use supervisor scopes' feature to only return after all child jobs are done

Author: beanbag44

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

@@ -29,40 +29,45 @@ import com.lambda.interaction.construction.simulation.checks.RequirementChecks.c
 import com.lambda.util.BlockUtils.blockState
 import io.ktor.util.collections.*
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.joinAll
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.supervisorScope
 import net.minecraft.util.math.Vec3d
 
 object BuildSimulator : SimChecker<PostSimResult>() {
     context(automatedSafeContext: AutomatedSafeContext)
-    fun Blueprint.simulate(pov: Vec3d = automatedSafeContext.player.eyePos): Set<BuildResult> = runBlocking(Dispatchers.Default) {
-        val concurrentSet = ConcurrentSet<BuildResult>()
-        with(automatedSafeContext) {
-            structure.entries
-                .map { (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))
+    fun Blueprint.simulate(
+        pov: Vec3d = automatedSafeContext.player.eyePos
+    ): 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))
+                                }
                             }
                         }
                     }
-                }.joinAll()
-        }
+                }
 
-        return@runBlocking concurrentSet
-    }
+                concurrentSet
+            }
+        }
 }
-

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

@@ -29,10 +29,8 @@ import com.lambda.util.math.distSq
 import com.lambda.util.math.vec3d
 import com.lambda.util.world.raycast.RayCastUtils.blockResult
 import io.ktor.util.collections.*
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.joinAll
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
+import kotlinx.coroutines.supervisorScope
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
@@ -82,8 +80,8 @@ abstract class SimChecker<T : BuildResult> {
         val validHits = ConcurrentSet<CheckedHit>()
         val misses = ConcurrentSet<Vec3d>()
 
-        withContext(Dispatchers.Default) {
-            boxes.map { box ->
+        supervisorScope {
+            boxes.forEach { box ->
                 launch {
                     val sides = if (buildConfig.checkSideVisibility || buildConfig.strictRayCast) {
                         sides.intersect(box.getVisibleSurfaces(pov))
@@ -110,7 +108,7 @@ abstract class SimChecker<T : BuildResult> {
                         validHits.add(checked)
                     }
                 }
-            }.joinAll()
+            }
         }
 
         if (validHits.isEmpty()) {

src/main/kotlin/com/lambda/interaction/construction/simulation/checks/PlaceChecker.kt

@@ -50,12 +50,9 @@ import com.lambda.util.player.MovementUtils.sneaking
 import com.lambda.util.player.copyPlayer
 import com.lambda.util.world.raycast.RayCastUtils.blockResult
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.cancel
-import kotlinx.coroutines.joinAll
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.supervisorScope
-import kotlinx.coroutines.withContext
 import net.minecraft.block.BlockState
 import net.minecraft.block.pattern.CachedBlockPosition
 import net.minecraft.client.network.ClientPlayerEntity
@@ -83,24 +80,20 @@ class PlaceChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
             }
     }
 
-    private suspend fun AutomatedSafeContext.checkPlacements(): Boolean {
+    private suspend fun AutomatedSafeContext.checkPlacements(): Boolean =
         supervisorScope {
-            withContext(Dispatchers.Default) {
-                preProcessing.sides.map { side ->
-                    launch {
-                        val neighborPos = pos.offset(side)
-                        val neighborSide = side.opposite
-                        if (!placeConfig.airPlace.isEnabled)
-                            testBlock(neighborPos, neighborSide, this@supervisorScope)
-                        testBlock(pos, side, this@supervisorScope)
-                    }
-                }.joinAll()
+            preProcessing.sides.forEach { side ->
+                launch {
+                    val neighborPos = pos.offset(side)
+                    val neighborSide = side.opposite
+                    if (!placeConfig.airPlace.isEnabled)
+                        testBlock(neighborPos, neighborSide, this@supervisorScope)
+                    testBlock(pos, side, this@supervisorScope)
+                }
             }
+            true
         }
 
-        return true
-    }
-
     private suspend fun AutomatedSafeContext.testBlock(pos: BlockPos, side: Direction, supervisorScope: CoroutineScope) {
         if (!world.worldBorder.contains(pos)) return
 
@@ -240,7 +233,7 @@ class PlaceChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
 
     private fun AutomatedSafeContext.testPlaceState(context: ItemPlacementContext): PlaceTest {
         val resultState = context.stack.blockItem.getPlacementState(context) ?: run {
-            result(PlaceResult.BlockedByEntity(pos))
+            result(PlaceResult.BlockedByEntity(pos, emptyList()))
             return PlaceTest(state, PlaceTestResult.BlockedByEntity)
         }
 

src/main/kotlin/com/lambda/interaction/construction/simulation/checks/PostProcessingChecker.kt

@@ -24,9 +24,11 @@ import com.lambda.interaction.construction.result.Dependable
 import com.lambda.interaction.construction.result.results.GenericResult
 import com.lambda.interaction.construction.result.results.InteractResult
 import com.lambda.interaction.construction.simulation.ISimInfo
+import com.lambda.interaction.construction.simulation.ISimInfo.Companion.simInfo
 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.verify.TargetState
 import com.lambda.interaction.material.ContainerSelection.Companion.selectContainer
 import com.lambda.interaction.material.StackSelection.Companion.select
@@ -98,7 +100,7 @@ class PostProcessingChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
                     simInteraction(expectedState)
                 }
 
-                Properties.SLAB_TYPE -> return false
+                Properties.SLAB_TYPE -> simInfo()?.checkPlacements()
             }
         }