Faster pathing

Author: Avanatiker

common/src/main/kotlin/com/lambda/interaction/construction/Blueprint.kt

@@ -1,26 +1,33 @@
 package com.lambda.interaction.construction
 
-import com.lambda.context.SafeContext
 import com.lambda.interaction.construction.verify.TargetState
-import com.lambda.module.modules.client.TaskFlow
 import com.lambda.util.BlockUtils.blockPos
-import com.lambda.util.BlockUtils.blockState
-import com.lambda.util.Communication.info
 import com.lambda.util.extension.Structure
+import com.lambda.util.math.VecUtils.blockPos
 import net.minecraft.structure.StructureTemplate
-import net.minecraft.util.math.BlockBox
-import net.minecraft.util.math.BlockPos
-import net.minecraft.util.math.Box
+import net.minecraft.util.math.*
 
 abstract class Blueprint {
     abstract val structure: Structure
 
-    open fun isDone(ctx: SafeContext) =
-        structure.all { (pos, targetState) ->
-            with(ctx) {
-                targetState.matches(pos.blockState(world), pos, world)
-            }
-        }
+    private val bounds: BlockBox by lazy {
+        val maxX = structure.keys.maxOf { it.x }
+        val maxY = structure.keys.maxOf { it.y }
+        val maxZ = structure.keys.maxOf { it.z }
+        val minX = structure.keys.minOf { it.x }
+        val minY = structure.keys.minOf { it.y }
+        val minZ = structure.keys.minOf { it.z }
+        BlockBox(minX, minY, minZ, maxX, maxY, maxZ)
+    }
+
+    fun getClosestPointTo(target: Vec3d): Vec3d {
+        val d = MathHelper.clamp(target.x, bounds.minX.toDouble(), bounds.maxX.toDouble())
+        val e = MathHelper.clamp(target.y, bounds.minY.toDouble(), bounds.maxY.toDouble())
+        val f = MathHelper.clamp(target.z, bounds.minZ.toDouble(), bounds.maxZ.toDouble())
+        return Vec3d(d, e, f)
+    }
+
+    fun isOutOfBounds(vec3d: Vec3d): Boolean = !bounds.contains(vec3d.blockPos)
 
     companion object {
         fun emptyStructure(): Structure = emptyMap()

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

@@ -1,19 +1,17 @@
 package com.lambda.interaction.construction.simulation
 
 import baritone.api.pathing.goals.Goal
-import com.lambda.util.Communication.info
 import com.lambda.util.world.fastVectorOf
 
 class BuildGoal(private val sim: Simulation) : Goal {
     override fun isInGoal(x: Int, y: Int, z: Int): Boolean {
         val vec = fastVectorOf(x, y, z)
-//        info("Checking goal at $x, $y, $z")
         val simu = sim.simulate(vec)
         return simu.any { it.rank.ordinal < 4 }
     }
 
     override fun heuristic(x: Int, y: Int, z: Int): Double {
-        val bestRank = sim.simulate(fastVectorOf(x, y, z)).minOrNull()?.rank?.ordinal ?: 10000
+        val bestRank = sim.simulate(fastVectorOf(x, y, z)).minOrNull()?.rank?.ordinal ?: 100000
         val score = 1 / (bestRank.toDouble() + 1)
 //        info("Calculating heuristic at $x, $y, $z with score $score")
         return score

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

@@ -4,6 +4,8 @@ import com.lambda.context.SafeContext
 import com.lambda.interaction.construction.Blueprint
 import com.lambda.interaction.construction.result.BuildResult
 import com.lambda.interaction.construction.simulation.BuildSimulator.simulate
+import com.lambda.module.modules.client.TaskFlow
+import com.lambda.task.Task
 import com.lambda.threading.runSafe
 import com.lambda.util.Communication.info
 import com.lambda.util.world.FastVector
@@ -18,35 +20,16 @@ import net.minecraft.util.math.Vec3d
 data class Simulation(val blueprint: Blueprint) {
     private val cache: MutableMap<FastVector, Set<BuildResult>> = mutableMapOf()
     private fun FastVector.toView(): Vec3d = toVec3d().add(0.5, 0.62, 0.5)
-//    private lateinit var player: ClientPlayerEntity
-
-//    init {
-//        runSafe {
-//            this@Simulation.player = player
-//            BlockPos.iterateOutwards(player.blockPos, 5, 5, 5).forEach { pos ->
-//                val vec = pos.toFastVec()
-//                info("Preloading simulation at $vec")
-//                simulate(vec)
-//            }
-//        }
-//    }
-
-//    val best: FastVector? get() = cache.filter { (_, results) ->
-//        results.isNotEmpty() && results.any { it.rank.ordinal < 4 }
-//    }.keys.minByOrNull { it.toVec3d().distanceTo(player.pos) }
-
-//    fun best() = cache.filter { (_, results) ->
-//        results.isNotEmpty() && results.any { it.rank.ordinal < 3 }
-//    }.keys
 
     fun simulate(pos: FastVector): Set<BuildResult> {
         return cache.computeIfAbsent(pos) {
+            val view = pos.toView()
             runSafe {
+                if (blueprint.isOutOfBounds(view) && blueprint.getClosestPointTo(view).distanceTo(view) > 10.0) return@computeIfAbsent emptySet()
                 if (!playerFitsIn(Vec3d.ofBottomCenter(pos.toBlockPos()))) return@computeIfAbsent emptySet()
             }
-            blueprint.simulate(pos.toView(), reach = 3.5)
+            blueprint.simulate(view, reach = TaskFlow.interact.reach - 1)
         }
-//        return blueprint.simulate(pos.toView(), reach = 3.5)
     }
 
     private fun SafeContext.playerFitsIn(pos: Vec3d): Boolean {

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

@@ -83,9 +83,7 @@ class BuildTask @Ta5kBuilder constructor(
 
             val result = results.minOrNull() ?: return@listener
             when {
-                !result.rank.solvable -> {
-                    success(Unit)
-                }
+                !result.rank.solvable -> success(Unit)
                 result is BuildResult.NotVisible -> {
                     if (pathing) BaritoneUtils.setGoalAndPath(
                         BuildGoal(blueprint.simulation())