Stacktraceing and shulker container

Author: Avanatiker

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

@@ -1,12 +1,14 @@
 package com.lambda.interaction.construction.result
 
+import baritone.process.BuilderProcess.GoalAdjacent
 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.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
@@ -105,12 +107,13 @@ abstract class BuildResult : ComparableResult<Rank> {
      */
     data class NotVisible(
         override val blockPos: BlockPos,
+        val hitPos: BlockPos,
         val side: Direction,
         val distance: Double
     ) : Resolvable, BuildResult() {
         override val rank = Rank.NOT_VISIBLE
 
-        override val resolve = emptyTask()
+        override val resolve = moveToGoal(GoalAdjacent(hitPos, blockPos, true))
 
         override fun compareTo(other: ComparableResult<Rank>): Int {
             return when (other) {

common/src/main/kotlin/com/lambda/interaction/material/ContainerManager.kt

@@ -23,7 +23,7 @@ import java.util.TreeSet
 // ToDo: Make this a Configurable to save container caches. Should use a cached region based storage system.
 object ContainerManager : Loadable {
     // ToDo: Maybe use reflection to get all containers?
-    val container = TreeSet<MaterialContainer>().apply {
+    private val container = TreeSet<MaterialContainer>().apply {
         add(CreativeContainer)
         add(EnderChestContainer)
         add(HotbarContainer)
@@ -70,23 +70,27 @@ object ContainerManager : Loadable {
         }
     }
 
+    fun container() = container.flatMap {
+        setOf(it) + it.shulkerContainer
+    }
+
     fun StackSelection.transfer(destination: MaterialContainer) =
         findContainerWithSelection(this)?.transfer(this, destination)
 
     fun findContainer(
         block: (MaterialContainer) -> Boolean
-    ): MaterialContainer? = container.find(block)
+    ): MaterialContainer? = container().find(block)
 
     fun findContainerWithSelection(
         selection: StackSelection
     ): MaterialContainer? =
-        container.find { it.available(selection) >= selection.count }
+        container().find { it.available(selection) >= selection.count }
 
     fun findContainerWithSelection(
         selectionBuilder: StackSelection.() -> Unit
     ): MaterialContainer? {
         val selection = StackSelection().apply(selectionBuilder)
-        return container.find { it.available(selection) >= selection.count }
+        return container().find { it.available(selection) >= selection.count }
     }
 
     fun findContainerWithStacks(

common/src/main/kotlin/com/lambda/interaction/material/MaterialContainer.kt

@@ -4,7 +4,6 @@ import com.lambda.interaction.material.StackSelection.Companion.select
 import com.lambda.interaction.material.container.ShulkerBoxContainer
 import com.lambda.interaction.material.transfer.TransferResult
 import com.lambda.task.Task
-import com.lambda.task.Task.Companion.emptyTask
 import com.lambda.util.item.ItemStackUtils.count
 import com.lambda.util.item.ItemStackUtils.empty
 import com.lambda.util.item.ItemStackUtils.shulkerBoxContents
@@ -18,6 +17,17 @@ abstract class MaterialContainer(
 ) : Comparable<MaterialContainer> {
     abstract var stacks: List<ItemStack>
 
+    val shulkerContainer get() =
+        stacks.filter {
+            it.item in ItemUtils.shulkerBoxes
+        }.map { stack ->
+            ShulkerBoxContainer(
+                stack.shulkerBoxContents,
+                containedIn = this@MaterialContainer,
+                shulkerStack = stack,
+            )
+        }.toSet()
+
     fun update(stacks: List<ItemStack>) {
         this.stacks = stacks
     }
@@ -53,17 +63,17 @@ abstract class MaterialContainer(
             }
         } ?: deposit(selection)
 
-    open fun filter(selection: StackSelection) =
-        selection.filterStacks(stacks)
+    open fun StackSelection.matchingStacks() =
+        filterStacks(stacks)
 
-    open fun filter(selection: (ItemStack) -> Boolean) =
-        filter(selection.select())
+    open fun matchingStacks(selection: (ItemStack) -> Boolean) =
+        selection.select().matchingStacks()
 
     open fun available(selection: StackSelection) =
-        filter(selection).count
+        selection.matchingStacks().count
 
     open fun spaceLeft(selection: StackSelection) =
-        filter(selection).spaceLeft + stacks.empty * selection.stackSize
+        selection.matchingStacks().spaceLeft + stacks.empty * selection.stackSize
 
     fun transfer(selection: StackSelection, destination: MaterialContainer): TransferResult {
         val amount = available(selection)
@@ -87,17 +97,6 @@ abstract class MaterialContainer(
         )
     }
 
-    fun List<ItemStack>.doShulkerCheck() =
-        filter {
-            it.item in ItemUtils.shulkerBoxes
-        }.map { stack ->
-            ShulkerBoxContainer(
-                stack.shulkerBoxContents,
-                containedIn = this@MaterialContainer,
-                shulkerStack = stack,
-            )
-        }.toSet()
-
     enum class Rank {
         CREATIVE,
         MAIN_HAND,

common/src/main/kotlin/com/lambda/interaction/material/container/MainHandContainer.kt

@@ -20,7 +20,7 @@ object MainHandContainer : MaterialContainer(Rank.MAIN_HAND) {
     override fun withdraw(selection: StackSelection) = emptyTask("WithdrawFromMainHand")
 
     override fun deposit(selection: StackSelection) = buildTask("DepositToMainHand") {
-        InventoryContainer.filter(selection).firstOrNull()?.let { stack ->
+        selection.matchingStacks().firstOrNull()?.let { stack ->
             if (ItemStack.areEqual(stack, player.mainHandStack)) {
                 return@buildTask
             }

common/src/main/kotlin/com/lambda/interaction/visibilty/VisibilityChecker.kt

@@ -32,8 +32,8 @@ object VisibilityChecker {
 
     fun SafeContext.lookAtBlock(
         blockPos: BlockPos,
-        rotationConfig: IRotationConfig = TaskFlow.rotationSettings,
-        interactionConfig: InteractionConfig = TaskFlow.interactionSettings,
+        rotationConfig: IRotationConfig = TaskFlow.rotation,
+        interactionConfig: InteractionConfig = TaskFlow.interact,
         sides: Set<Direction> = emptySet()
     ): RotationContext? {
         val state = blockPos.blockState(world)
@@ -46,8 +46,8 @@ object VisibilityChecker {
 
     fun SafeContext.findRotation(
         boxes: List<Box>,
-        rotationConfig: IRotationConfig = TaskFlow.rotationSettings,
-        interact: InteractionConfig = TaskFlow.interactionSettings,
+        rotationConfig: IRotationConfig = TaskFlow.rotation,
+        interact: InteractionConfig = TaskFlow.interact,
         sides: Set<Direction> = emptySet(),
         verify: HitResult.() -> Boolean,
     ): RotationContext? {

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

@@ -18,13 +18,13 @@ object TaskFlow : Module(
     }
 
     private val page by setting("Page", Page.BUILD)
-    val buildSettings = BuildSettings(this) {
+    val build = BuildSettings(this) {
         page == Page.BUILD
     }
-    val rotationSettings = RotationSettings(this) {
+    val rotation = RotationSettings(this) {
         page == Page.ROTATION
     }
-    val interactionSettings = InteractionSettings(this) {
+    val interact = InteractionSettings(this) {
         page == Page.INTERACTION
     }
 //    val disposables by setting("Disposables", ItemUtils.defaultDisposables)

common/src/main/kotlin/com/lambda/task/Task.kt

@@ -217,7 +217,10 @@ abstract class Task<Result>(
     }
 
     @Ta5kBuilder
-    fun failure(e: Throwable) {
+    fun failure(
+        e: Throwable,
+        stacktrace: MutableList<Task<*>> = mutableListOf()
+    ) {
         if (attempted < tries) {
             attempted++
             warn("Failed task with error: ${e.message}, retrying ($attempted/$tries) ...")
@@ -230,10 +233,21 @@ abstract class Task<Result>(
         }
 
         state = State.FAILED
-        logError("Task failed after $attempted attempts with error: ${e.message}")
         stopListening()
         runSafe { onException(this@Task, e) }
-        parent?.failure(e)
+        stacktrace.add(this)
+        parent?.failure(e, stacktrace) ?: run {
+            val message = buildString {
+                stacktrace.firstOrNull()?.let { first ->
+                    append("${first.identifier} failed: ${e.message}\n")
+                    stacktrace.drop(1).forEach {
+                        append("  -> ${it.identifier}\n")
+                    }
+                }
+            }
+            LOG.error(message, e)
+            logError(message)
+        }
     }
 
     /**

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

@@ -20,13 +20,13 @@ import net.minecraft.util.math.Direction
 
 class BreakBlock @Ta5kBuilder constructor(
     private val ctx: BreakContext,
-    private val rotationConfig: IRotationConfig = TaskFlow.rotationSettings,
-    private val interactionConfig: InteractionConfig = TaskFlow.interactionSettings,
+    private val rotationConfig: IRotationConfig = TaskFlow.rotation,
+    private val interactionConfig: InteractionConfig = TaskFlow.interact,
     private val sides: Set<Direction> = emptySet(),
-    private val collectDrop: Boolean = TaskFlow.buildSettings.collectDrops,
-    private val rotate: Boolean = TaskFlow.buildSettings.rotateForBreak,
-    private val swingHand: Boolean = TaskFlow.buildSettings.swingHand,
-    private val particles: Boolean = TaskFlow.buildSettings.particlesOnBreak,
+    private val collectDrop: Boolean = TaskFlow.build.collectDrops,
+    private val rotate: Boolean = TaskFlow.build.rotateForBreak,
+    private val swingHand: Boolean = TaskFlow.build.swingHand,
+    private val particles: Boolean = TaskFlow.build.particlesOnBreak,
 ) : Task<ItemEntity?>() {
     val blockPos: BlockPos get() = ctx.result.blockPos
     private var beginState: BlockState? = null
@@ -85,8 +85,8 @@ class BreakBlock @Ta5kBuilder constructor(
         @Ta5kBuilder
         fun breakBlock(
             ctx: BreakContext,
-            rotationConfig: IRotationConfig = TaskFlow.rotationSettings,
-            interactionConfig: InteractionConfig = TaskFlow.interactionSettings,
+            rotationConfig: IRotationConfig = TaskFlow.rotation,
+            interactionConfig: InteractionConfig = TaskFlow.interact,
             sides: Set<Direction> = emptySet(),
             collectDrop: Boolean = false,
             rotate: Boolean = false,