Improvement: Build Simulator

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

@@ -76,10 +76,10 @@ 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
+    override val efficientOnly by c.setting("Efficient Tools Only", true, "Only use tools suitable for the given block (will get the item drop)") { vis() && swapMode.isEnabled() }.group(baseGroup, Group.General)
     override val suitableToolsOnly by c.setting("Suitable Tools Only", true, "Only use tools suitable for the given block (will get the item drop)") { vis() && swapMode.isEnabled() }.group(baseGroup, Group.General)
     override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks") { vis() && swapMode.isEnabled() }.group(baseGroup, Group.General)
     override val forceFortunePickaxe by c.setting("Force Fortune Pickaxe", false, "Force fortune pickaxe when breaking blocks") { vis() && swapMode.isEnabled() }.group(baseGroup, Group.General)

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

@@ -47,8 +47,8 @@ class BuildSettings(
 
     override val scanReach: Double get() = max(attackReach, interactReach)
 
-    override val strictRayCast by c.setting("Strict Raycast", false, "Whether to include the environment to the ray cast context", vis).group(*baseGroup, Group.Scan)
     override val checkSideVisibility by c.setting("Visibility Check", true, "Whether to check if an AABB side is visible", vis).group(*baseGroup, Group.Scan)
+    override val strictRayCast by c.setting("Strict Raycast", false, "Whether to include the environment to the ray cast context", vis).group(*baseGroup, Group.Scan)
     override val resolution by c.setting("Resolution", 5, 1..20, 1, "The amount of grid divisions per surface of the hit box", "", vis).group(*baseGroup, Group.Scan)
     override val pointSelection by c.setting("Point Selection", PointSelection.Optimum, "The strategy to select the best hit point", vis).group(*baseGroup, Group.Scan)
 

src/main/kotlin/com/lambda/context/AutomationConfig.kt

@@ -62,6 +62,7 @@ object AutomationConfig : Configurable(LambdaConfig), Automated {
     val showAllEntries by setting("Show All Entries", false, "Show all entries in the task tree").group(Group.Debug)
     val shrinkFactor by setting("Shrink Factor", 0.001, 0.0..1.0, 0.001).group(Group.Debug)
     val ignoreItemDropWarnings by setting("Ignore Drop Warnings", false, "Hides the item drop warnings from the break manager").group(Group.Debug)
+    val maxSimDependencies by setting("Max Sim Dependencies", 3, 0..10, 1, "Maximum dependency build results").group(Group.Debug)
 
     @Volatile
     var drawables = listOf<Drawable>()

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

@@ -41,34 +41,34 @@ import kotlin.math.sqrt
 import kotlin.random.Random
 
 data class BreakContext(
-    override val result: BlockHitResult,
-    override val rotation: RotationRequest,
-    override var hotbarIndex: Int,
-    var itemSelection: StackSelection,
-    var instantBreak: Boolean,
+    override val hitResult: BlockHitResult,
+    override val rotationRequest: RotationRequest,
+    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)
     private val sideColor = Color(222, 0, 0, 100)
 
-    override val blockPos: BlockPos = result.blockPos
+    override val blockPos: BlockPos = hitResult.blockPos
     override val expectedState = cachedState.emptyState
 
     val random = Random.nextDouble()
 
     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.result.pos, it.cachedState.block)
-                    BreakConfig.SortMode.Farthest -> -player.eyePos.distance(it.result.pos, it.cachedState.block)
-                    BreakConfig.SortMode.Rotation -> it.rotation.target.angleDistance
+                    BreakConfig.SortMode.Closest -> player.eyePos.distance(it.hitResult.pos, it.cachedState.block)
+                    BreakConfig.SortMode.Farthest -> -player.eyePos.distance(it.hitResult.pos, it.cachedState.block)
+                    BreakConfig.SortMode.Rotation -> it.rotationRequest.target.angleDistance
                     BreakConfig.SortMode.Random -> it.random
                 }
             }.thenByDescending {
@@ -92,19 +92,18 @@ data class BreakContext(
     }
 
     override fun ShapeBuilder.buildRenderer() {
-        box(blockPos, cachedState, baseColor, sideColor, DirectionMask.ALL.exclude(result.side))
+        box(blockPos, cachedState, baseColor, sideColor, DirectionMask.ALL.exclude(hitResult.side))
     }
 
     override fun getLogContextBuilder(): LogContextBuilder.() -> Unit = {
         group("Break Context") {
             text(blockPos.getLogContextBuilder())
-            text(result.getLogContextBuilder())
-            text(rotation.getLogContextBuilder())
+            text(hitResult.getLogContextBuilder())
+            text(rotationRequest.getLogContextBuilder())
             value("Hotbar Index", hotbarIndex)
             value("Instant Break", instantBreak)
             value("Cached State", cachedState)
             value("Expected State", expectedState)
-            value("Sort Mode", sortMode)
         }
     }
 }

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

@@ -26,14 +26,14 @@ import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
 
 abstract class BuildContext : Comparable<BuildContext>, Drawable, Automated {
-    abstract val result: BlockHitResult
-    abstract val rotation: RotationRequest
+    abstract val hitResult: BlockHitResult
+    abstract val rotationRequest: RotationRequest
     abstract val hotbarIndex: Int
     abstract val cachedState: BlockState
     abstract val expectedState: BlockState
     abstract val blockPos: BlockPos
 
     val distance by lazy {
-        runSafe { player.eyePos.distanceTo(result.pos) } ?: Double.MAX_VALUE
+        runSafe { player.eyePos.distanceTo(hitResult.pos) } ?: Double.MAX_VALUE
     }
 }

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

@@ -35,8 +35,8 @@ import net.minecraft.util.math.BlockPos
 import java.awt.Color
 
 class InteractionContext(
-    override val result: BlockHitResult,
-    override val rotation: RotationRequest,
+    override val hitResult: BlockHitResult,
+    override val rotationRequest: RotationRequest,
     override var hotbarIndex: Int,
     override var cachedState: BlockState,
     override val expectedState: BlockState,
@@ -45,7 +45,7 @@ class InteractionContext(
     private val baseColor = Color(35, 254, 79, 25)
     private val sideColor = Color(35, 254, 79, 100)
 
-    override val blockPos: BlockPos = result.blockPos
+    override val blockPos: BlockPos = hitResult.blockPos
 
     override fun compareTo(other: BuildContext) =
         when {
@@ -54,7 +54,7 @@ class InteractionContext(
             }.thenByDescending {
                 it.cachedState.fluidState.level
             }.thenBy {
-                it.rotation.target.angleDistance
+                it.rotationRequest.target.angleDistance
             }.thenBy {
                 it.hotbarIndex == HotbarManager.serverSlot
             }.thenBy {
@@ -65,20 +65,20 @@ class InteractionContext(
         }
 
     override fun ShapeBuilder.buildRenderer() {
-        box(blockPos, expectedState, baseColor, sideColor, result.side.mask)
+        box(blockPos, expectedState, baseColor, sideColor, hitResult.side.mask)
     }
 
     fun requestDependencies(request: InteractRequest): Boolean {
         val hotbarRequest = submit(HotbarRequest(hotbarIndex, request), false)
-        val validRotation = if (request.interactConfig.rotate) submit(rotation, false).done else true
+        val validRotation = if (request.interactConfig.rotate) submit(rotationRequest, false).done else true
         return hotbarRequest.done && validRotation
     }
 
     override fun getLogContextBuilder(): LogContextBuilder.() -> Unit = {
         group("Interaction Context") {
             text(blockPos.getLogContextBuilder())
-            text(result.getLogContextBuilder())
-            text(rotation.getLogContextBuilder())
+            text(hitResult.getLogContextBuilder())
+            text(rotationRequest.getLogContextBuilder())
             value("Hotbar Index", hotbarIndex)
             value("Cached State", cachedState)
             value("Expected State", expectedState)

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

@@ -36,8 +36,8 @@ import net.minecraft.util.math.BlockPos
 import java.awt.Color
 
 data class PlaceContext(
-    override val result: BlockHitResult,
-    override val rotation: RotationRequest,
+    override val hitResult: BlockHitResult,
+    override val rotationRequest: RotationRequest,
     override var hotbarIndex: Int,
     override val blockPos: BlockPos,
     override var cachedState: BlockState,
@@ -61,7 +61,7 @@ data class PlaceContext(
             }.thenBy {
                 it.sneak == (mc.player?.isSneaking ?: false)
             }.thenBy {
-                it.rotation.target.angleDistance
+                it.rotationRequest.target.angleDistance
             }.thenBy {
                 it.hotbarIndex == HotbarManager.serverSlot
             }.thenBy {
@@ -74,22 +74,22 @@ data class PlaceContext(
         }
 
     override fun ShapeBuilder.buildRenderer() {
-        box(blockPos, expectedState, baseColor, sideColor, result.side.mask)
+        box(blockPos, expectedState, baseColor, sideColor, hitResult.side.mask)
     }
 
     fun requestDependencies(request: PlaceRequest): Boolean {
         val hotbarRequest = submit(HotbarRequest(hotbarIndex, this), false)
         val validRotation = if (request.placeConfig.rotateForPlace) {
-            submit(rotation, false).done && currentDirIsValid
+            submit(rotationRequest, false).done && currentDirIsValid
         } else true
         return hotbarRequest.done && validRotation
     }
 
     override fun getLogContextBuilder(): LogContextBuilder.() -> Unit = {
         group("Place Context") {
             text(blockPos.getLogContextBuilder())
-            text(result.getLogContextBuilder())
-            text(rotation.getLogContextBuilder())
+            text(hitResult.getLogContextBuilder())
+            text(rotationRequest.getLogContextBuilder())
             value("Hotbar Index", hotbarIndex)
             value("Cached State", cachedState)
             value("Expected State", expectedState)

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

@@ -21,14 +21,13 @@ 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
+import java.util.*
 
 object ProcessorRegistry : Loadable {
     private val processors = getInstances<PlacementProcessor>()
-    private val processorCache = mutableMapOf<BlockState, PreProcessingInfo?>()
+    private val processorCache = Collections.synchronizedMap<BlockState, PreProcessingInfo?>(mutableMapOf())
 
     val postProcessedProperties = setOf(
         Properties.EXTENDED,
@@ -107,30 +106,21 @@ object ProcessorRegistry : Loadable {
 
     override fun load() = "Loaded ${processors.size} pre processors"
 
-    fun TargetState.getProcessingInfo(pos: BlockPos) =
-        if (this is TargetState.State) {
+    fun TargetState.getProcessingInfo(pos: BlockPos): PreProcessingInfo? =
+        if (this !is TargetState.State) PreProcessingInfo.DEFAULT
+        else {
             val get: () -> PreProcessingInfo? = get@{
                 val infoAccumulator = PreProcessingInfoAccumulator()
 
                 processors.forEach { processor ->
                     if (!processor.acceptsState(blockState)) return@forEach
                     processor.preProcess(blockState, pos, infoAccumulator)
-                    if (infoAccumulator.shouldBeOmitted) {
+                    if (infoAccumulator.shouldBeOmitted)
                         return@get null
-                    }
                 }
 
                 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/processing/preprocessors/BlockHalfPreProcessor.kt

@@ -37,8 +37,8 @@ object BlockHalfPreProcessor : PlacementProcessor() {
         val slab = state.get(Properties.BLOCK_HALF) ?: return
 
         val surfaceScan = when (slab) {
-            BlockHalf.BOTTOM -> SurfaceScan(ScanMode.LESSER_BLOCK_HALF, Direction.Axis.Y)
-            BlockHalf.TOP -> SurfaceScan(ScanMode.GREATER_BLOCK_HALF, Direction.Axis.Y)
+            BlockHalf.BOTTOM -> SurfaceScan(ScanMode.LesserBlockHalf, Direction.Axis.Y)
+            BlockHalf.TOP -> SurfaceScan(ScanMode.GreaterBlockHalf, Direction.Axis.Y)
         }
 
         accumulator.offerSurfaceScan(surfaceScan)

src/main/kotlin/com/lambda/interaction/construction/processing/preprocessors/DoorHingePreProcessor.kt

@@ -39,19 +39,19 @@ object DoorHingePreProcessor : PlacementProcessor() {
             val side = state.get(Properties.DOOR_HINGE) ?: return@runSafe
             val scanner = when (state.get(Properties.HORIZONTAL_FACING) ?: return@runSafe) {
                 Direction.NORTH ->
-                    if (side == DoorHinge.LEFT) SurfaceScan(ScanMode.LESSER_BLOCK_HALF, Direction.Axis.X)
-                    else SurfaceScan(ScanMode.GREATER_BLOCK_HALF, Direction.Axis.X)
+                    if (side == DoorHinge.LEFT) SurfaceScan(ScanMode.LesserBlockHalf, Direction.Axis.X)
+                    else SurfaceScan(ScanMode.GreaterBlockHalf, Direction.Axis.X)
                 Direction.EAST ->
-                    if (side == DoorHinge.LEFT) SurfaceScan(ScanMode.LESSER_BLOCK_HALF, Direction.Axis.Z)
-                    else SurfaceScan(ScanMode.GREATER_BLOCK_HALF, Direction.Axis.Z)
+                    if (side == DoorHinge.LEFT) SurfaceScan(ScanMode.LesserBlockHalf, Direction.Axis.Z)
+                    else SurfaceScan(ScanMode.GreaterBlockHalf, Direction.Axis.Z)
                 Direction.SOUTH ->
-                    if (side == DoorHinge.LEFT) SurfaceScan(ScanMode.GREATER_BLOCK_HALF, Direction.Axis.X)
-                    else SurfaceScan(ScanMode.LESSER_BLOCK_HALF, Direction.Axis.X)
+                    if (side == DoorHinge.LEFT) SurfaceScan(ScanMode.GreaterBlockHalf, Direction.Axis.X)
+                    else SurfaceScan(ScanMode.LesserBlockHalf, Direction.Axis.X)
                 Direction.DOWN,
                 Direction.UP,
                 Direction.WEST ->
-                    if (side == DoorHinge.LEFT) SurfaceScan(ScanMode.GREATER_BLOCK_HALF, Direction.Axis.Z)
-                    else SurfaceScan(ScanMode.LESSER_BLOCK_HALF, Direction.Axis.Z)
+                    if (side == DoorHinge.LEFT) SurfaceScan(ScanMode.GreaterBlockHalf, Direction.Axis.Z)
+                    else SurfaceScan(ScanMode.LesserBlockHalf, Direction.Axis.Z)
             }
             accumulator.offerSurfaceScan(scanner)
         } ?: Unit

src/main/kotlin/com/lambda/interaction/construction/processing/preprocessors/SlabPreProcessor.kt

@@ -40,14 +40,14 @@ object SlabPreProcessor : PlacementProcessor() {
         val currentState = runSafe { blockState(pos) } ?: return
 
         val surfaceScan = when (slab) {
-            SlabType.BOTTOM -> SurfaceScan(ScanMode.LESSER_BLOCK_HALF, Direction.Axis.Y)
-            SlabType.TOP -> SurfaceScan(ScanMode.GREATER_BLOCK_HALF, Direction.Axis.Y)
+            SlabType.BOTTOM -> SurfaceScan(ScanMode.LesserBlockHalf, Direction.Axis.Y)
+            SlabType.TOP -> SurfaceScan(ScanMode.GreaterBlockHalf, Direction.Axis.Y)
             SlabType.DOUBLE -> {
                 accumulator.addIgnores(Properties.SLAB_TYPE)
                 if (currentState.block !is SlabBlock) SurfaceScan.DEFAULT
                 else when (currentState.get(Properties.SLAB_TYPE)) {
-                    SlabType.BOTTOM -> SurfaceScan(ScanMode.GREATER_BLOCK_HALF, Direction.Axis.Y)
-                    else -> SurfaceScan(ScanMode.LESSER_BLOCK_HALF, Direction.Axis.Y)
+                    SlabType.BOTTOM -> SurfaceScan(ScanMode.GreaterBlockHalf, Direction.Axis.Y)
+                    else -> SurfaceScan(ScanMode.LesserBlockHalf, Direction.Axis.Y)
                 }
             }
         }