fillFluids setting in nuker and better fluid removal logic in build sim. Also improved sorting for place contexts with a fluid level != 0

Author: beanbag44

common/src/main/kotlin/com/lambda/interaction/construction/context/PlaceContext.kt

@@ -50,6 +50,9 @@ data class PlaceContext(
         when (other) {
             is PlaceContext -> compareBy<PlaceContext> {
                 BlockUtils.fluids.indexOf(it.cachedState.fluidState.fluid)
+            }.thenByDescending {
+                if (it.cachedState.fluidState.level != 0) it.blockPos.y
+                else 0
             }.thenByDescending {
                 it.cachedState.fluidState.level
             }.thenBy {

common/src/main/kotlin/com/lambda/interaction/construction/simulation/BuildSimulator.kt

@@ -342,7 +342,15 @@ object BuildSimulator {
         val currentState = blockState(pos)
 
         val statePromoting = currentState.block is SlabBlock && targetState.matches(currentState, pos, world, preProcessing.ignore)
-        if (targetState.isEmpty() || (!currentState.isReplaceable && !statePromoting)) return acc
+        // If the target state is air then the only possible blocks it could place are to remove liquids so we use the Solid TargetState
+        val nextTargetState = if (targetState is TargetState.Air) {
+            TargetState.Solid
+        } else if (targetState.isEmpty()) {
+            // Otherwise if the target state is empty, there's no situation where placement would be required so we can return
+            return acc
+        } else targetState
+        // For example, slabs count as state promoting because you are placing another block to promote the current state to the target state
+        if (!currentState.isReplaceable && !statePromoting) return acc
 
         preProcessing.sides.forEach { neighbor ->
             val hitPos = if (!place.airPlace.isEnabled() && (currentState.isEmpty || statePromoting))
@@ -415,7 +423,7 @@ object BuildSimulator {
             }
 
             interactionConfig.pointSelection.select(validHits)?.let { checkedHit ->
-                val optimalStack = targetState.getStack(world, pos, inventory)
+                val optimalStack = nextTargetState.getStack(world, pos, inventory)
 
                 // ToDo: For each hand and sneak or not?
                 val fakePlayer = copyPlayer(player).apply {
@@ -424,6 +432,7 @@ object BuildSimulator {
 
                 val checkedResult = checkedHit.hit
 
+                // ToDo: Override the stack used for this to account for blocks where replaceability is dependent on the held item
                 val usageContext = ItemUsageContext(
                     fakePlayer,
                     Hand.MAIN_HAND,
@@ -476,8 +485,8 @@ object BuildSimulator {
                     resultState = blockItem.getPlacementState(context)
                         ?: return@placeState PlaceResult.BlockedByEntity(pos)
 
-                    return@placeState if (!targetState.matches(resultState, pos, world, preProcessing.ignore))
-                        PlaceResult.NoIntegrity(pos, resultState, context, (targetState as? TargetState.State)?.blockState)
+                    return@placeState if (!nextTargetState.matches(resultState, pos, world, preProcessing.ignore))
+                        PlaceResult.NoIntegrity(pos, resultState, context, (nextTargetState as? TargetState.State)?.blockState)
                     else null
                 }
 
@@ -638,12 +647,12 @@ object BuildSimulator {
                     if (fluidState.isEmpty || fluid !is FlowableFluid) return@forEach
 
                     if (offset == Direction.UP) {
-                        accumulator.put(offsetPos, offsetState)
+                        accumulator[offsetPos] = offsetState
                         return@fold accumulator
                     }
 
                     if (offsetState.block is Waterloggable && !fluidState.isEmpty) {
-                        accumulator.put(offsetPos, offsetState)
+                        accumulator[offsetPos] = offsetState
                         return@fold accumulator
                     }
 
@@ -663,17 +672,8 @@ object BuildSimulator {
                 return@fold accumulator
             }
 
-            /* block has liquids next to it that will leak when broken */
             if (affectedFluids.isNotEmpty()) {
                 acc.add(BreakResult.BlockedByFluid(pos, state))
-                affectedFluids.entries.forEach { fluid  ->
-                    val submerge = if (fluid.value.isReplaceable) {
-                        checkPlaceResults(fluid.key, eye, preProcessing, TargetState.Solid, build.placing, interactionConfig, rotation, inventory)
-                    } else {
-                        checkBreakResults(fluid.key, eye, preProcessing, breaking, interactionConfig, rotation, inventory, build)
-                    }
-                    acc.addAll(submerge)
-                }
                 return acc
             }
         }

common/src/main/kotlin/com/lambda/module/modules/player/Nuker.kt

@@ -28,7 +28,6 @@ import com.lambda.task.tasks.BuildTask.Companion.build
 import com.lambda.util.BaritoneUtils
 import com.lambda.util.BlockUtils.blockPos
 import com.lambda.util.BlockUtils.blockState
-import com.lambda.util.BlockUtils.isNotEmpty
 import net.minecraft.util.math.BlockPos
 
 object Nuker : Module(
@@ -39,6 +38,7 @@ object Nuker : Module(
     private val height by setting("Height", 4, 1..8, 1)
     private val width by setting("Width", 4, 1..8, 1)
     private val flatten by setting("Flatten", true)
+    private val fillFluids by setting("Fill Fluids", false, "Removes liquids by filling them in before breaking")
     private val instantOnly by setting("Instant Only", false)
     private val fillFloor by setting("Fill Floor", false)
     private val baritoneSelection by setting("Baritone Selection", false, "Restricts nuker to your baritone selection")
@@ -51,7 +51,7 @@ object Nuker : Module(
                 val selection = BlockPos.iterateOutwards(player.blockPos, width, height, width)
                     .asSequence()
                     .map { it.blockPos }
-                    .filter { blockState(it).isNotEmpty }
+                    .filter { !blockState(it).isAir }
                     .filter { !flatten || it.y >= player.blockPos.y }
                     .filter { !instantOnly || blockState(it).getHardness(world, it) <= TaskFlowModule.build.breaking.breakThreshold }
                     .filter { pos ->
@@ -64,7 +64,7 @@ object Nuker : Module(
                                     && pos.z >= min.z && pos.z <= max.z
                         }
                     }
-                    .associateWith { TargetState.Air }
+                    .associateWith { if (fillFluids) TargetState.Air else TargetState.Empty }
 
                 if (fillFloor) {
                     val floor = BlockPos.iterateOutwards(player.blockPos.down(), width, 0, width)

common/src/main/kotlin/com/lambda/util/BlockUtils.kt

@@ -230,10 +230,10 @@ object BlockUtils {
     )
 
     val fluids = listOf(
-        Fluids.LAVA,
         Fluids.FLOWING_LAVA,
-        Fluids.WATER,
+        Fluids.LAVA,
         Fluids.FLOWING_WATER,
+        Fluids.WATER,
         Fluids.EMPTY,
     )