Stack selection container transfer fixes

Avanatiker · Avanatiker · commit d1e0c66e7f5b · 2024-05-30T18:23:02.000+02:00
diff --git a/common/src/main/kotlin/com/lambda/command/commands/TransferCommand.kt b/common/src/main/kotlin/com/lambda/command/commands/TransferCommand.kt
@@ -0,0 +1,21 @@
+package com.lambda.command.commands
+
+import com.lambda.brigadier.execute
+import com.lambda.command.LambdaCommand
+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.util.primitives.extension.CommandBuilder
+import net.minecraft.item.Items
+
+object TransferCommand : LambdaCommand(
+    name = "transfer",
+    usage = "transfer <item> <amount> <to>",
+    description = "Transfer items to a container"
+) {
+    override fun CommandBuilder.create() {
+        execute {
+            Items.OBSIDIAN.select().transfer(MainHandContainer).solve.start(null)
+        }
+    }
+}
diff --git a/common/src/main/kotlin/com/lambda/interaction/construction/context/BreakContext.kt b/common/src/main/kotlin/com/lambda/interaction/construction/context/BreakContext.kt
@@ -14,7 +14,7 @@ data class BreakContext(
     val result: BlockHitResult,
     val rotation: RotationContext,
     val checkedState: BlockState,
-    val hand: Hand,
+    var hand: Hand,
     val instantBreak: Boolean,
 ) : BuildContext, ComparableContext {
     override val distance: Double by lazy {
diff --git a/common/src/main/kotlin/com/lambda/interaction/construction/result/BreakResult.kt b/common/src/main/kotlin/com/lambda/interaction/construction/result/BreakResult.kt
@@ -2,9 +2,9 @@ package com.lambda.interaction.construction.result
 
 import com.lambda.interaction.construction.context.BreakContext
 import com.lambda.interaction.material.ContainerManager.findBestAvailableTool
+import com.lambda.interaction.material.ContainerManager.transfer
 import com.lambda.interaction.material.StackSelection.Companion.select
 import com.lambda.interaction.material.StackSelection.Companion.selectStack
-import com.lambda.interaction.material.container.CreativeContainer.transfer
 import com.lambda.interaction.material.container.MainHandContainer
 import com.lambda.task.Task
 import com.lambda.task.Task.Companion.emptyTask
diff --git a/common/src/main/kotlin/com/lambda/interaction/material/ContainerManager.kt b/common/src/main/kotlin/com/lambda/interaction/material/ContainerManager.kt
@@ -70,6 +70,10 @@ object ContainerManager : Loadable {
         }
     }
 
+    fun StackSelection.transfer(destination: MaterialContainer) =
+        findContainerWithSelection(this)?.transfer(this, destination)
+            ?: throw NoContainerFound(this)
+
     fun findContainer(
         block: (MaterialContainer) -> Boolean
     ): MaterialContainer? = container.find(block)
diff --git a/common/src/main/kotlin/com/lambda/interaction/material/MaterialContainer.kt b/common/src/main/kotlin/com/lambda/interaction/material/MaterialContainer.kt
@@ -52,26 +52,26 @@ abstract class MaterialContainer(
     open fun spaceLeft(selection: StackSelection) =
         filter(selection).spaceLeft + stacks.empty * selection.stackSize
 
-    fun StackSelection.transfer(destination: MaterialContainer): TransferResult {
-        val amount = available(this)
-        if (amount < count) {
-            return TransferResult.MissingItems(amount - count)
+    fun transfer(selection: StackSelection, destination: MaterialContainer): TransferResult {
+        val amount = available(selection)
+        if (amount < selection.count) {
+            return TransferResult.MissingItems(amount - selection.count)
         }
 
-        val space = destination.spaceLeft(this)
-        if (space == 0) {
-            return TransferResult.NoSpace
-        }
+//        val space = destination.spaceLeft(selection)
+//        if (space == 0) {
+//            return TransferResult.NoSpace
+//        }
 
-        val transferAmount = minOf(amount, space)
-        selector = { true }
-        count = transferAmount
+//        val transferAmount = minOf(amount, space)
+//        selection.selector = { true }
+//        selection.count = transferAmount
 
         return TransferResult.Success(
             prepare().onSuccess { prep, _ ->
-                withdraw(this@transfer).onSuccess { with, _ ->
+                withdraw(selection).onSuccess { with, _ ->
                     destination.prepare().onSuccess { dest, _ ->
-                        destination.deposit(this@transfer).start(dest)
+                        destination.deposit(selection).start(dest)
                     }.start(with)
                 }.start(prep)
             }
diff --git a/common/src/main/kotlin/com/lambda/interaction/material/container/ChestContainer.kt b/common/src/main/kotlin/com/lambda/interaction/material/container/ChestContainer.kt
@@ -30,17 +30,17 @@ data class ChestContainer(
 
     override fun withdraw(selection: StackSelection) =
         openContainer<GenericContainerScreenHandler>(blockPos)
-            .withMaxAttempts(3)
-            .withTimeout(20)
+//            .withMaxAttempts(3)
+//            .withTimeout(20)
             .onSuccess { open, screen ->
                 info("Withdrawing $selection from ${screen.type}")
                 withdraw(screen, selection).start(open)
             }
 
     override fun deposit(selection: StackSelection) =
         openContainer<GenericContainerScreenHandler>(blockPos)
-            .withMaxAttempts(3)
-            .withTimeout(20)
+//            .withMaxAttempts(3)
+//            .withTimeout(20)
             .onSuccess { open, screen ->
                 info("Depositing $selection to ${screen.type}")
                 deposit(screen, selection).start(open)
diff --git a/common/src/main/kotlin/com/lambda/interaction/material/container/HotbarContainer.kt b/common/src/main/kotlin/com/lambda/interaction/material/container/HotbarContainer.kt
@@ -4,19 +4,21 @@ import com.lambda.Lambda.mc
 import com.lambda.interaction.material.MaterialContainer
 import com.lambda.interaction.material.StackSelection
 import com.lambda.task.Task
+import com.lambda.task.Task.Companion.emptyTask
+import com.lambda.task.tasks.InventoryTask.Companion.deposit
 import com.lambda.util.player.SlotUtils.hotbar
+import net.minecraft.client.gui.screen.ingame.ScreenHandlerProvider
 import net.minecraft.item.ItemStack
 
 object HotbarContainer : MaterialContainer(Rank.HOTBAR) {
     override var stacks: List<ItemStack>
         get() = mc.player?.hotbar ?: emptyList()
         set(_) {}
 
-    override fun withdraw(selection: StackSelection): Task<*> {
-        TODO("Not yet implemented")
-    }
+    override fun withdraw(selection: StackSelection) = emptyTask("HotbarWithdraw")
 
     override fun deposit(selection: StackSelection): Task<*> {
-        TODO("Not yet implemented")
+        val handledScreen = mc.currentScreen as? ScreenHandlerProvider<*> ?: return emptyTask()
+        return deposit(handledScreen.screenHandler, selection)
     }
 }
diff --git a/common/src/main/kotlin/com/lambda/interaction/material/container/InventoryContainer.kt b/common/src/main/kotlin/com/lambda/interaction/material/container/InventoryContainer.kt
@@ -12,11 +12,7 @@ object InventoryContainer : MaterialContainer(Rank.INVENTORY) {
         get() = mc.player?.combined ?: emptyList()
         set(_) {}
 
-    override fun withdraw(selection: StackSelection): Task<*> {
-        TODO("Not yet implemented")
-    }
+    override fun withdraw(selection: StackSelection) = Task.emptyTask()
 
-    override fun deposit(selection: StackSelection): Task<*> {
-        TODO("Not yet implemented")
-    }
+    override fun deposit(selection: StackSelection) = Task.emptyTask()
 }
diff --git a/common/src/main/kotlin/com/lambda/interaction/material/container/MainHandContainer.kt b/common/src/main/kotlin/com/lambda/interaction/material/container/MainHandContainer.kt
@@ -5,6 +5,8 @@ import com.lambda.interaction.material.MaterialContainer
 import com.lambda.interaction.material.StackSelection
 import com.lambda.module.modules.client.TaskFlow
 import com.lambda.task.Task
+import com.lambda.task.Task.Companion.buildTask
+import com.lambda.task.Task.Companion.emptyTask
 import com.lambda.util.player.SlotUtils.combined
 import com.lambda.util.player.SlotUtils.hotbar
 import kotlinx.coroutines.delay
@@ -18,38 +20,31 @@ object MainHandContainer : MaterialContainer(Rank.MAIN_HAND) {
         get() = mc.player?.mainHandStack?.let { listOf(it) } ?: emptyList()
         set(_) {}
 
-    override fun withdraw(selection: StackSelection): Task<*> {
-        TODO("Not yet implemented")
-    }
-//        InventoryContainer.stacks.filter(selection.selector).take(selection.count).forEach { stack ->
-//            if (ItemStack.areEqual(stack, player.mainHandStack)) {
-//                return@forEach
-//            }
-//
-//            if (ItemStack.areEqual(stack, player.offHandStack)) {
-//                connection.sendPacket(
-//                    PlayerActionC2SPacket(
-//                        PlayerActionC2SPacket.Action.SWAP_ITEM_WITH_OFFHAND,
-//                        BlockPos.ORIGIN,
-//                        Direction.DOWN,
-//                    ),
-//                )
-//                delay(TaskFlow.itemMoveDelay)
-//                return@forEach
-//            }
-//
-//            if (stack in player.hotbar) {
-//                player.inventory.selectedSlot = player.hotbar.indexOf(stack)
-//                delay(TaskFlow.itemMoveDelay)
-//                return@forEach
-//            }
-//
-//            interaction.pickFromInventory(player.combined.indexOf(stack))
-//            delay(TaskFlow.itemMoveDelay)
-//        }
-//    }
+    override fun withdraw(selection: StackSelection) = emptyTask("WithdrawFromMainHand")
+
+    override fun deposit(selection: StackSelection) = buildTask("DepositToMainHand") {
+        InventoryContainer.filter(selection).firstOrNull()?.let { stack ->
+            if (ItemStack.areEqual(stack, player.mainHandStack)) {
+                return@buildTask
+            }
+
+            if (ItemStack.areEqual(stack, player.offHandStack)) {
+                connection.sendPacket(
+                    PlayerActionC2SPacket(
+                        PlayerActionC2SPacket.Action.SWAP_ITEM_WITH_OFFHAND,
+                        BlockPos.ORIGIN,
+                        Direction.DOWN,
+                    ),
+                )
+                return@buildTask
+            }
+
+            if (stack in player.hotbar) {
+                player.inventory.selectedSlot = player.hotbar.indexOf(stack)
+                return@buildTask
+            }
 
-    override fun deposit(selection: StackSelection): Task<*> {
-        TODO("Not yet implemented")
+            interaction.pickFromInventory(player.combined.indexOf(stack))
+        }
     }
 }
diff --git a/common/src/main/kotlin/com/lambda/module/modules/player/Nuker.kt b/common/src/main/kotlin/com/lambda/module/modules/player/Nuker.kt
@@ -8,9 +8,8 @@ import com.lambda.task.Task
 import com.lambda.task.Task.Companion.emptyTask
 import com.lambda.task.tasks.BuildStructure.Companion.buildStructure
 import com.lambda.util.BlockUtils.blockPos
-import com.lambda.util.BlockUtils.instantBreakable
-import com.lambda.util.BlockUtils.safeLiquid
 import com.lambda.util.BlockUtils.blockState
+import com.lambda.util.BlockUtils.instantBreakable
 import com.lambda.util.KeyCode
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Vec3i
@@ -23,7 +22,6 @@ object Nuker : Module(
 ) {
     private val flatten by setting("Flatten", true)
     private val onlyBreakInstant by setting("Only Break Instant", true)
-    private val doNotExposeLiquids by setting("Do Not Expose Liquids", true)
     private val fillFloor by setting("Fill Floor", false)
 
     private val range = Vec3i(4, 4, 4) // TODO: Customizable
@@ -42,7 +40,6 @@ object Nuker : Module(
                         .filter { !world.isAir(it) }
                         .filter { !flatten || it.y >= player.blockPos.y }
                         .filter { !onlyBreakInstant || instantBreakable(it.blockState(world), it) }
-                        .filter { !doNotExposeLiquids || safeLiquid(it) }
                         .associateWith { TargetState.Air }
 
 //                    if (fillFloor) {
diff --git a/common/src/main/kotlin/com/lambda/task/Task.kt b/common/src/main/kotlin/com/lambda/task/Task.kt
@@ -400,10 +400,12 @@ abstract class Task<Result>(
         val MAX_DEPTH = 20
         const val MAX_DEBUG_ENTRIES = 7
 
+        interface EmptyTask
+
         @Ta5kBuilder
         fun emptyTask(
             name: String = "EmptyTask",
-        ) = object : Task<Unit>() {
+        ): Task<Unit> = object : EmptyTask, Task<Unit>() {
             init { this.name = name }
             override fun SafeContext.onStart() { success(Unit) }
         }
diff --git a/common/src/main/kotlin/com/lambda/task/tasks/BuildStructure.kt b/common/src/main/kotlin/com/lambda/task/tasks/BuildStructure.kt
@@ -103,6 +103,8 @@ class BuildStructure(
 
                 lastResult = result
                 cancelSubTasks()
+
+                if (!pathing && result is BreakResult.OutOfReach) return@let
                 result.resolve.start(this@BuildStructure, false)
             }
         }
@@ -280,15 +282,17 @@ class BuildStructure(
 
             /* player has a better tool for the job available */
             findBestAvailableTool(state)?.let { bestTool ->
-                var added = false
-                Hand.entries.forEach {
+                Hand.entries.firstOrNull {
                     val stack = player.getStackInHand(it)
-                    if (stack.isEmpty) return@forEach
-                    if (stack.item == bestTool) return@forEach
-                    added = true
+                    stack.item == bestTool
+                }?.let { hand ->
+                    breakContext.hand = hand
+                    acc.add(BreakResult.Success(pos, breakContext))
+                    return acc
+                } ?: run {
                     acc.add(BreakResult.WrongTool(pos, breakContext, bestTool))
+                    return acc
                 }
-                if (added) return acc
             }
 
             acc.add(BreakResult.Success(pos, breakContext))
diff --git a/common/src/main/kotlin/com/lambda/task/tasks/OpenContainer.kt b/common/src/main/kotlin/com/lambda/task/tasks/OpenContainer.kt
@@ -28,7 +28,7 @@ class OpenContainer<H : ScreenHandler>(
         listener<ScreenHandlerEvent.Open<H>> {
             screenHandler = it.screenHandler
 
-            if (!waitForSlotLoad) success(it.screenHandler)
+            if (!waitForSlotLoad || slotsLoaded) success(it.screenHandler)
         }
 
         listener<ScreenHandlerEvent.Close<H>> {
@@ -42,10 +42,12 @@ class OpenContainer<H : ScreenHandler>(
         }
 
         listener<RotationEvent.Pre> { event ->
+            if (screenHandler != null) return@listener
             event.context = lookAtBlock(blockPos, rotationConfig, interactionConfig, sides)
         }
 
         listener<RotationEvent.Post> {
+            if (screenHandler != null) return@listener
             if (!it.context.isValid) return@listener
             val hitResult = it.context.hitResult?.blockResult ?: return@listener
             interaction.interactBlock(player, Hand.MAIN_HAND, hitResult)
diff --git a/common/src/main/kotlin/com/lambda/util/BlockUtils.kt b/common/src/main/kotlin/com/lambda/util/BlockUtils.kt
@@ -105,10 +105,6 @@ object BlockUtils {
 //        info("State: $blockState Ticks to break: $ticksNeeded")
         return ticksNeeded <= 1 && ticksNeeded != 0f
     }
-    fun SafeContext.safeLiquid(blockPos: BlockPos) = Direction.entries.all {
-        if (it == Direction.UP) return@all true
-        world.getFluidState(blockPos.offset(it)).isEmpty
-    }
     val Vec3i.blockPos: BlockPos get() = BlockPos(this)
     val Block.item: Item get() = asItem()
     val Vec3d.flooredPos: BlockPos get() = BlockPos(floor(x).toInt(), floor(y).toInt(), floor(z).toInt())

Original file line number	Diff line number	Diff line change
`@@ -70,6 +70,10 @@ object ContainerManager : Loadable {`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`
	`73`	`+ fun StackSelection.transfer(destination: MaterialContainer) =`
	`74`	`+ findContainerWithSelection(this)?.transfer(this, destination)`
	`75`	`+ ?: throw NoContainerFound(this)`
	`76`	`+`
`73`	`77`	`fun findContainer(`
`74`	`78`	`block: (MaterialContainer) -> Boolean`
`75`	`79`	`): MaterialContainer? = container.find(block)`