double break logic

Author: beanbag44

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

@@ -117,10 +117,13 @@ object PacketMineTaskRewrite : Module(
             val blockState = pos.blockState(world)
             val bestTool = findBestAvailableTool(blockState)
 
-            if (doubleBreak && secondaryBreakTask == null) {
-                secondaryBreakTask = primaryBreakTask
-            } else {
-                primaryBreakTask?.cancelBreak()
+            primaryBreakTask?.let { currentPrimary ->
+                if (doubleBreak && secondaryBreakTask == null) {
+                    currentPrimary.transformToSecondaryBreak()
+                    secondaryBreakTask = currentPrimary
+                } else {
+                    primaryBreakTask?.cancelBreak()
+                }
             }
 
             primaryBreakTask = PacketBreakInfo(
@@ -159,7 +162,7 @@ object PacketMineTaskRewrite : Module(
         val side: Direction,
         bestTool: Item?,
         instantBreak: Boolean,
-        breakType: BreakType
+        var breakType: BreakType
     ) {
         private val breakContext: BreakContext
         private val packetBreakTask: PacketBreakBlock
@@ -177,11 +180,12 @@ object PacketMineTaskRewrite : Module(
                 instantBreak
             )
             packetBreakTask = PacketBreakBlock(
-                breakContext,
-                bestTool,
-                breakThreshold,
-                breakConfirmation,
-                swingHand
+                ctx = breakContext,
+                tool = bestTool,
+                breakThreshold = breakThreshold,
+                internalBreakConfirmation = breakConfirmation,
+                swingHand = swingHand,
+                obeyInteractionDelays = interactionDelay
             ).finally {
                 breakTasks[breakType.index] = null
             } as PacketBreakBlock
@@ -192,9 +196,12 @@ object PacketMineTaskRewrite : Module(
             return this
         }
 
-        fun cancelBreak() {
-            packetBreakTask.cancel()
+        fun transformToSecondaryBreak() {
+            packetBreakTask.transformToSecondaryBreak()
+            breakType = BreakType.Secondary
         }
+
+        fun cancelBreak() = packetBreakTask.cancel()
     }
 
     private enum class BreakType(val index: Int) {

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

@@ -55,7 +55,7 @@ import net.minecraft.util.math.Direction
 class PacketBreakBlock @Ta5kBuilder constructor(
     private val ctx: BreakContext,
     private var tool: Item?,
-    private val breakThreshold: Float = TaskFlowModule.build.breakThreshold,
+    private var breakThreshold: Float = TaskFlowModule.build.breakThreshold,
     private val internalBreakConfirmation: Boolean = false,
     private val swingHand: SwingHandStyle = SwingHandStyle.StartAndEnd,
     private val breakingTexture: Boolean = true,
@@ -217,6 +217,12 @@ class PacketBreakBlock @Ta5kBuilder constructor(
         }
     }
 
+    override fun SafeContext.onCancel() {
+        connection.sendPacket(PlayerActionC2SPacket(Action.ABORT_DESTROY_BLOCK, blockPos, side))
+        setBreakingTextureStage(-1)
+        player.resetLastAttackedTicks()
+    }
+
     private fun SafeContext.done() =
         !collectDrop && blockState.isAir
 
@@ -329,7 +335,7 @@ class PacketBreakBlock @Ta5kBuilder constructor(
 
         if (notAir && blockState.calcItemBlockBreakingDelta(player, world, blockPos, getToolItemStack()) >= breakThreshold) {
             onBlockBreak()
-            startBreakPacket(blockPos, side, sequence)
+            startBreakPacket(sequence)
             return true
         } else {
             startedBreaking = true
@@ -341,10 +347,10 @@ class PacketBreakBlock @Ta5kBuilder constructor(
         if (breakingTexture) {
             setBreakingTextureStage()
         }
-        abortBreakPacket(blockPos, side, sequence)
-        stopBreakPacket(blockPos, side, sequence + 1)
-        startBreakPacket(blockPos, side, sequence + 2)
-        stopBreakPacket(blockPos, side, sequence + 3)
+        abortBreakPacket(sequence)
+        stopBreakPacket(sequence + 1)
+        startBreakPacket(sequence + 2)
+        stopBreakPacket(sequence + 3)
         (0..3).forEach { i ->
             pendingUpdateManager.incrementSequence()
         }
@@ -395,25 +401,29 @@ class PacketBreakBlock @Ta5kBuilder constructor(
     private fun SafeContext.getToolItemStack(): ItemStack =
         tool?.select()?.itemStack ?: player.mainHandStack
 
-    private fun SafeContext.startBreakPacket(pos: BlockPos, direction: Direction, sequence: Int) =
-        breakPacket(pos, direction, Action.START_DESTROY_BLOCK, sequence)
+    private fun SafeContext.startBreakPacket(sequence: Int) =
+        breakPacket(Action.START_DESTROY_BLOCK, sequence)
 
-    private fun SafeContext.stopBreakPacket(pos: BlockPos, direction: Direction, sequence: Int) =
-        breakPacket(pos, direction, Action.STOP_DESTROY_BLOCK, sequence)
+    private fun SafeContext.stopBreakPacket(sequence: Int) =
+        breakPacket(Action.STOP_DESTROY_BLOCK, sequence)
 
-    private fun SafeContext.abortBreakPacket(pos: BlockPos, direction: Direction, sequence: Int) =
-        breakPacket(pos, direction, Action.ABORT_DESTROY_BLOCK, sequence)
+    private fun SafeContext.abortBreakPacket(sequence: Int) =
+        breakPacket(Action.ABORT_DESTROY_BLOCK, sequence)
 
-    private fun SafeContext.breakPacket(pos: BlockPos, direction: Direction, action: Action, sequence: Int) =
+    private fun SafeContext.breakPacket(action: Action, sequence: Int) =
         connection.sendPacket(
             PlayerActionC2SPacket(
                 action,
-                pos,
-                direction,
+                blockPos,
+                side,
                 sequence
             )
         )
 
+    fun transformToSecondaryBreak() {
+        breakThreshold = 1.0f
+    }
+
     enum class SwingHandStyle {
         Constant,
         StartAndEnd,