dsl oriented sim structure. Im not sure if i like how many objects are created but i guess this is a clean looking solution we can potentially improve performance on after the logic is smoothed

Author: beanbag44

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

@@ -21,11 +21,11 @@ import com.lambda.context.AutomatedSafeContext
 import com.lambda.interaction.construction.blueprint.Blueprint
 import com.lambda.interaction.construction.result.BuildResult
 import com.lambda.interaction.construction.result.results.PostSimResult
-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.interaction.construction.simulation.ISimInfo.Companion.sim
+import com.lambda.interaction.construction.simulation.checks.BreakSim.Companion.simBreak
+import com.lambda.interaction.construction.simulation.checks.PlaceSim.Companion.simPlacement
+import com.lambda.interaction.construction.simulation.checks.PostProcessingSim.Companion.simPostProcessing
+import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.util.BlockUtils.blockState
 import io.ktor.util.collections.*
 import kotlinx.coroutines.Dispatchers
@@ -38,36 +38,28 @@ object BuildSimulator : SimChecker<PostSimResult>() {
     context(automatedSafeContext: AutomatedSafeContext)
     fun Blueprint.simulate(
         pov: Vec3d = automatedSafeContext.player.eyePos
-    ): Set<BuildResult> =
-        runBlocking(Dispatchers.Default) {
-            supervisorScope {
-                val concurrentSet = ConcurrentSet<BuildResult>()
+    ): Set<BuildResult> = runBlocking(Dispatchers.Default) {
+        supervisorScope {
+            val concurrentSet = ConcurrentSet<BuildResult>()
 
-                with(automatedSafeContext) {
-                    structure.entries.forEach { (pos, targetState) ->
-                        launch {
-                            val simInfo = simInfo(
-                                pos,
-                                blockState(pos),
-                                targetState,
-                                pov,
-                                concurrentSet
-                            ) ?: return@launch
-
-                            with(simInfo) {
-                                with(null) {
-                                    if (checkRequirements() ||
-                                        checkPostProcessing() ||
-                                        checkBreaks() ||
-                                        checkPlacements()) return@launch
-                                    else result(PostSimResult.NoMatch(pos))
-                                }
+            with(automatedSafeContext) {
+                structure.forEach { (pos, targetState) ->
+                    launch {
+                        sim(pos, blockState(pos), targetState, pov, concurrentSet) {
+                            if (targetState is TargetState.State &&
+                                targetState.matches(state, pos, preProcessing.ignore)
+                                ) {
+                                simPostProcessing()
+                                return@sim
                             }
+                            if (!targetState.isEmpty() && state.isReplaceable) simPlacement()
+                            else simBreak()
                         }
                     }
                 }
-
-                concurrentSet
             }
+
+            concurrentSet
         }
+    }
 }

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

@@ -18,16 +18,21 @@
 package com.lambda.interaction.construction.simulation
 
 import com.lambda.context.Automated
+import com.lambda.context.AutomatedSafeContext
 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.simulation.checks.RequirementChecker.checkRequirements
 import com.lambda.interaction.construction.verify.TargetState
 import net.minecraft.block.BlockState
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Vec3d
 import java.util.*
 
+@DslMarker
+annotation class SimBuilderDsl
+
 interface ISimInfo : Automated {
     val pos: BlockPos
     val state: BlockState
@@ -38,32 +43,53 @@ interface ISimInfo : Automated {
     val dependencyStack: Stack<Dependable>
 
     companion object {
-        @SimCheckerDsl
-        fun Automated.simInfo(
+        @SimBuilderDsl
+        private suspend fun ISimInfo.sim(
+            dependable: Dependable?,
+            simBuilder: suspend context(Dependable?) SimBuilder.() -> Unit
+        ) = SimBuilder(this).run { with(dependable) { simBuilder() } }
+
+        @SimBuilderDsl
+        suspend fun AutomatedSafeContext.sim(
             pos: BlockPos,
             state: BlockState,
             targetState: TargetState,
             pov: Vec3d,
             concurrentResults: MutableSet<BuildResult>,
-        ): SimInfo? {
-            val preProcessingInfo = targetState.getProcessingInfo(pos) ?: return null
-            return SimInfo(pos, state, targetState, preProcessingInfo, pov, concurrentResults, this)
+            simBuilder: suspend context(Dependable?) SimBuilder.() -> Unit
+        ) {
+            SimInfo(
+                pos, state, targetState,
+                targetState.getProcessingInfo(pos) ?: return,
+                pov, concurrentResults, this
+            ).takeIf { it.checkRequirements() }?.sim(null, simBuilder)
         }
 
-        @SimCheckerDsl
-        fun ISimInfo.simInfo(
+        @SimBuilderDsl
+        context(_: AutomatedSafeContext, dependable: Dependable)
+        suspend fun ISimInfo.sim(
             pos: BlockPos = this.pos,
             state: BlockState = this.state,
             targetState: TargetState = this.targetState,
             pov: Vec3d = this.pov,
-            concurrentResults: MutableSet<BuildResult> = this.concurrentResults
-        ): SimInfo? {
-            val preProcessingInfo = targetState.getProcessingInfo(pos) ?: return null
-            return SimInfo(pos, state, targetState, preProcessingInfo, pov, concurrentResults, this)
+            simBuilder: suspend context(Dependable?) SimBuilder.() -> Unit
+        ) {
+            SimInfo(
+                pos, state, targetState,
+                targetState.getProcessingInfo(pos) ?: return,
+                pov, concurrentResults, this
+            ).takeIf { it.checkRequirements() }?.sim(dependable, simBuilder)
         }
+
+        @SimBuilderDsl
+        context(dependable: Dependable)
+        suspend fun ISimInfo.sim(
+            simBuilder: suspend context(Dependable?) SimBuilder.() -> Unit
+        ) = sim(dependable, simBuilder)
     }
 }
 
+@SimBuilderDsl
 data class SimInfo(
     override val pos: BlockPos,
     override val state: BlockState,
@@ -74,4 +100,6 @@ data class SimInfo(
     val automated: Automated
 ) : ISimInfo, Automated by automated {
     override val dependencyStack = Stack<Dependable>()
-}
+}
+
+class SimBuilder(simInfo: ISimInfo) : ISimInfo by simInfo

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

@@ -52,7 +52,6 @@ abstract class SimChecker<T : BuildResult> {
     }
 
     fun ISimInfo.result(result: GenericResult) = addResult(result)
-
     fun ISimInfo.result(result: T) = addResult(result)
 
     private fun ISimInfo.addResult(result: BuildResult) {

…uction/simulation/checks/BreakChecker.kt …nstruction/simulation/checks/BreakSim.ktsrc/main/kotlin/com/lambda/interaction/construction/simulation/checks/BreakChecker.kt renamed to src/main/kotlin/com/lambda/interaction/construction/simulation/checks/BreakSim.kt src/main/kotlin/com/lambda/interaction/construction/simulation/checks/BreakChecker.kt renamed to src/main/kotlin/com/lambda/interaction/construction/simulation/checks/BreakSim.kt

@@ -24,11 +24,11 @@ import com.lambda.interaction.construction.result.Dependable
 import com.lambda.interaction.construction.result.results.BreakResult
 import com.lambda.interaction.construction.result.results.GenericResult
 import com.lambda.interaction.construction.simulation.ISimInfo
-import com.lambda.interaction.construction.simulation.ISimInfo.Companion.simInfo
+import com.lambda.interaction.construction.simulation.ISimInfo.Companion.sim
+import com.lambda.interaction.construction.simulation.SimBuilder
+import com.lambda.interaction.construction.simulation.SimBuilderDsl
 import com.lambda.interaction.construction.simulation.SimChecker
-import com.lambda.interaction.construction.simulation.SimCheckerDsl
-import com.lambda.interaction.construction.simulation.SimInfo
-import com.lambda.interaction.construction.simulation.checks.PlaceChecker.Companion.checkPlacements
+import com.lambda.interaction.construction.simulation.checks.PlaceSim.Companion.simPlacement
 import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.interaction.material.ContainerSelection.Companion.selectContainer
 import com.lambda.interaction.material.StackSelection
@@ -44,7 +44,6 @@ import com.lambda.interaction.request.rotating.visibilty.lookAtBlock
 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.inventoryIndex
 import com.lambda.util.item.ItemStackUtils.inventoryIndexOrSelected
 import com.lambda.util.world.raycast.RayCastUtils.blockResult
@@ -67,40 +66,39 @@ import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
 import kotlin.jvm.optionals.getOrNull
 
-class BreakChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
+class BreakSim private constructor(simInfo: ISimInfo)
     : SimChecker<BreakResult>(), Dependable,
     ISimInfo by simInfo
 {
     override fun asDependent(buildResult: BuildResult) =
         BreakResult.Dependency(pos, buildResult)
 
     companion object {
-        @SimCheckerDsl
+        @SimBuilderDsl
         context(automatedSafeContext: AutomatedSafeContext, dependable: Dependable?)
-        suspend fun SimInfo.checkBreaks() =
-            BreakChecker(this).run {
+        suspend fun SimBuilder.simBreak() =
+            BreakSim(this).run {
                 checkDependent(dependable)
                 automatedSafeContext.checkBreaks()
             }
     }
 
-    private suspend fun AutomatedSafeContext.checkBreaks(): Boolean {
+    private suspend fun AutomatedSafeContext.checkBreaks() {
         if (breakConfig.avoidSupporting) player.supportingBlockPos.getOrNull()?.let { support ->
             if (support != pos) return@let
             result(BreakResult.PlayerOnTop(pos, state))
-            return true
+            return
         }
 
         if (targetState.getState(pos).isAir && !state.fluidState.isEmpty && state.isReplaceable) {
             result(BreakResult.Submerge(pos, state))
-            return simInfo(pos, state, TargetState.Solid(emptySet()))?.checkPlacements() ?: true
+            sim(pos, state, TargetState.Solid(emptySet())) { simPlacement() }
+            return
         }
 
-        if (state.isEmpty) return false
-
-        if (breakConfig.avoidLiquids && affectsFluids()) return true
+        if (breakConfig.avoidLiquids && affectsFluids()) return
 
-        val (swapStack, stackSelection) = getSwapStack() ?: return true
+        val (swapStack, stackSelection) = getSwapStack() ?: return
         val instant = instantBreakable(
             state, pos,
             if (breakConfig.swapMode.isEnabled()) swapStack else player.mainHandStack,
@@ -124,17 +122,17 @@ class BreakChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
                 )
                 result(BreakResult.Break(pos, breakContext))
             }
-            return true
+            return
         }
 
-        val validHits = scanShape(pov, shape, pos, Direction.entries.toSet(), preProcessing) ?: return true
+        val validHits = scanShape(pov, shape, pos, Direction.entries.toSet(), preProcessing) ?: return
 
-        val bestHit = buildConfig.pointSelection.select(validHits) ?: return true
+        val bestHit = buildConfig.pointSelection.select(validHits) ?: return
         val target = lookAt(bestHit.targetRotation, 0.001)
         val rotationRequest = RotationRequest(target, this)
 
         val breakContext = BreakContext(
-            bestHit.hit.blockResult ?: return true,
+            bestHit.hit.blockResult ?: return,
             rotationRequest,
             swapStack.inventoryIndexOrSelected,
             stackSelection,
@@ -144,7 +142,7 @@ class BreakChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
         )
 
         result(BreakResult.Break(pos, breakContext))
-        return true
+        return
     }
 
     private fun AutomatedSafeContext.getSwapStack(): Pair<ItemStack, StackSelection>? {
@@ -276,7 +274,7 @@ class BreakChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
 
             affectedFluids.forEach { (liquidPos, liquidState) ->
                 result(BreakResult.Submerge(liquidPos, liquidState))
-                simInfo(liquidPos, liquidState, TargetState.Solid(emptySet()))?.checkPlacements()
+                sim(liquidPos, liquidState, TargetState.Solid(emptySet())) { simPlacement() }
             }
             result(BreakResult.BlockedByFluid(pos, state))
             return true

…uction/simulation/checks/PlaceChecker.kt …nstruction/simulation/checks/PlaceSim.ktsrc/main/kotlin/com/lambda/interaction/construction/simulation/checks/PlaceChecker.kt renamed to src/main/kotlin/com/lambda/interaction/construction/simulation/checks/PlaceSim.kt src/main/kotlin/com/lambda/interaction/construction/simulation/checks/PlaceChecker.kt renamed to src/main/kotlin/com/lambda/interaction/construction/simulation/checks/PlaceSim.kt

@@ -24,12 +24,12 @@ import com.lambda.interaction.construction.result.Dependable
 import com.lambda.interaction.construction.result.results.GenericResult
 import com.lambda.interaction.construction.result.results.PlaceResult
 import com.lambda.interaction.construction.simulation.ISimInfo
-import com.lambda.interaction.construction.simulation.ISimInfo.Companion.simInfo
+import com.lambda.interaction.construction.simulation.ISimInfo.Companion.sim
+import com.lambda.interaction.construction.simulation.SimBuilder
+import com.lambda.interaction.construction.simulation.SimBuilderDsl
 import com.lambda.interaction.construction.simulation.SimChecker
-import com.lambda.interaction.construction.simulation.SimCheckerDsl
-import com.lambda.interaction.construction.simulation.SimInfo
-import com.lambda.interaction.construction.simulation.checks.BreakChecker.Companion.checkBreaks
-import com.lambda.interaction.construction.simulation.checks.PlaceChecker.RotatePlaceTest.Companion.rotatePlaceTest
+import com.lambda.interaction.construction.simulation.checks.BreakSim.Companion.simBreak
+import com.lambda.interaction.construction.simulation.checks.PlaceSim.RotatePlaceTest.Companion.rotatePlaceTest
 import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.interaction.material.ContainerSelection.Companion.selectContainer
 import com.lambda.interaction.material.StackSelection.Companion.select
@@ -69,24 +69,24 @@ import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
 import net.minecraft.util.shape.VoxelShapes
 
-class PlaceChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
+class PlaceSim private constructor(simInfo: ISimInfo)
     : SimChecker<PlaceResult>(), Dependable,
     ISimInfo by simInfo
 {
     override fun asDependent(buildResult: BuildResult) =
         PlaceResult.Dependency(pos, buildResult)
 
     companion object {
-        @SimCheckerDsl
         context(automatedSafeContext: AutomatedSafeContext, dependable: Dependable?)
-        suspend fun SimInfo.checkPlacements() =
-            PlaceChecker(this).run {
+        @SimBuilderDsl
+        suspend fun SimBuilder.simPlacement() =
+            PlaceSim(this).run {
                 checkDependent(dependable)
                 automatedSafeContext.checkPlacements()
             }
     }
 
-    private suspend fun AutomatedSafeContext.checkPlacements(): Boolean =
+    private suspend fun AutomatedSafeContext.checkPlacements() =
         supervisorScope {
             preProcessing.sides.forEach { side ->
                 launch {
@@ -97,7 +97,6 @@ class PlaceChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
                     testBlock(pos, side, this@supervisorScope)
                 }
             }
-            true
         }
 
     private suspend fun AutomatedSafeContext.testBlock(pos: BlockPos, side: Direction, supervisorScope: CoroutineScope) {
@@ -192,15 +191,15 @@ class PlaceChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
 
             val placeContext = PlaceContext(
                 hitResult,
-                RotationRequest(rotationRequest, this@PlaceChecker),
+                RotationRequest(rotationRequest, this@PlaceSim),
                 swapStack.inventoryIndex,
                 pos,
                 state,
                 rotatePlaceTest.resultState,
                 fakePlayer.isSneaking,
                 false,
                 rotatePlaceTest.currentDirIsValid,
-                this@PlaceChecker
+                this@PlaceSim
             )
 
             result(PlaceResult.Place(pos, placeContext))
@@ -276,7 +275,7 @@ class PlaceChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
                 }
                 .flatten()
                 .forEach { support ->
-                    simInfo(support, blockState(support), TargetState.Empty)?.checkBreaks()
+                    sim(support, blockState(support), TargetState.Empty) { simBreak() }
                 }
             result(PlaceResult.BlockedByEntity(pos, collidingEntities))
         }