Merge remote-tracking branch 'origin/feature/packetmine-rewrite' into feature/packetmine-rewrite

Author: beanbag44

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

@@ -25,6 +25,8 @@ import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.interaction.request.rotation.RotationRequest
 import com.lambda.util.world.raycast.RayCastUtils.distanceTo
 import net.minecraft.block.BlockState
+import net.minecraft.block.Blocks
+import net.minecraft.block.FallingBlock
 import net.minecraft.client.network.ClientPlayerInteractionManager
 import net.minecraft.client.world.ClientWorld
 import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket
@@ -56,14 +58,16 @@ data class BreakContext(
 
     fun exposedSides(ctx: SafeContext) =
         Direction.entries.filter {
-            ctx.world.isAir(result.blockPos.offset(it))
+            ctx.world.isAir(expectedPos.offset(it))
         }
 
     override val expectedState: BlockState = checkedState.fluidState.blockState
 
     override fun compareTo(other: BuildContext): Int {
         return when (other) {
-            is BreakContext -> compareBy<BreakContext> {
+            is BreakContext -> compareByDescending<BreakContext> {
+                if (it.checkedState.block is FallingBlock) it.expectedPos.y else 0
+            }.thenBy {
                 it.rotation.target.angleDistance
             }.compare(this, other)
 

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

@@ -66,9 +66,11 @@ data class Simulation(
         blueprint.simulate(view, interact, rotation, inventory, build)
     }
 
-    fun goodPositions() = cache.filter { it.value.any { it.rank.ordinal < 4 } }.map { PossiblePos(it.key.toBlockPos()) }
+    fun goodPositions() = cache
+        .filter { entry -> entry.value.any { it.rank.ordinal < 4 } }
+        .map { PossiblePos(it.key.toBlockPos(), it.value.count { it.rank.ordinal < 4 }) }
 
-    class PossiblePos(val pos: BlockPos): Drawable {
+    class PossiblePos(val pos: BlockPos, val interactions: Int): Drawable {
         override fun SafeContext.buildRenderer() {
             withBox(Vec3d.ofBottomCenter(pos).playerBox(), Color(0, 255, 0, 50))
         }

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

@@ -18,6 +18,7 @@
 package com.lambda.task.tasks
 
 import baritone.api.pathing.goals.GoalBlock
+import baritone.api.pathing.goals.GoalNear
 import com.lambda.Lambda.LOG
 import com.lambda.config.groups.BuildConfig
 import com.lambda.config.groups.InteractionConfig
@@ -55,6 +56,7 @@ import com.lambda.util.extension.Structure
 import com.lambda.util.extension.inventorySlots
 import com.lambda.util.item.ItemUtils.block
 import com.lambda.util.player.SlotUtils.hotbarAndStorage
+import com.lambda.util.world.toFastVec
 import net.minecraft.entity.ItemEntity
 import net.minecraft.util.math.BlockPos
 import java.util.concurrent.ConcurrentLinkedQueue
@@ -95,13 +97,26 @@ class BuildTask @Ta5kBuilder constructor(
         listen<TickEvent.Pre> {
             if (collectDrops()) return@listen
 
-            // ToDo: Simulate for each pair player positions that work
             val results = blueprint.simulate(player.eyePos, interact, rotation, inventory, build)
+            val resultPostions = results.map { it.blockPos }
 
-            TaskFlowModule.drawables = results
+            val sim = blueprint.simulation(interact, rotation, inventory, build)
+            BlockPos.iterateOutwards(player.blockPos, 2, 2, 2).forEach {
+                sim.simulate(it.toFastVec())
+            }
+            val bestPos = sim.goodPositions()
+                .filter { it.pos !in resultPostions }
+                .maxByOrNull { it.interactions }
+
+            val drawables = results
                 .filterIsInstance<Drawable>()
                 .plus(pendingInteractions.toList())
-            //                .plus(sim.goodPositions())
+                .toMutableList()
+
+            if (bestPos != null) {
+                drawables.add(bestPos)
+            }
+            TaskFlowModule.drawables = drawables
 
             val resultsNotBlocked = results
                 .filter { result -> pendingInteractions.none { it.expectedPos == result.blockPos } }
@@ -127,7 +142,6 @@ class BuildTask @Ta5kBuilder constructor(
                 is BuildResult.NotVisible,
                 is PlaceResult.NoIntegrity -> {
                     if (!build.pathing) return@listen
-                    val sim = blueprint.simulation(interact, rotation, inventory, build)
                     val goal = BuildGoal(sim, player.blockPos)
                     BaritoneUtils.setGoalAndPath(goal)
                 }
@@ -137,6 +151,10 @@ class BuildTask @Ta5kBuilder constructor(
                 }
 
                 is BuildResult.Contextual -> {
+                    bestPos?.let {
+                        BaritoneUtils.setGoalAndPath(GoalNear(it.pos, 1))
+                    }
+
                     if (atMaxPendingInteractions) return@listen
                     when (bestResult) {
                         is BreakResult.Break -> {