Fix player collision check for simulation

Author: Avanatiker

common/src/main/kotlin/com/lambda/interaction/construction/result/Drawable.kt

@@ -56,7 +56,10 @@ interface Drawable {
     }
 
     fun SafeContext.withShape(shape: VoxelShape, offset: BlockPos, color: Color, mask: Int = DirectionMask.ALL) {
-        if (shape.isEmpty) return
+        if (shape.isEmpty) {
+            withBox(Box(offset), color, mask)
+            return
+        }
         shape.boundingBoxes.forEach { box ->
             withBox(box.offset(offset), color, mask)
         }

common/src/main/kotlin/com/lambda/interaction/construction/simulation/Simulation.kt

@@ -23,6 +23,7 @@ import com.lambda.config.groups.InventoryConfig
 import com.lambda.context.SafeContext
 import com.lambda.interaction.construction.blueprint.Blueprint
 import com.lambda.interaction.construction.result.BuildResult
+import com.lambda.interaction.construction.result.Drawable
 import com.lambda.interaction.construction.simulation.BuildSimulator.simulate
 import com.lambda.interaction.request.rotation.RotationConfig
 import com.lambda.module.modules.client.TaskFlowModule
@@ -32,9 +33,11 @@ import com.lambda.util.world.FastVector
 import com.lambda.util.world.toBlockPos
 import com.lambda.util.world.toVec3d
 import net.minecraft.client.network.ClientPlayerEntity
+import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Box
 import net.minecraft.util.math.Direction
 import net.minecraft.util.math.Vec3d
+import java.awt.Color
 
 data class Simulation(
     val blueprint: Blueprint,
@@ -47,31 +50,37 @@ data class Simulation(
     private fun FastVector.toView(): Vec3d = toVec3d().add(0.5, ClientPlayerEntity.DEFAULT_EYE_HEIGHT.toDouble(), 0.5)
 
     fun simulate(
-        pos: FastVector
-    ) =
-        cache.getOrPut(pos) {
-            val view = pos.toView()
-            runSafe {
-                if (blueprint.isOutOfBounds(view) && blueprint.getClosestPointTo(view)
-                        .distanceTo(view) > 10.0
-                ) return@getOrPut emptySet()
-                val blockPos = pos.toBlockPos()
-                if (!playerFitsIn(Vec3d.ofBottomCenter(blockPos))) return@getOrPut emptySet()
-                if (!blockPos.down().blockState(world)
-                        .isSideSolidFullSquare(world, blockPos, Direction.UP)
-                ) return@getOrPut emptySet()
-            }
+        pos: FastVector,
+    ) = cache.getOrPut(pos) {
+        val view = pos.toView()
+        val isOutOfBounds = blueprint.isOutOfBounds(view)
+        val isTooFar = blueprint.getClosestPointTo(view).distanceTo(view) > 10.0
+        runSafe {
+            if (isOutOfBounds && isTooFar) return@getOrPut emptySet()
+            val blockPos = pos.toBlockPos()
+            val isWalkable = blockPos.down().blockState(world).isSideSolidFullSquare(world, blockPos, Direction.UP)
+            if (!isWalkable) return@getOrPut emptySet()
+            if (!playerFitsIn(blockPos)) return@getOrPut emptySet()
+        }
+
+        blueprint.simulate(view, interact, rotation, inventory, build)
+    }
 
-            blueprint.simulate(view, interact, rotation, inventory, build)
+    fun goodPositions() = cache.filter { it.value.any { it.rank.ordinal < 4 } }.map { PossiblePos(it.key.toBlockPos()) }
+
+    class PossiblePos(val pos: BlockPos): Drawable {
+        override fun SafeContext.buildRenderer() {
+            withBox(Vec3d.ofBottomCenter(pos).playerBox(), Color(0, 255, 0, 50))
         }
+    }
 
-    private fun SafeContext.playerFitsIn(pos: Vec3d): Boolean {
-        val pBox = player.boundingBox
-        val aabb = Box(pBox.minX, pBox.minY - 1.0E-6, pBox.minZ, pBox.maxX, pBox.minY, pBox.maxZ)
-        return world.isSpaceEmpty(aabb.offset(pos))
+    private fun SafeContext.playerFitsIn(pos: BlockPos): Boolean {
+        return world.isSpaceEmpty(Vec3d.ofBottomCenter(pos).playerBox())
     }
 
     companion object {
+        fun Vec3d.playerBox(): Box = Box(x - 0.3, y, z - 0.3, x + 0.3, y + 1.8, z + 0.3).contract(1.0E-6)
+
         fun Blueprint.simulation(
             interact: InteractionConfig = TaskFlowModule.interact,
             rotation: RotationConfig = TaskFlowModule.rotation,

common/src/main/kotlin/com/lambda/interaction/request/rotation/visibilty/VisibilityChecker.kt

@@ -138,7 +138,7 @@ object VisibilityChecker {
     ) {
         excludedSides.forEach { side ->
             if (excludedSides.isNotEmpty() && side !in excludedSides) return@forEach
-            val (minX, minY, minZ, maxX, maxY, maxZ) = box.shrink(0.01, 0.01, 0.01).bounds(side)
+            val (minX, minY, minZ, maxX, maxY, maxZ) = box.contract(1.0E-6).bounds(side)
             val stepX = (maxX - minX) / resolution
             val stepY = (maxY - minY) / resolution
             val stepZ = (maxZ - minZ) / resolution

common/src/main/kotlin/com/lambda/task/tasks/BuildTask.kt

@@ -47,6 +47,7 @@ import com.lambda.util.BlockUtils.blockState
 import com.lambda.util.Communication.info
 import com.lambda.util.Formatting.string
 import com.lambda.util.extension.Structure
+import com.lambda.util.world.toFastVec
 import net.minecraft.network.packet.s2c.play.BlockUpdateS2CPacket
 import net.minecraft.util.math.BlockPos
 import java.util.concurrent.ConcurrentLinkedQueue
@@ -68,6 +69,7 @@ class BuildTask @Ta5kBuilder constructor(
     private var currentPlacement: PlaceContext? = null
     private var placements = 0
     private var breaks = 0
+    private var goodPositions = setOf<BlockPos>()
 
     override fun SafeContext.onStart() {
         (blueprint as? DynamicBlueprint)?.create()
@@ -98,9 +100,16 @@ class BuildTask @Ta5kBuilder constructor(
                 return@listen
             }
 
+//            val sim = blueprint.simulation(interact, rotation, inventory)
+//            BlockPos.iterateOutwards(player.blockPos, 5, 5, 5).forEach { pos ->
+//                sim.simulate(pos.toFastVec())
+//            }
+
             // ToDo: Simulate for each pair player positions that work
             val results = blueprint.simulate(player.eyePos, interact, rotation, inventory, build)
-            TaskFlowModule.drawables = results.filterIsInstance<Drawable>().plus(pendingPlacements.toList())
+            TaskFlowModule.drawables = results.filterIsInstance<Drawable>()
+                .plus(pendingPlacements.toList())
+//                .plus(sim.goodPositions())
 
             val instantResults = results.filterIsInstance<BreakResult.Break>()
                 .filter { it.context.instantBreak }