replacement blocks for solid target state, and fixed race condition issue in place checker

beanbag44 · beanbag44 · commit c2dd7d7e5355 · 2025-10-24T15:31:02.000+01:00
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/BuildSimulator.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/BuildSimulator.kt
@@ -51,8 +51,8 @@ object BuildSimulator : SimChecker<PostSimResult>() {
                             with(null) {
                                 if (checkRequirements() ||
                                     checkPostProcessing() ||
-                                    checkPlacements() ||
-                                    checkBreaks()) return@launch
+                                    checkBreaks() ||
+                                    checkPlacements()) return@launch
                                 else result(PostSimResult.NoMatch(pos))
                             }
                         }
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/checks/BreakChecker.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/checks/BreakChecker.kt
@@ -50,6 +50,7 @@ import com.lambda.threading.runSafe
 import com.lambda.util.BlockUtils.blockState
 import com.lambda.util.BlockUtils.calcItemBlockBreakingDelta
 import com.lambda.util.BlockUtils.instantBreakable
+import com.lambda.util.BlockUtils.isEmpty
 import com.lambda.util.item.ItemStackUtils.inventoryIndexOrSelected
 import com.lambda.util.math.distSq
 import com.lambda.util.world.raycast.RayCastUtils.blockResult
@@ -87,6 +88,7 @@ class BreakChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
     val stackSelection: StackSelection by lazy {
         runSafe {
             selectStack(
+                count = 0,
                 sorter = compareByDescending<ItemStack> {
                     it.canBreak(CachedBlockPosition(world, pos, false))
                 }.thenByDescending {
@@ -131,8 +133,6 @@ class BreakChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
     }
 
     private suspend fun AutomatedSafeContext.checkBreaks(): Boolean {
-        if (!targetState.isEmpty()) return false
-
         /* player is standing on top of the block */
         if (breakConfig.avoidSupporting) player.supportingBlockPos.getOrNull()?.let { support ->
             if (support != pos) return@let
@@ -143,9 +143,11 @@ class BreakChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
         /* liquid needs to be submerged first to be broken */
         if (targetState.getState(pos).isAir && !state.fluidState.isEmpty && state.isReplaceable) {
             result(BreakResult.Submerge(pos, state))
-            return simInfo(pos, state, TargetState.Solid)?.checkPlacements() ?: true
+            return simInfo(pos, state, TargetState.Solid(emptySet()))?.checkPlacements() ?: true
         }
 
+        if (state.isEmpty) return false
+
         if (breakConfig.avoidLiquids && affectsFluids()) return true
 
         val voxelShape = state.getOutlineShape(world, pos)
@@ -159,11 +161,9 @@ class BreakChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
             breakConfig.breakThreshold
         )
 
-        val currentRotation = RotationManager.activeRotation
-        val currentCast = currentRotation.rayCast(buildConfig.interactReach, eye)
-
         /* the player is buried inside the block */
         if (boxes.any { it.contains(eye) }) {
+            val currentCast = RotationManager.activeRotation.rayCast(buildConfig.interactReach, eye)
             currentCast?.blockResult?.let { blockHit ->
                 val rotationRequest = RotationRequest(lookAtBlock(pos), this)
                 val breakContext = BreakContext(
@@ -336,7 +336,7 @@ class BreakChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
 
             affectedFluids.forEach { (liquidPos, liquidState) ->
                 result(BreakResult.Submerge(liquidPos, liquidState))
-                simInfo(liquidPos, liquidState, TargetState.Solid)?.checkPlacements()
+                simInfo(liquidPos, liquidState, TargetState.Solid(emptySet()))?.checkPlacements()
             }
             result(BreakResult.BlockedByFluid(pos, state))
             return true
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/checks/PlaceChecker.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/checks/PlaceChecker.kt
@@ -33,6 +33,7 @@ import com.lambda.interaction.material.ContainerSelection.Companion.selectContai
 import com.lambda.interaction.material.StackSelection.Companion.select
 import com.lambda.interaction.material.container.ContainerManager.containerWithMaterial
 import com.lambda.interaction.material.container.MaterialContainer
+import com.lambda.interaction.request.rotating.Rotation
 import com.lambda.interaction.request.rotating.Rotation.Companion.rotation
 import com.lambda.interaction.request.rotating.Rotation.Companion.rotationTo
 import com.lambda.interaction.request.rotating.RotationManager
@@ -78,9 +79,6 @@ class PlaceChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
     : SimChecker<PlaceResult>(), Dependable,
     ISimInfo by simInfo
 {
-    lateinit var resultState: BlockState
-    var rot = RotationManager.serverRotation
-
     private val swapStack by lazy {
         runSafeAutomated {
             val optimalStack = targetState.getStack(pos)
@@ -104,8 +102,6 @@ class PlaceChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
     }
     private val blockItem get() = swapStack.blockItem
 
-    private var currentDirIsValid = false
-
     override fun asDependent(buildResult: BuildResult) =
         PlaceResult.Dependency(pos, buildResult)
 
@@ -120,8 +116,6 @@ class PlaceChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
     }
 
     private suspend fun AutomatedSafeContext.checkPlacements(): Boolean {
-        if (targetState.isEmpty()) return false
-
         supervisorScope {
             withContext(Dispatchers.Default) {
                 preProcessing.sides.map { side ->
@@ -155,7 +149,7 @@ class PlaceChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
         val misses = mutableSetOf<Vec3d>()
         val reachSq = buildConfig.interactReach.pow(2)
 
-        // ToDo: For each hand and sneak or not?
+        // ToDo: For each hand
         val fakePlayer = copyPlayer(player).apply {
             this.rotation = RotationManager.serverRotation
             if (testBlockState.block::class in BlockUtils.interactionBlocks) {
@@ -249,22 +243,23 @@ class PlaceChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
                 return
             }
 
-            if (!simRotation(fakePlayer, checkedHit, context)) return
+            val rotatePlaceTest = simRotatePlace(fakePlayer, checkedHit, context) ?: return
+            if (!rotatePlaceTest.isValid) return
 
             val rotationRequest = if (placeConfig.axisRotate) {
-                lookInDirection(PlaceDirection.fromRotation(rot))
-            } else lookAt(rot, 0.001)
+                lookInDirection(PlaceDirection.fromRotation(rotatePlaceTest.rotation))
+            } else lookAt(rotatePlaceTest.rotation, 0.001)
 
             val placeContext = PlaceContext(
                 hitResult,
                 RotationRequest(rotationRequest, this@PlaceChecker),
                 swapStack.inventoryIndex,
                 pos,
                 state,
-                resultState,
+                rotatePlaceTest.placeTest.resultState,
                 fakePlayer.isSneaking,
                 false,
-                currentDirIsValid,
+                rotatePlaceTest.currentDirIsValid,
                 this@PlaceChecker
             )
 
@@ -274,61 +269,64 @@ class PlaceChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
         return
     }
 
-    private fun SafeContext.simRotation(
+    private fun SafeContext.simRotatePlace(
         fakePlayer: ClientPlayerEntity,
         checkedHit: CheckedHit,
         context: ItemPlacementContext
-    ): Boolean {
-        currentDirIsValid = if (testPlaceState(context) != PlaceTestResult.Success) {
-            if (!placeConfig.rotateForPlace) return false
-            else false
-        } else true
+    ): RotatePlaceTest? {
+        val currentDirIsValid = testPlaceState(context).let { currentDirTest ->
+            if (currentDirTest.testResult != PlaceTestResult.Success) {
+                if (!placeConfig.rotateForPlace)
+                    return RotatePlaceTest(currentDirTest, false, fakePlayer.rotation)
+                else false
+            } else true
+        }
 
         if (!placeConfig.axisRotate) {
             fakePlayer.rotation = checkedHit.targetRotation
-            if (testPlaceState(context) != PlaceTestResult.Success) return false
-            rot = fakePlayer.rotation
-            return true
+            return RotatePlaceTest(testPlaceState(context), currentDirIsValid, fakePlayer.rotation)
         }
 
         fakePlayer.rotation = player.rotation
-        if (testPlaceState(context) == PlaceTestResult.Success) {
-            rot = fakePlayer.rotation
-            return true
+        testPlaceState(context).let { playerRotTest ->
+            if (playerRotTest.testResult == PlaceTestResult.Success)
+                return RotatePlaceTest(playerRotTest, currentDirIsValid, fakePlayer.rotation)
         }
 
         PlaceDirection.entries.asReversed().forEachIndexed direction@{ index, direction ->
             fakePlayer.rotation = direction.rotation
-            when (testPlaceState(context)) {
+            val axisRotateTest = testPlaceState(context)
+            when (axisRotateTest.testResult) {
                 PlaceTestResult.BlockedByEntity -> return@direction
 
                 PlaceTestResult.NoIntegrity -> {
                     if (index != PlaceDirection.entries.lastIndex) return@direction
-                    return false
+                    return RotatePlaceTest(axisRotateTest, currentDirIsValid, fakePlayer.rotation)
                 }
 
-                else -> {
-                    rot = fakePlayer.rotation
-                    return true
-                }
+                else -> return RotatePlaceTest(axisRotateTest, currentDirIsValid, fakePlayer.rotation)
             }
         }
 
-        return true
+        return null
     }
 
-    private fun SafeContext.testPlaceState(context: ItemPlacementContext): PlaceTestResult {
-        resultState = blockItem.getPlacementState(context) ?: run {
+    private fun SafeContext.testPlaceState(context: ItemPlacementContext): PlaceTest {
+        val resultState = blockItem.getPlacementState(context) ?: run {
             result(PlaceResult.BlockedByEntity(pos))
-            return PlaceTestResult.BlockedByEntity
+            return PlaceTest(state, PlaceTestResult.BlockedByEntity)
         }
 
         return if (!targetState.matches(resultState, pos, preProcessing.ignore)) {
             result(PlaceResult.NoIntegrity(pos, resultState, context, (targetState as? TargetState.State)?.blockState))
-            PlaceTestResult.NoIntegrity
-        } else PlaceTestResult.Success
+            PlaceTest(resultState, PlaceTestResult.NoIntegrity)
+        } else PlaceTest(resultState, PlaceTestResult.Success)
     }
 
+    private data class RotatePlaceTest(val placeTest: PlaceTest, val currentDirIsValid: Boolean, val rotation: Rotation) {
+        val isValid = placeTest.testResult == PlaceTestResult.Success
+    }
+    private data class PlaceTest(val resultState: BlockState, val testResult: PlaceTestResult)
     private enum class PlaceTestResult {
         Success,
         BlockedByEntity,
diff --git a/src/main/kotlin/com/lambda/interaction/construction/verify/TargetState.kt b/src/main/kotlin/com/lambda/interaction/construction/verify/TargetState.kt
@@ -78,21 +78,21 @@ sealed class TargetState(val type: Type) : StateMatcher {
         override fun isEmpty() = true
     }
 
-    data object Solid : TargetState(Type.Solid) {
+    data class Solid(val replace: Set<net.minecraft.block.Block>) : TargetState(Type.Solid) {
         override fun toString() = "Solid"
 
         context(safeContext: SafeContext)
         override fun matches(
             state: BlockState,
             pos: BlockPos,
             ignoredProperties: Collection<Property<*>>
-        ) = with(safeContext) { state.isSolidBlock(world, pos) }
+        ) = with(safeContext) { state.isSolidBlock(world, pos) && state.block !in replace }
 
         context(automatedSafeContext: AutomatedSafeContext)
         override fun getStack(pos: BlockPos) =
             with(automatedSafeContext) {
                 findDisposable()?.stacks?.firstOrNull {
-                    it.item.block in inventoryConfig.disposables
+                    it.item.block in inventoryConfig.disposables && it.item.block !in replace
                 } ?: ItemStack(Items.NETHERRACK)
             }
 
diff --git a/src/main/kotlin/com/lambda/module/modules/player/HighwayTools.kt b/src/main/kotlin/com/lambda/module/modules/player/HighwayTools.kt
@@ -81,6 +81,7 @@ object HighwayTools : Module(
     private val wallMaterial by setting("Wall Material", Blocks.NETHERRACK, "Material to build the walls with") { rightWall == Material.Block || leftWall == Material.Block }.group(Group.Structure)
     private val ceiling by setting("Ceiling", Material.None, "Material for the ceiling").group(Group.Structure)
     private val ceilingMaterial by setting("Ceiling Material", Blocks.OBSIDIAN, "Material to build the ceiling with") { ceiling == Material.Block }.group(Group.Structure)
+    private val replaceableSolids by setting("Replaceable Solids", setOf(Blocks.MAGMA_BLOCK, Blocks.SOUL_SAND)).group(Group.Structure)
     private val distance by setting("Distance", -1, -1..1000000, 1, "Distance to build the highway/tunnel (negative for infinite)").group(Group.Structure)
     private val sliceSize by setting("Slice Size", 3, 1..5, 1, "Number of slices to build at once").group(Group.Structure)
 
@@ -265,11 +266,10 @@ object HighwayTools : Module(
         return transformed
     }
 
-    private fun target(target: Material, material: net.minecraft.block.Block): TargetState {
-        return when (target) {
-            Material.Solid -> TargetState.Solid
+    private fun target(target: Material, material: net.minecraft.block.Block) =
+        when (target) {
+            Material.Solid -> TargetState.Solid(replaceableSolids)
             Material.Block -> TargetState.Block(material)
             else -> throw IllegalStateException("Invalid material")
         }
-    }
 }
diff --git a/src/main/kotlin/com/lambda/module/modules/player/Nuker.kt b/src/main/kotlin/com/lambda/module/modules/player/Nuker.kt
@@ -17,7 +17,6 @@
 
 package com.lambda.module.modules.player
 
-import com.lambda.context.AutomationConfig
 import com.lambda.interaction.BaritoneManager
 import com.lambda.interaction.construction.blueprint.TickingBlueprint.Companion.tickingBlueprint
 import com.lambda.interaction.construction.verify.TargetState
@@ -27,7 +26,7 @@ import com.lambda.task.RootTask.run
 import com.lambda.task.Task
 import com.lambda.task.tasks.BuildTask.Companion.build
 import com.lambda.util.BlockUtils.blockPos
-import com.lambda.util.BlockUtils.blockState
+import net.minecraft.block.Blocks
 import net.minecraft.util.math.BlockPos
 
 object Nuker : Module(
@@ -39,7 +38,6 @@ object Nuker : Module(
     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")
 
@@ -53,7 +51,6 @@ object Nuker : Module(
                     .map { it.blockPos }
                     .filter { !world.isAir(it) }
                     .filter { !flatten || it.y >= player.blockPos.y }
-                    .filter { !instantOnly || blockState(it).getHardness(world, it) <= AutomationConfig.breakConfig.breakThreshold }
                     .filter { pos ->
                         if (!baritoneSelection) true
                         else BaritoneManager.primary.selectionManager.selections.any {
@@ -69,7 +66,7 @@ object Nuker : Module(
                 if (fillFloor) {
                     val floor = BlockPos.iterateOutwards(player.blockPos.down(), width, 0, width)
                         .map { it.blockPos }
-                        .associateWith { TargetState.Solid }
+                        .associateWith { TargetState.Solid(setOf(Blocks.MAGMA_BLOCK)) }
                     return@tickingBlueprint selection + floor
                 }
 
diff --git a/src/main/kotlin/com/lambda/module/modules/player/Scaffold.kt b/src/main/kotlin/com/lambda/module/modules/player/Scaffold.kt
@@ -92,7 +92,7 @@ object Scaffold : Module(
             val beneath = playerSupport.down(offset)
             runSafeAutomated {
                 scaffoldPositions(beneath)
-                    .associateWith { TargetState.Solid }
+                    .associateWith { TargetState.Solid(emptySet()) }
                     .toBlueprint()
                     .simulate()
                     .filterIsInstance<PlaceResult.Place>()

Original file line number	Diff line number	Diff line change
`@@ -51,8 +51,8 @@ object BuildSimulator : SimChecker<PostSimResult>() {`
`51`	`51`	`with(null) {`
`52`	`52`	`if (checkRequirements() \|\|`
`53`	`53`	`checkPostProcessing() \|\|`
`54`		`- checkPlacements() \|\|`
`55`		`- checkBreaks()) return@launch`
	`54`	`+ checkBreaks() \|\|`
	`55`	`+ checkPlacements()) return@launch`
`56`	`56`	`else result(PostSimResult.NoMatch(pos))`
`57`	`57`	`}`
`58`	`58`	`}`