sim cleanup and improvement

Author: beanbag44

src/main/kotlin/com/lambda/config/groups/BreakSettings.kt

@@ -76,7 +76,6 @@ class BreakSettings(
     // Block
     override val avoidLiquids by c.setting("Avoid Liquids", true, "Avoids breaking blocks that would cause liquid to spill", visibility = vis).group(baseGroup, Group.General)
     override val avoidSupporting by c.setting("Avoid Supporting", true, "Avoids breaking the block supporting the player", visibility = vis).group(baseGroup, Group.General)
-    override val breakWeakBlocks by c.setting("Break Weak Blocks", false, "Break blocks that dont have structural integrity (e.g: grass)", visibility = vis).group(baseGroup, Group.General)
     override val ignoredBlocks by c.setting("Ignored Blocks", allSigns, description = "Blocks that wont be broken", visibility = vis).group(baseGroup, Group.General)
 
     // Tool

src/main/kotlin/com/lambda/interaction/construction/context/BreakContext.kt

@@ -43,11 +43,10 @@ import kotlin.random.Random
 data class BreakContext(
     override val hitResult: BlockHitResult,
     override val rotationRequest: RotationRequest,
-    override var hotbarIndex: Int,
-    var itemSelection: StackSelection,
-    var instantBreak: Boolean,
+    override val hotbarIndex: Int,
+    val itemSelection: StackSelection,
+    val instantBreak: Boolean,
     override var cachedState: BlockState,
-    val sortMode: BreakConfig.SortMode,
     private val automated: Automated
 ) : BuildContext(), LogContext, Automated by automated {
     private val baseColor = Color(222, 0, 0, 25)
@@ -61,10 +60,10 @@ data class BreakContext(
     override fun compareTo(other: BuildContext): Int = runSafe {
         return when (other) {
             is BreakContext -> compareByDescending<BreakContext> {
-                if (sortMode == BreakConfig.SortMode.Tool) it.hotbarIndex == HotbarManager.serverSlot
+                if (breakConfig.sorter == BreakConfig.SortMode.Tool) it.hotbarIndex == HotbarManager.serverSlot
                 else 0
             }.thenBy {
-                when (sortMode) {
+                when (breakConfig.sorter) {
                     BreakConfig.SortMode.Tool,
                     BreakConfig.SortMode.Closest -> player.eyePos.distance(it.hitResult.pos, it.cachedState.block)
                     BreakConfig.SortMode.Farthest -> -player.eyePos.distance(it.hitResult.pos, it.cachedState.block)
@@ -104,7 +103,6 @@ data class BreakContext(
             value("Instant Break", instantBreak)
             value("Cached State", cachedState)
             value("Expected State", expectedState)
-            value("Sort Mode", sortMode)
         }
     }
 }

src/main/kotlin/com/lambda/interaction/construction/processing/ProcessorRegistry.kt

@@ -21,8 +21,6 @@ import com.lambda.core.Loadable
 import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.util.reflections.getInstances
 import net.minecraft.block.BlockState
-import net.minecraft.block.SlabBlock
-import net.minecraft.block.enums.SlabType
 import net.minecraft.state.property.Properties
 import net.minecraft.util.math.BlockPos
 
@@ -108,7 +106,8 @@ object ProcessorRegistry : Loadable {
     override fun load() = "Loaded ${processors.size} pre processors"
 
     fun TargetState.getProcessingInfo(pos: BlockPos) =
-        if (this is TargetState.State) {
+        if (this !is TargetState.State) PreProcessingInfo.DEFAULT
+        else {
             val get: () -> PreProcessingInfo? = get@{
                 val infoAccumulator = PreProcessingInfoAccumulator()
 
@@ -122,15 +121,6 @@ object ProcessorRegistry : Loadable {
 
                 infoAccumulator.complete()
             }
-            if (isExemptFromCache()) {
-                get()
-            } else {
-                processorCache.getOrPut(blockState, get)
-            }
-        } else {
-            PreProcessingInfo.DEFAULT
+            processorCache.getOrPut(blockState, get)
         }
-
-    private fun TargetState.State.isExemptFromCache() =
-        blockState.block is SlabBlock && blockState.get(Properties.SLAB_TYPE) == SlabType.DOUBLE
 }

src/main/kotlin/com/lambda/interaction/construction/result/Dependable.kt

@@ -17,8 +17,8 @@
 
 package com.lambda.interaction.construction.result
 
-import com.lambda.interaction.construction.simulation.SimInfo
+import com.lambda.interaction.construction.simulation.ISimInfo
 
-interface Dependable {
-    fun SimInfo.asDependent(buildResult: BuildResult): BuildResult
+interface Dependable : ISimInfo {
+    fun asDependent(buildResult: BuildResult): BuildResult
 }

src/main/kotlin/com/lambda/interaction/construction/result/Rank.kt

@@ -31,7 +31,6 @@ enum class Rank {
     ChunkNotLoaded,
     PlaceCantReplace,
     BreakPlayerOnTop,
-    PlaceNotItemBlock,
 
     // not solvable
     OutOfWorld,
@@ -50,7 +49,4 @@ enum class Rank {
     Done,
     Ignored,
     NoMatch;
-
-    val solvable: Boolean
-        get() = ordinal < PlaceNotItemBlock.ordinal
 }

src/main/kotlin/com/lambda/interaction/construction/result/results/GenericResult.kt

@@ -20,7 +20,6 @@ package com.lambda.interaction.construction.result.results
 import baritone.api.pathing.goals.GoalNear
 import com.lambda.context.Automated
 import com.lambda.graphics.renderer.esp.ShapeBuilder
-import com.lambda.interaction.construction.context.BuildContext
 import com.lambda.interaction.construction.result.BuildResult
 import com.lambda.interaction.construction.result.ComparableResult
 import com.lambda.interaction.construction.result.Drawable
@@ -82,7 +81,6 @@ sealed class GenericResult : BuildResult() {
      */
     data class WrongItemSelection(
         override val pos: BlockPos,
-        val context: BuildContext,
         val neededSelection: StackSelection,
         val currentItem: ItemStack
     ) : Drawable, Resolvable, GenericResult() {
@@ -102,13 +100,6 @@ sealed class GenericResult : BuildResult() {
         override fun ShapeBuilder.buildRenderer() {
             box(pos, color, color)
         }
-
-        override fun compareResult(other: ComparableResult<Rank>): Int {
-            return when (other) {
-                is WrongItemSelection -> context.compareTo(other.context)
-                else -> super.compareResult(other)
-            }
-        }
     }
 
     /**

src/main/kotlin/com/lambda/interaction/construction/result/results/PlaceResult.kt

@@ -182,20 +182,6 @@ sealed class PlaceResult : BuildResult() {
         override val rank = Rank.PlaceIllegalUsage
     }
 
-    /**
-     * Represents the result of a place operation where the provided item does not match the expected item block type.
-     *
-     * @property pos The position of the block where the operation was attempted.
-     * @property itemStack The item stack that was checked during the place operation.
-     */
-    data class NotItemBlock(
-        override val pos: BlockPos,
-        val itemStack: ItemStack,
-    ) : PlaceResult() {
-        override val name: String get() = "${this::class.simpleName} at ${pos.toShortString()}"
-        override val rank = Rank.PlaceNotItemBlock
-    }
-
     data class Dependency(
         override val pos: BlockPos,
         override val dependency: BuildResult

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

@@ -19,46 +19,45 @@ package com.lambda.interaction.construction.simulation
 
 import com.lambda.context.AutomatedSafeContext
 import com.lambda.interaction.construction.blueprint.Blueprint
-import com.lambda.interaction.construction.processing.ProcessorRegistry.getProcessingInfo
 import com.lambda.interaction.construction.result.BuildResult
 import com.lambda.interaction.construction.result.results.PostSimResult
-import com.lambda.interaction.construction.simulation.checks.BreakChecks.checkBreaks
-import com.lambda.interaction.construction.simulation.checks.PlaceChecks.checkPlacements
-import com.lambda.interaction.construction.simulation.checks.PostProcessingChecks.checkPostProcessing
+import com.lambda.interaction.construction.simulation.ISimInfo.Companion.simInfo
+import com.lambda.interaction.construction.simulation.checks.BreakChecker.Companion.checkBreaks
+import com.lambda.interaction.construction.simulation.checks.PlaceChecker.Companion.checkPlacements
+import com.lambda.interaction.construction.simulation.checks.PostProcessingChecker.Companion.checkPostProcessing
 import com.lambda.interaction.construction.simulation.checks.RequirementChecks.checkRequirements
 import com.lambda.util.BlockUtils.blockState
 import io.ktor.util.collections.*
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.joinAll
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 
 object BuildSimulator : SimChecker<PostSimResult>() {
-    context(context: AutomatedSafeContext)
+    context(automatedSafeContext: AutomatedSafeContext)
     fun Blueprint.simulate(): Set<BuildResult> = runBlocking(Dispatchers.Default) {
         val concurrentSet = ConcurrentSet<BuildResult>()
-        with(context) {
+        with(automatedSafeContext) {
             structure.entries
                 .map { (pos, targetState) ->
-                    async {
-                        val preProcessing = targetState.getProcessingInfo(pos) ?: return@async
-                        val simInfo = SimInfo(
+                    launch {
+                        val simInfo = simInfo(
                             pos,
                             blockState(pos),
                             targetState,
-                            preProcessing,
                             concurrentSet
-                        )
+                        ) ?: return@launch
                         with(simInfo) {
                             with(null) {
-                                checkRequirements()
-                                checkPostProcessing()
-                                checkPlacements()
-                                checkBreaks()
+                                if (checkRequirements() ||
+                                    checkPostProcessing() ||
+                                    checkPlacements() ||
+                                    checkBreaks()) return@launch
+                                else result(PostSimResult.NoMatch(pos))
                             }
                         }
                     }
-                }.awaitAll()
+                }.joinAll()
         }
 
         return@runBlocking concurrentSet

src/main/kotlin/com/lambda/interaction/construction/simulation/ISimInfo.kt

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lambda.interaction.construction.simulation
+
+import com.lambda.context.Automated
+import com.lambda.interaction.construction.processing.PreProcessingInfo
+import com.lambda.interaction.construction.processing.ProcessorRegistry.getProcessingInfo
+import com.lambda.interaction.construction.result.BuildResult
+import com.lambda.interaction.construction.result.Dependable
+import com.lambda.interaction.construction.verify.TargetState
+import net.minecraft.block.BlockState
+import net.minecraft.util.math.BlockPos
+import java.util.*
+
+interface ISimInfo : Automated {
+    val pos: BlockPos
+    val state: BlockState
+    val targetState: TargetState
+    val preProcessing: PreProcessingInfo
+    val concurrentResults: MutableSet<BuildResult>
+    val dependencyStack: Stack<Dependable>
+
+    companion object {
+        @SimCheckerDsl
+        fun Automated.simInfo(
+            pos: BlockPos,
+            state: BlockState,
+            targetState: TargetState,
+            concurrentResults: MutableSet<BuildResult>,
+        ): SimInfo? {
+            val preProcessingInfo = targetState.getProcessingInfo(pos) ?: return null
+            return SimInfo(pos, state, targetState, preProcessingInfo, concurrentResults, this)
+        }
+
+        @SimCheckerDsl
+        fun ISimInfo.simInfo(
+            pos: BlockPos = this.pos,
+            state: BlockState = this.state,
+            targetState: TargetState = this.targetState,
+            concurrentResults: MutableSet<BuildResult> = this.concurrentResults
+        ): SimInfo? {
+            val preProcessingInfo = targetState.getProcessingInfo(pos) ?: return null
+            return SimInfo(pos, state, targetState, preProcessingInfo, concurrentResults, this)
+        }
+    }
+}
+
+data class SimInfo(
+    override val pos: BlockPos,
+    override val state: BlockState,
+    override val targetState: TargetState,
+    override val preProcessing: PreProcessingInfo,
+    override val concurrentResults: MutableSet<BuildResult>,
+    val automated: Automated
+) : ISimInfo, Automated by automated {
+    override val dependencyStack = Stack<Dependable>()
+}

src/main/kotlin/com/lambda/interaction/construction/simulation/SimChecker.kt

@@ -23,21 +23,28 @@ import com.lambda.interaction.construction.result.Dependable
 import com.lambda.interaction.construction.result.results.GenericResult
 import net.minecraft.util.math.Vec3d
 
+@DslMarker
+annotation class SimCheckerDsl
+
+@SimCheckerDsl
 abstract class SimChecker<T : BuildResult> {
     val SafeContext.eye: Vec3d get() = player.eyePos
 
-    fun SimInfo.checkDependent(caller: Dependable?) {
+    protected fun ISimInfo.checkDependent(caller: Dependable?) {
         if (caller == null) {
             dependencyStack.clear()
             return
         }
         dependencyStack.push(caller)
     }
 
-    fun SimInfo.result(result: GenericResult) = addResult(result)
-    fun SimInfo.result(result: T) = addResult(result)
-    private fun SimInfo.addResult(result: BuildResult) {
-        concurrentResults.add(
+    fun ISimInfo.result(result: GenericResult) = addResult(result)
+
+    fun ISimInfo.result(result: T) = addResult(result)
+
+    private fun ISimInfo.addResult(result: BuildResult) {
+        if (this@SimChecker is BuildSimulator) concurrentResults.add(result)
+        else concurrentResults.add(
             dependencyStack
                 .asReversed()
                 .fold(result) { acc, dependable ->