Speed up clearance checks

Author: Avanatiker

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

@@ -28,16 +28,13 @@ import com.lambda.interaction.construction.simulation.BuildSimulator.simulate
 import com.lambda.interaction.request.rotation.RotationConfig
 import com.lambda.module.modules.client.TaskFlowModule
 import com.lambda.threading.runSafe
-import com.lambda.util.BlockUtils.blockState
 import com.lambda.util.world.FastVector
 import com.lambda.util.world.WorldUtils.playerBox
-import com.lambda.util.world.WorldUtils.playerFitsIn
 import com.lambda.util.world.WorldUtils.traversable
 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.Vec3d
 import java.awt.Color
 

common/src/main/kotlin/com/lambda/module/modules/movement/Pathfinder.kt

@@ -136,14 +136,6 @@ object Pathfinder : Module(
         }
     }
 
-    private fun Path.render(renderer: StaticESP, color: Color) {
-        moves.zipWithNext { current, next ->
-            val currentPos = current.pos.toBlockPos().toCenterPos()
-            val nextPos = next.pos.toBlockPos().toCenterPos()
-            renderer.buildLine(currentPos, nextPos, color)
-        }
-    }
-
     private fun SafeContext.updateTargetNode() {
         shortPath.moves.firstOrNull()?.let { current ->
             if (player.pos.distanceTo(current.bottomPos) < pathing.tolerance) {
@@ -171,7 +163,7 @@ object Pathfinder : Module(
             val thetaStar = measureTimeMillis {
                 short = thetaStarClearance(long, pathing)
             }
-            info("A* (Length: ${long.length.string} Nodes: ${long.moves.size} T: $aStar ms) and Theta* (Length: ${short.length.string} Nodes: ${short.moves.size} T: $thetaStar ms)")
+            info("A* (Length: ${long.length().string} Nodes: ${long.moves.size} T: $aStar ms) and Theta* (Length: ${short.length().string} Nodes: ${short.moves.size} T: $thetaStar ms)")
             println("Long: $long | Short: $short")
             short.moves.removeFirstOrNull()
             longPath = long

common/src/main/kotlin/com/lambda/pathing/Path.kt

@@ -17,22 +17,40 @@
 
 package com.lambda.pathing
 
+import com.lambda.graphics.renderer.esp.builders.buildLine
+import com.lambda.graphics.renderer.esp.global.StaticESP
 import com.lambda.pathing.move.Move
+import com.lambda.util.collections.updatableLazy
 import com.lambda.util.world.dist
 import com.lambda.util.world.toBlockPos
+import java.awt.Color
 
 data class Path(
     val moves: ArrayDeque<Move> = ArrayDeque(),
 ) {
     fun append(move: Move) {
         moves.addLast(move)
+        length.clear()
     }
 
     fun prepend(move: Move) {
         moves.addFirst(move)
+        length.clear()
     }
 
-    val length get() = moves.zipWithNext { a, b -> a.pos dist b.pos }.sum()
+    private val length = updatableLazy {
+        moves.zipWithNext { a, b -> a.pos dist b.pos }.sum()
+    }
+
+    fun render(renderer: StaticESP, color: Color) {
+        moves.zipWithNext { current, next ->
+            val currentPos = current.pos.toBlockPos().toCenterPos()
+            val nextPos = next.pos.toBlockPos().toCenterPos()
+            renderer.buildLine(currentPos, nextPos, color)
+        }
+    }
+
+    fun length() = length.value
 
     override fun toString() =
         moves.joinToString(" -> ") { "(${it.pos.toBlockPos().toShortString()})" }

common/src/main/kotlin/com/lambda/pathing/dstar/DStarLite.kt

@@ -189,7 +189,7 @@ class DStarLite(
             if (bestNext == null) break
             current = bestNext
             path.add(current)
-            if (path.size > 100000) break
+            if (path.size > 100_000) break
         }
         return path
     }

common/src/main/kotlin/com/lambda/pathing/dstar/PriorityQueueDStar.kt

@@ -28,7 +28,7 @@ class PriorityQueueDStar {
     private val pq = PriorityQueue<Pair<FastVector, Key>>(compareBy { it.second })
     private val vertexToKey = mutableMapOf<FastVector, Key>()
 
-    fun isEmpty(): Boolean = pq.isEmpty()
+    fun isEmpty() = pq.isEmpty()
 
     fun topKey(): Key {
         return if (pq.isEmpty()) Key(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY)

common/src/main/kotlin/com/lambda/pathing/move/MoveFinder.kt

@@ -23,12 +23,10 @@ import com.lambda.pathing.goal.Goal
 import com.lambda.util.BlockUtils.blockState
 import com.lambda.util.BlockUtils.fluidState
 import com.lambda.util.world.FastVector
-import com.lambda.util.world.WorldUtils.hasSupport
-import com.lambda.util.world.WorldUtils.isPathClear
+import com.lambda.util.world.WorldUtils.traversable
 import com.lambda.util.world.add
 import com.lambda.util.world.fastVectorOf
 import com.lambda.util.world.length
-import com.lambda.util.world.offset
 import com.lambda.util.world.toBlockPos
 import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
@@ -45,27 +43,30 @@ import net.minecraft.item.Items
 import net.minecraft.registry.tag.BlockTags
 import net.minecraft.registry.tag.FluidTags
 import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Box
 import net.minecraft.util.math.Direction
 import net.minecraft.util.math.EightWayDirection
+import kotlin.reflect.KFunction1
 
 object MoveFinder {
     private val nodeTypeCache = HashMap<FastVector, NodeType>()
 
     fun SafeContext.moveOptions(origin: Move, goal: Goal, config: PathingConfig) =
         EightWayDirection.entries.flatMap { direction ->
             (-1..1).mapNotNull { y ->
-                getPathNode(goal, origin, direction, y, config)
+                getPathNode(goal::heuristic, origin, direction, y, config)
             }
         }
 
     private fun SafeContext.getPathNode(
-        goal: Goal,
+        heuristic: KFunction1<FastVector, Double>,
         origin: Move,
         direction: EightWayDirection,
         height: Int,
         config: PathingConfig
     ): Move? {
         val offset = fastVectorOf(direction.offsetX, height, direction.offsetZ)
+        val diagonal = direction.ordinal.mod(2) == 1
         val checkingPos = origin.pos.add(offset)
         val checkingBlockPos = checkingPos.toBlockPos()
         val originBlockPos = origin.pos.toBlockPos()
@@ -74,20 +75,19 @@ object MoveFinder {
         val nodeType = findPathType(checkingPos)
         if (nodeType == NodeType.BLOCKED) return null
 
-        val clear = when {
-            height == 0 -> isPathClear(originBlockPos, checkingBlockPos, config.clearancePrecition)
-            height > 0 -> {
-                val between = origin.pos.offset(0, height, 0)
-                isPathClear(origin.pos, between, config.clearancePrecition, false) && isPathClear(between, checkingPos, config.clearancePrecition, false) && hasSupport(checkingBlockPos)
-            }
-            else -> {
-                val between = origin.pos.offset(direction.offsetX, 0, direction.offsetZ)
-                isPathClear(origin.pos, between, config.clearancePrecition, false) && isPathClear(between, checkingPos, config.clearancePrecition, false) && hasSupport(checkingBlockPos)
+        val clear = if (diagonal) {
+            val enclose = when {
+                checkingBlockPos.y == originBlockPos.y -> Box.enclosing(originBlockPos.up(), checkingBlockPos)
+                checkingBlockPos.y < originBlockPos.y -> Box.enclosing(originBlockPos.up(), checkingBlockPos.up())
+                else -> Box.enclosing(originBlockPos.up(2), checkingBlockPos)
             }
+            traversable(checkingBlockPos) && world.isSpaceEmpty(enclose)
+        } else {
+            traversable(checkingBlockPos)
         }
         if (!clear) return null
 
-        val hCost = goal.heuristic(checkingPos) /** nodeType.penalty*/
+        val hCost = heuristic(checkingPos) /** nodeType.penalty*/
         val cost = offset.length()
         val currentFeetY = getFeetY(checkingBlockPos)
 

common/src/main/kotlin/com/lambda/util/collections/UpdatableLazy.kt

@@ -43,6 +43,17 @@ class UpdatableLazy<T>(private val initializer: () -> T) {
      */
     val value: T get() = _value ?: initializer().also { _value = it }
 
+    /**
+     * Clears the currently stored value, setting it to null.
+     *
+     * This function is used to explicitly reset the stored value, effectively marking
+     * it as uninitialized. It can subsequently be re-initialized through lazy evaluation
+     * when accessed again.
+     */
+    fun clear() {
+        _value = null
+    }
+
     /**
      * Resets the current value to a new value generated by the initializer function.
      *

common/src/main/kotlin/com/lambda/util/world/WorldUtils.kt

@@ -19,24 +19,14 @@ package com.lambda.util.world
 
 import com.lambda.context.SafeContext
 import com.lambda.util.BlockUtils.blockState
-import com.lambda.util.math.flooredBlockPos
-import net.fabricmc.loader.impl.lib.sat4j.core.Vec
 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 kotlin.math.min
 
 object WorldUtils {
     fun SafeContext.traversable(pos: BlockPos) =
-        blockState(pos.down()).isSideSolidFullSquare(world, pos.down(), Direction.UP) && playerFitsIn(pos)
-
-    fun SafeContext.isPathClear(
-        start: FastVector,
-        end: FastVector,
-        stepSize: Double = 0.3,
-        supportCheck: Boolean = true,
-    ) = isPathClear(start.toBlockPos(), end.toBlockPos(), stepSize, supportCheck)
+        hasSupport(pos) && hasClearance(pos)
 
     fun SafeContext.isPathClear(
         start: BlockPos,
@@ -61,34 +51,28 @@ object WorldUtils {
         var currentPos = start
 
         (0 until steps).forEach { _ ->
-            val playerNotFitting = !playerFitsIn(currentPos)
+            val playerNotFitting = !hasClearance(currentPos)
             val hasNoSupport = !hasSupport(currentPos)
             if (playerNotFitting || (supportCheck && hasNoSupport)) {
                 return false
             }
             currentPos = currentPos.add(stepDirection)
         }
 
-        return playerFitsIn(end)
+        return hasClearance(end)
     }
 
-    fun SafeContext.playerFitsIn(pos: BlockPos) =
-        playerFitsIn(Vec3d.ofBottomCenter(pos))
-
-    fun SafeContext.playerFitsIn(pos: Vec3d) =
+    private fun SafeContext.hasClearance(pos: Vec3d) =
         world.isSpaceEmpty(player, pos.playerBox().contract(1.0E-6))
 
-    fun SafeContext.hasSupport(pos: BlockPos) =
-        hasSupport(Vec3d.ofBottomCenter(pos))
-
-//    private fun SafeContext.hasSupport(pos: BlockPos) =
-//        blockState(pos.down()).isSideSolidFullSquare(world, pos.down(), Direction.UP)
-
     fun SafeContext.hasSupport(pos: Vec3d) =
-        !world.isSpaceEmpty(player, pos.playerBox().expand(1.0E-6))
+        !world.isSpaceEmpty(player, pos.playerBox().expand(1.0E-6).contract(0.05, 0.0, 0.05))
+
+    private fun SafeContext.hasClearance(pos: BlockPos) =
+        blockState(pos).isAir && blockState(pos.up()).isAir
 
-//    fun SafeContext.hasSupport(pos: Vec3d) =
-//        world.canCollide(null, pos.playerBox().expand(1.0E-6))
+    private fun SafeContext.hasSupport(pos: BlockPos) =
+        blockState(pos.down()).isSideSolidFullSquare(world, pos.down(), Direction.UP)
 
     fun Vec3d.playerBox(): Box =
         Box(x - 0.3, y, z - 0.3, x + 0.3, y + 1.8, z + 0.3)