Pathing strategies and more options

Author: Avanatiker

common/src/main/kotlin/com/lambda/config/groups/BuildConfig.kt

@@ -3,10 +3,13 @@ package com.lambda.config.groups
 interface BuildConfig {
     val breakCoolDown: Int
     val placeCooldown: Int
+    val placeConfirmation: Boolean
+    val breakConfirmation: Boolean
     val collectDrops: Boolean
     val breakWeakBlocks: Boolean
     val pathing: Boolean
     val breaksPerTick: Int
     val rotateForBreak: Boolean
+    val rotateForPlace: Boolean
     val swingHand: Boolean
 }

common/src/main/kotlin/com/lambda/config/groups/BuildSettings.kt

@@ -8,10 +8,13 @@ class BuildSettings(
 ) : BuildConfig {
     override val breakCoolDown by c.setting("Break Cooldown", 0, 0..1000, 1, "Delay between breaking blocks", " ms", vis)
     override val placeCooldown by c.setting("Place Cooldown", 0, 0..1000, 1, "Delay between placing blocks", " ms", vis)
+    override val placeConfirmation by c.setting("Place Confirmation", false, "Wait for block placement confirmation", vis)
+    override val breakConfirmation by c.setting("Break Confirmation", false, "Wait for block break confirmation", vis)
     override val collectDrops by c.setting("Collect All Drops", false, "Collect all drops when breaking blocks", vis)
     override val breakWeakBlocks by c.setting("Break Weak Blocks", false, "Break blocks that dont have structural integrity (e.g: grass)", vis)
     override val pathing by c.setting("Pathing", true, "Path to blocks", vis)
     override val breaksPerTick by c.setting("Instant Breaks Per Tick", 10, 1..30, 1, "Maximum instant block breaks per tick", "", vis)
     override val rotateForBreak by c.setting("Rotate For Break", false, "Rotate towards block while breaking", vis)
+    override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing", vis)
     override val swingHand by c.setting("Swing Hand", true, "Swing hand on interactions", vis)
 }

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

@@ -117,14 +117,9 @@ sealed class BreakResult : BuildResult() {
     data class PlayerOnTop(
         override val blockPos: BlockPos,
         val blockState: BlockState
-    ) : Navigable, Resolvable, BreakResult() {
+    ) : Navigable, BreakResult() {
         override val rank = Rank.BREAK_PLAYER_ON_TOP
 
-        override val resolve get() =
-            moveToGoalUntil(GoalInverted(GoalBlock(blockPos))) {
-                val pBox = player.boundingBox
-                val aabb = Box(pBox.minX, pBox.minY - 1.0E-6, pBox.minZ, pBox.maxX, pBox.minY, pBox.maxZ)
-                world.findSupportingBlockPos(player, aabb).orElse(null) != blockPos
-            }
+        override val goal = GoalInverted(GoalBlock(blockPos))
     }
 }

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

@@ -1,16 +1,13 @@
 package com.lambda.interaction.construction.result
 
+import baritone.api.pathing.goals.GoalBlock
+import baritone.api.pathing.goals.GoalNear
 import baritone.process.BuilderProcess.GoalPlace
 import com.lambda.interaction.construction.context.BuildContext
 import com.lambda.interaction.material.ContainerManager.transfer
 import com.lambda.interaction.material.StackSelection.Companion.select
 import com.lambda.interaction.material.container.MainHandContainer
-import com.lambda.task.Task
-import com.lambda.task.Task.Companion.emptyTask
 import com.lambda.task.Task.Companion.failTask
-import com.lambda.task.tasks.GoalTask.Companion.moveNearBlock
-import com.lambda.task.tasks.GoalTask.Companion.moveToGoal
-import com.lambda.task.tasks.GoalTask.Companion.moveUntilLoaded
 import net.minecraft.block.BlockState
 import net.minecraft.item.Item
 import net.minecraft.item.ItemStack
@@ -45,10 +42,10 @@ abstract class BuildResult : ComparableResult<Rank> {
      */
     data class ChunkNotLoaded(
         override val blockPos: BlockPos
-    ) : Navigable, Resolvable, BuildResult() {
+    ) : Navigable, BuildResult() {
         override val rank = Rank.CHUNK_NOT_LOADED
 
-        override val resolve get() = moveUntilLoaded(blockPos)
+        override val goal = GoalBlock(blockPos)
 
         override fun compareTo(other: ComparableResult<Rank>): Int {
             return when (other) {
@@ -112,12 +109,10 @@ abstract class BuildResult : ComparableResult<Rank> {
         val hitPos: BlockPos,
         val side: Direction,
         val distance: Double
-    ) : Navigable, Resolvable, BuildResult() {
+    ) : Navigable, BuildResult() {
         override val rank = Rank.NOT_VISIBLE
 
-        override val resolve get() = moveToGoal {
-            GoalPlace(blockPos)
-        }
+        override val goal = GoalPlace(blockPos)
 
         override fun compareTo(other: ComparableResult<Rank>): Int {
             return when (other) {
@@ -186,14 +181,14 @@ abstract class BuildResult : ComparableResult<Rank> {
         val hitVec: Vec3d,
         val reach: Double,
         val side: Direction,
-    ) : Navigable, Resolvable, BuildResult() {
+    ) : Navigable, BuildResult() {
         override val rank = Rank.OUT_OF_REACH
 
         val distance: Double by lazy {
             startVec.distanceTo(hitVec)
         }
 
-        override val resolve get() = moveNearBlock(blockPos, 2)
+        override val goal = GoalNear(blockPos, 2)
 
         override fun compareTo(other: ComparableResult<Rank>): Int {
             return when (other) {

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

@@ -1,3 +1,7 @@
 package com.lambda.interaction.construction.result
 
-interface Navigable
+import baritone.api.pathing.goals.Goal
+
+interface Navigable {
+    val goal: Goal
+}

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

@@ -1,5 +1,6 @@
 package com.lambda.interaction.construction.result
 
+import baritone.api.pathing.goals.Goal
 import baritone.api.pathing.goals.GoalBlock
 import baritone.api.pathing.goals.GoalInverted
 import com.lambda.interaction.construction.context.PlaceContext
@@ -59,12 +60,10 @@ sealed class PlaceResult : BuildResult() {
 
     data class BlockedByPlayer(
         override val blockPos: BlockPos
-    ) : Navigable, Resolvable, PlaceResult() {
+    ) : Navigable, PlaceResult() {
         override val rank = Rank.PLACE_BLOCKED_BY_PLAYER
 
-        override val resolve get() = moveToGoalUntil(GoalInverted(GoalBlock(blockPos))) {
-            !world.canCollide(player, Box(blockPos))
-        }
+        override val goal = GoalInverted(GoalBlock(blockPos))
     }
 
     /**
@@ -74,13 +73,10 @@ sealed class PlaceResult : BuildResult() {
     data class CantReplace(
         override val blockPos: BlockPos,
         val simulated: ItemPlacementContext
-    ) : Navigable, Resolvable, PlaceResult() {
+    ) : Resolvable, PlaceResult() {
         override val rank = Rank.PLACE_CANT_REPLACE
 
-//        override val resolve = breakBlock(simulated.blockPos)
-        override val resolve get() = moveToGoalUntil(GoalInverted(GoalBlock(blockPos))) {
-            !world.canCollide(player, Box(blockPos))
-        }
+        override val resolve = breakBlock(blockPos)
     }
 
     /**
@@ -123,6 +119,6 @@ sealed class PlaceResult : BuildResult() {
     ) : Resolvable, PlaceResult() {
         override val rank = Rank.PLACE_NOT_ITEM_BLOCK
 
-        override val resolve get() = Task.emptyTask() // ToDo: analyze interaction with non-block items
+        override val resolve get() = TODO("Not expected")
     }
 }

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

@@ -10,17 +10,17 @@ enum class Rank {
     NOT_VISIBLE,
     OUT_OF_REACH,
     BREAK_NOT_EXPOSED,
-    OUT_OF_WORLD,
     CHUNK_NOT_LOADED,
-    PLACE_NO_INTEGRITY,
     PLACE_CANT_REPLACE,
-    PLACE_NOT_ITEM_BLOCK,
-    BREAK_SUBMERGE,
-    BREAK_IS_BLOCKED_BY_LIQUID,
     BREAK_PLAYER_ON_TOP,
+    PLACE_NOT_ITEM_BLOCK,
 
     // not solvable
+    OUT_OF_WORLD,
     BREAK_RESTRICTED,
+    PLACE_NO_INTEGRITY,
+    BREAK_SUBMERGE,
+    BREAK_IS_BLOCKED_BY_LIQUID,
     UNBREAKABLE,
     BREAK_NO_PERMISSION,
     PLACE_SCAFFOLD_EXCEEDED,

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

@@ -126,10 +126,10 @@ object BuildSimulator {
                 acc.add(BuildResult.OutOfReach(pos, eye, hitPos.vecOf(hitSide), interact.reach, hitSide))
                 return@forEach
             }
+
             val verify: HitResult.() -> Boolean = {
                 blockResult?.blockPos == hitPos && blockResult?.side == hitSide
             }
-
             val validHits = mutableMapOf<Vec3d, HitResult>()
             val reachSq = interact.reach.pow(2)
 
@@ -251,7 +251,7 @@ object BuildSimulator {
 
                 val currentHandStack = player.getStackInHand(Hand.MAIN_HAND)
                 if (target is TargetState.Stack && !target.itemStack.equal(currentHandStack)) {
-                    acc.add(BuildResult.WrongStack(pos, placeContext, target.itemStack))
+                    acc.add(BuildResult.WrongStack(pos, placeContext, target.copy))
                     return@forEach
                 }
 

common/src/main/kotlin/com/lambda/module/modules/client/TaskFlow.kt

@@ -14,13 +14,10 @@ object TaskFlow : Module(
     defaultTags = setOf(ModuleTag.CLIENT, ModuleTag.AUTOMATION)
 ) {
     enum class Page {
-        TASKS, BUILD, ROTATION, INTERACTION
+        BUILD, ROTATION, INTERACTION, TASKS
     }
 
     private val page by setting("Page", Page.BUILD)
-    val taskCooldown by setting("Task Cooldown", 0, 0..10000, 10, " ms") {
-        page == Page.TASKS
-    }
     val build = BuildSettings(this) {
         page == Page.BUILD
     }
@@ -30,6 +27,9 @@ object TaskFlow : Module(
     val interact = InteractionSettings(this) {
         page == Page.INTERACTION
     }
+    val taskCooldown by setting("Task Cooldown", 0, 0..10000, 10, unit = " ms") {
+        page == Page.TASKS
+    }
 //    val disposables by setting("Disposables", ItemUtils.defaultDisposables)
     val ignoredBlocks = mutableSetOf<Block>().apply { addAll(allSigns) }
 }

common/src/main/kotlin/com/lambda/module/modules/player/HighwayTools.kt

@@ -1,16 +1,13 @@
 package com.lambda.module.modules.player
 
-import baritone.api.pathing.goals.GoalNear
 import com.lambda.interaction.construction.StaticBlueprint.Companion.toBlueprint
 import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.module.Module
 import com.lambda.module.tag.ModuleTag
 import com.lambda.task.Task
 import com.lambda.task.tasks.BuildStructure.Companion.buildStructure
 import com.lambda.util.BaritoneUtils
-import com.lambda.util.BaritoneUtils.primary
 import com.lambda.util.Communication.info
-import com.lambda.util.KeyCode
 import com.lambda.util.player.MovementUtils.octant
 import com.lambda.util.primitives.extension.Structure
 import com.lambda.util.world.StructureUtils.generateDirectionalTube
@@ -67,11 +64,9 @@ object HighwayTools : Module(
             structure += slice.map { it.key.add(currentPos) to it.value }
         }
 
-        buildStructure {
+        runningTask = buildStructure {
             structure.toBlueprint()
         }.apply {
-            runningTask = this
-            primary.customGoalProcess.setGoalAndPath(GoalNear(currentPos, sliceSize))
             onSuccess { _, _ ->
                 if (distanceMoved < distance || distance < 0) {
                     buildSlice()