Fix BuildTask context build timing, block inaccurate pathing positions

Author: Avanatiker

common/src/main/kotlin/com/lambda/interaction/construction/context/BuildContext.kt

@@ -39,11 +39,5 @@ interface BuildContext : Comparable<BuildContext>, Drawable {
     val rotation: RotationRequest
 
     fun interact(swingHand: Boolean)
-
-    override fun compareTo(other: BuildContext) =
-        compareBy<BuildContext> {
-            it.distance
-        }.compare(this, other)
-
     fun shouldRotate(config: BuildConfig): Boolean
 }

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

@@ -19,11 +19,19 @@ package com.lambda.interaction.construction.simulation
 
 import baritone.api.pathing.goals.Goal
 import com.lambda.util.world.fastVectorOf
+import com.lambda.util.world.toFastVec
+import net.minecraft.util.math.BlockPos
 
-class BuildGoal(private val sim: Simulation) : Goal {
-    override fun isInGoal(x: Int, y: Int, z: Int) =
-        sim.simulate(fastVectorOf(x, y, z))
-            .any { it.rank.ordinal < 4 }
+class BuildGoal(
+    private val sim: Simulation,
+    blocked: BlockPos
+) : Goal {
+    private val blockedVec = blocked.toFastVec()
+
+    override fun isInGoal(x: Int, y: Int, z: Int): Boolean {
+        val pos = fastVectorOf(x, y, z)
+        return sim.simulate(pos).any { it.rank.ordinal < 4 } && blockedVec != pos
+    }
 
     override fun heuristic(x: Int, y: Int, z: Int): Double {
         val bestRank = sim.simulate(fastVectorOf(x, y, z))

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

@@ -290,9 +290,7 @@ object BuildSimulator {
                 val placeContext = PlaceContext(
                     eye,
                     blockHit,
-                    RotationRequest(
-                        lookAtBlock(blockHit.blockPos, setOf(blockHit.side), config = interact), rotation
-                    ),
+                    RotationRequest(lookAt(checkedHit.targetRotation, 0.001), rotation),
                     eye.distanceTo(blockHit.pos),
                     resultState,
                     blockHit.blockPos.blockState(world),

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

@@ -43,6 +43,4 @@ data class RotationRequest(
         mode == RotationMode.None || runSafe {
             target.verify(target)
         } == true
-
-    fun megaDone() = target.distance < 0.001
 }

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

@@ -39,7 +39,6 @@ data class RotationTarget(
     val verify: RotationTarget.() -> Boolean = { hit?.verifyRotation() ?: true },
     private val buildRotation: SafeContext.() -> Rotation?,
 ) {
-
     val targetRotation = resettableLazy {
         runSafe { buildRotation() }
     }

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

@@ -67,6 +67,7 @@ class BuildTask @Ta5kBuilder constructor(
         build.maxPendingInteractions, build.interactionTimeout * 50L
     ) { info("${it::class.simpleName} at ${it.expectedPos.toShortString()} timed out") }
     private var currentInteraction: BuildContext? = null
+    private val instantBreaks = mutableSetOf<BreakContext>()
 
     private var placements = 0
     private var breaks = 0
@@ -79,9 +80,14 @@ class BuildTask @Ta5kBuilder constructor(
     init {
         listen<TickEvent.Pre> {
             currentInteraction?.let { context ->
-                if (context.shouldRotate(build) && !context.rotation.megaDone()) return@listen
+                if (context.shouldRotate(build) && !context.rotation.done) return@let
                 context.interact(interact.swingHand)
             }
+            instantBreaks.forEach { context ->
+                context.interact(interact.swingHand)
+                pendingInteractions.add(context)
+            }
+            instantBreaks.clear()
         }
 
         listen<TickEvent.Post> {
@@ -91,7 +97,9 @@ class BuildTask @Ta5kBuilder constructor(
                 failure("Structure is empty")
                 return@listen
             }
+        }
 
+        onRotate {
 //            val sim = blueprint.simulation(interact, rotation, inventory)
 //            BlockPos.iterateOutwards(player.blockPos, 5, 5, 5).forEach { pos ->
 //                sim.simulate(pos.toFastVec())
@@ -109,50 +117,33 @@ class BuildTask @Ta5kBuilder constructor(
                     .sorted()
                     .take(build.breaksPerTick)
 
-                instantResults.forEach {
-                    it.context.interact(interact.swingHand)
-                    pendingInteractions.add(it.context)
-                }
+                instantBreaks.addAll(instantResults.map { it.context })
 
-                if (instantResults.isNotEmpty()) return@listen
+                if (instantResults.isNotEmpty()) return@onRotate
             }
 
             val resultsWithoutPending = results.filterNot { result ->
                 result.blockPos in pendingInteractions.map { it.expectedPos }
             }
-            val bestResult = resultsWithoutPending.minOrNull() ?: return@listen
+            val bestResult = resultsWithoutPending.minOrNull() ?: return@onRotate
             when (bestResult) {
                 is BuildResult.Done,
                 is BuildResult.Ignored,
                 is BuildResult.Unbreakable,
                 is BuildResult.Restricted,
                 is BuildResult.NoPermission -> {
-                    if (pendingInteractions.isNotEmpty()) return@listen
+                    if (pendingInteractions.isNotEmpty()) return@onRotate
                     if (blueprint is PropagatingBlueprint) {
                         blueprint.next()
-                        return@listen
+                        return@onRotate
                     }
                     if (finishOnDone) success()
                 }
 
                 is BuildResult.NotVisible,
                 is PlaceResult.NoIntegrity -> {
-                    if (!build.pathing) return@listen
-                    // ToDo:
-                    //  Solve the problem that baritone stops pathing when it thinks it is in a valid goal
-                    //  but the player position does not perfectly match the simulated position
-                    // hacky fix for now is to walk "closer" but it wont work in every situation
-                    val interaction = object : InteractionConfig {
-                        override val attackReach = 3.0
-                        override val interactReach = interact.interactReach - 1
-                        override val scanReach = interact.scanReach
-                        override val strictRayCast = interact.strictRayCast
-                        override val checkSideVisibility = interact.checkSideVisibility
-                        override val resolution = interact.resolution
-                        override val pointSelection = interact.pointSelection
-                        override val swingHand = interact.swingHand
-                    }
-                    val goal = BuildGoal(blueprint.simulation(interaction, rotation, inventory, build))
+                    if (!build.pathing) return@onRotate
+                    val goal = BuildGoal(blueprint.simulation(interact, rotation, inventory, build), player.blockPos)
                     BaritoneUtils.setGoalAndPath(goal)
                 }
 
@@ -161,7 +152,7 @@ class BuildTask @Ta5kBuilder constructor(
                 }
 
                 is BuildResult.Contextual -> {
-                    if (pendingInteractions.size >= build.maxPendingInteractions) return@listen
+                    if (pendingInteractions.size >= build.maxPendingInteractions) return@onRotate
 
                     currentInteraction = bestResult.context
                 }
@@ -172,9 +163,7 @@ class BuildTask @Ta5kBuilder constructor(
                     bestResult.resolve().execute(this@BuildTask)
                 }
             }
-        }
 
-        onRotate {
             if (!build.rotateForPlace) return@onRotate
             val rotateTo = currentInteraction?.rotation ?: return@onRotate