more general packet mine logic

Author: beanbag44

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

@@ -46,45 +46,65 @@ object PacketMineTaskRewrite : Module(
 ) {
     private val page by setting("Page", Page.General)
 
-    private val doubleBreak = setting(
+    private val doubleBreak by setting(
         "Double Break",
         false,
         "Lets the player break two blocks at once"
     ) { page == Page.General }
-    private val breakThreshold = setting(
-        "Break Threshold",
-        0.7f,
-        0.0f..1.1f,
-        0.1f,
-        "The time taken to break a block compared to vanilla speed (lower is faster)"
-    ) { page == Page.General }
-    private val validateBreak = setting(
+    private val validateBreak by setting(
         "Validate Break",
         false,
         "Awaits the servers response before confirming the block to be broken"
     ) { page == Page.General }
-    private val useInventory = setting(
+    private val useInventory by setting(
         "Use Inventory",
         false,
         "Allows usage of tools within the players inventory"
     ) { page == Page.General }
 
-    private var primaryBreakTask: PacketBreakInfo? = null
-    private var secondaryBreakTask: PacketBreakInfo? = null
+    private val reBreak by setting(
+        "Re-Break",
+        true,
+        "Re-breaks the block if replaced again, keeping the progress from the first"
+    ) { page == Page.Rebreak }
+    private val reBreakStyle by setting(
+        "Re-Break Style",
+        ReBreak.Standard,
+        "Affects the speed and style of re-break"
+    ) { page == Page.Rebreak }
+
+    private val queueBlocks by setting(
+        "Queue Blocks",
+        false,
+        "Adds blocks to a queue to break sequentially after the current breaking blocks are complete"
+    ) { page == Page.Queue }
+
+    private var breakTasks = arrayOfNulls<PacketBreakInfo>(2)
+    private var primaryBreakTask: PacketBreakInfo?
+        get() = breakTasks[0]
+        set(value) { breakTasks[0] = value }
+    private var secondaryBreakTask: PacketBreakInfo?
+        get() = breakTasks[1]
+        set(value) { breakTasks[1] = value }
+
+    private val blockQueue = ArrayDeque<BlockPos>()
 
     init {
         listen<PlayerEvent.Attack.Block> { event ->
             event.cancel()
 
             val pos = event.pos
-            val vec3dPos = event.pos.vec3d
-            val hitResult = BlockHitResult(vec3dPos, event.side, pos, false)
             val blockState = pos.blockState(world)
             val bestTool =
                 findBestAvailableTool(blockState)?.select()?.itemStack
                     ?: player.mainHandStack
 
-            primaryBreakTask?.cancelBreak()
+            if (doubleBreak && secondaryBreakTask == null) {
+                secondaryBreakTask = primaryBreakTask
+            } else {
+                primaryBreakTask?.cancelBreak()
+            }
+
             primaryBreakTask = PacketBreakInfo(
                 pos,
                 blockState,
@@ -95,7 +115,11 @@ object PacketMineTaskRewrite : Module(
         }
 
         onDisable {
-
+            breakTasks.forEach {
+                it?.cancelBreak()
+            }
+            breakTasks = arrayOfNulls(2)
+            blockQueue.clear()
         }
     }
 
@@ -122,7 +146,14 @@ object PacketMineTaskRewrite : Module(
                 instantBreak
             )
             packetBreakTask = PacketBreakBlock(
-                breakContext
+                breakContext,
+                false,
+                TaskFlowModule.rotation,
+                TaskFlowModule.interact,
+                validateBreak,
+                Direction.entries.toSet(),
+                TaskFlowModule.build.rotateForBreak,
+                PacketBreakBlock.SwingHandStyle.Start,
             )
         }
 
@@ -139,6 +170,13 @@ object PacketMineTaskRewrite : Module(
     private enum class Page {
         General,
         Rebreak,
+        Queue,
         Render
     }
+
+    private enum class ReBreak {
+        Standard,
+        Automatic,
+        FastAutomatic
+    }
 }

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

@@ -37,6 +37,8 @@ import com.lambda.util.player.SlotUtils.clickSlot
 import com.lambda.util.player.SlotUtils.hotbarAndStorage
 import net.minecraft.block.BlockState
 import net.minecraft.entity.ItemEntity
+import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket
+import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket.Action
 import net.minecraft.screen.slot.SlotActionType
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
@@ -46,9 +48,10 @@ class PacketBreakBlock @Ta5kBuilder constructor(
     private val collectDrop: Boolean = false,
     private val rotation: RotationConfig = TaskFlowModule.rotation,
     private val interact: InteractionConfig = TaskFlowModule.interact,
+    private val validateBreak: Boolean = true,
     private val sides: Set<Direction> = Direction.entries.toSet(),
     private val rotate: Boolean = TaskFlowModule.build.rotateForBreak,
-    private val swingHand: Boolean = TaskFlowModule.interact.swingHand,
+    private val swingHand: SwingHandStyle = SwingHandStyle.Start,
 ) : Task<ItemEntity?>() {
     override val name get() = "Packet breaking ${ctx.result.blockPos.toShortString()}"
 
@@ -62,6 +65,8 @@ class PacketBreakBlock @Ta5kBuilder constructor(
     private var state = State.BREAKING
     private var isValid = false
 
+    private var breakAmount = 0f
+
     enum class State {
         BREAKING, COLLECTING
     }
@@ -75,7 +80,8 @@ class PacketBreakBlock @Ta5kBuilder constructor(
         beginState = blockState
 
         if (!rotate || ctx.instantBreak) {
-            hitBlock(ctx.result.side)
+            stepDamage(ctx.result.side)
+            if (swingHand != SwingHandStyle.End) player.swingHand(ctx.hand)
         }
     }
 
@@ -114,7 +120,7 @@ class PacketBreakBlock @Ta5kBuilder constructor(
             } ?: BaritoneUtils.cancel()
 
             if (isValid || !rotate || ctx.instantBreak) {
-                hitBlock(ctx.result.side)
+                stepDamage(ctx.result.side)
             }
 
             if (done()) {
@@ -127,22 +133,48 @@ class PacketBreakBlock @Ta5kBuilder constructor(
 
         // ToDo: Find out when the stack entity is filled with the item
         listen<WorldEvent.EntityUpdate> {
+            val entity = it.entity
             if (collectDrop
-                && it.entity is ItemEntity
-                && it.entity.pos.isInRange(blockPos.toCenterPos(), 0.5)
+                && entity is ItemEntity
+                && entity.pos.isInRange(blockPos.toCenterPos(), 0.5)
             ) {
-                drop = it.entity
+                drop = entity
                 state = State.COLLECTING
             }
         }
     }
 
-    private fun SafeContext.done() = blockState.isAir && !collectDrop
+    private fun SafeContext.done() =
+        !collectDrop && (blockState.isAir || (!validateBreak && breakAmount >= 1.0f))
 
-    private fun SafeContext.hitBlock(side: Direction) {
+    private fun SafeContext.stepDamage(side: Direction) {
         if (interaction.updateBlockBreakingProgress(blockPos, side)) {
             if (player.isCreative) interaction.blockBreakingCooldown = 0
-            if (swingHand) player.swingHand(ctx.hand)
         }
     }
+
+    private fun SafeContext.startBreakPacket(pos: BlockPos, direction: Direction) =
+        breakPacket(pos, direction, Action.START_DESTROY_BLOCK)
+
+    private fun SafeContext.stopBreakPacket(pos: BlockPos, direction: Direction) =
+        breakPacket(pos, direction, Action.STOP_DESTROY_BLOCK)
+
+    private fun SafeContext.abortBreakPacket(pos: BlockPos, direction: Direction) =
+        breakPacket(pos, direction, Action.ABORT_DESTROY_BLOCK)
+
+    private fun SafeContext.breakPacket(pos: BlockPos, direction: Direction, action: Action) =
+        connection.sendPacket(
+            PlayerActionC2SPacket(
+                action,
+                pos,
+                direction
+            )
+        )
+
+    enum class SwingHandStyle {
+        Constant,
+        StartAndEnd,
+        Start,
+        End
+    }
 }