rebreak logic

Author: beanbag44

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

@@ -17,7 +17,9 @@
 
 package com.lambda.module.modules.player
 
+import com.lambda.context.SafeContext
 import com.lambda.event.events.PlayerEvent
+import com.lambda.event.events.TickEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.interaction.RotationManager
 import com.lambda.interaction.construction.context.BreakContext
@@ -34,6 +36,7 @@ import com.lambda.util.BlockUtils.instantBreakable
 import com.lambda.util.math.VecUtils.vec3d
 import net.minecraft.block.BlockState
 import net.minecraft.item.Item
+import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket
 import net.minecraft.util.Hand
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.hit.HitResult
@@ -89,7 +92,7 @@ object PacketMineTaskRewrite : Module(
         "Re-Break Style",
         ReBreak.Standard,
         "Affects the speed and style of re-break"
-    ) { page == Page.Rebreak }
+    ) { page == Page.Rebreak && reBreak }
 
     private val queueBlocks by setting(
         "Queue Blocks",
@@ -105,13 +108,23 @@ object PacketMineTaskRewrite : Module(
         get() = breakTasks[1]
         set(value) { breakTasks[1] = value }
 
+    private var reBreaking: PacketBreakInfo? = null
+
     private val blockQueue = ArrayDeque<BlockPos>()
 
     init {
         listen<PlayerEvent.Attack.Block> { event ->
             event.cancel()
 
             val pos = event.pos
+
+            reBreaking?.let { ctx ->
+                if (pos == ctx.pos) {
+                    reBreakBlock(ctx, event.side)
+                    return@listen
+                }
+            }
+
             if (breakTasks.any { it?.pos == pos }) return@listen
 
             val blockState = pos.blockState(world)
@@ -136,8 +149,7 @@ object PacketMineTaskRewrite : Module(
                     blockState,
                     pos,
                     bestTool?.select()?.itemStack ?: player.mainHandStack
-                ),
-                BreakType.Primary
+                )
             ).run()
         }
 
@@ -146,26 +158,58 @@ object PacketMineTaskRewrite : Module(
                 event.cancel()
         }
 
+        listen<TickEvent.Pre> {
+            if (reBreakStyle == ReBreak.Standard) return@listen
+
+            reBreaking?.let { ctx ->
+                if (reBreakStyle == ReBreak.FastAutomatic) {
+                    reBreakBlock(ctx, ctx.getSide())
+                    return@listen
+                }
+
+                val pos = ctx.pos
+                val hardness = pos.blockState(world).getHardness(world, pos)
+                if (hardness == -1.0f || hardness == 600.0f) return@listen
+
+                reBreakBlock(ctx, ctx.getSide())
+            }
+        }
+
         onDisable {
             breakTasks.forEach {
                 it?.cancelBreak()
             }
             breakTasks = arrayOfNulls(2)
+            reBreaking = null
             blockQueue.clear()
         }
     }
 
+    private fun SafeContext.reBreakBlock(ctx: PacketBreakInfo, side: Direction) {
+        val pos = ctx.pos
+        interaction.sendSequencedPacket(world) {
+            PlayerActionC2SPacket(
+                PlayerActionC2SPacket.Action.STOP_DESTROY_BLOCK,
+                pos,
+                side
+            )
+        }
+        if (!breakConfirmation) {
+            interaction.breakBlock(pos)
+        }
+    }
+
     private class PacketBreakInfo(
         val pos: BlockPos,
-        val blockState: BlockState,
-        val hand: Hand,
-        val side: Direction,
+        blockState: BlockState,
+        hand: Hand,
+        side: Direction,
         bestTool: Item?,
         instantBreak: Boolean,
-        var breakType: BreakType
     ) {
         private val breakContext: BreakContext
         private val packetBreakTask: PacketBreakBlock
+        var breakType = BreakType.Primary
 
         init {
             val vec3dPos = pos.vec3d
@@ -188,10 +232,15 @@ object PacketMineTaskRewrite : Module(
                 obeyInteractionDelays = interactionDelay
             ).finally {
                 breakTasks[breakType.index] = null
+                if (breakType == BreakType.Primary) {
+                    if (!reBreak) return@finally
+                    reBreaking = this@PacketBreakInfo
+                }
             } as PacketBreakBlock
         }
 
         fun run(): PacketBreakInfo {
+            reBreaking = null
             packetBreakTask.run()
             return this
         }
@@ -201,6 +250,8 @@ object PacketMineTaskRewrite : Module(
             breakType = BreakType.Secondary
         }
 
+        fun getSide() = packetBreakTask.getSide()
+
         fun cancelBreak() = packetBreakTask.cancel()
     }
 

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

@@ -235,8 +235,8 @@ class PacketBreakBlock @Ta5kBuilder constructor(
      */
     private fun SafeContext.updateBlockBreakingProgress(): Boolean {
         if (obeyInteractionDelays && interaction.blockBreakingCooldown > 0) {
-            interaction.blockBreakingCooldown--;
-            return true;
+            interaction.blockBreakingCooldown--
+            return true
         }
 
         if (interaction.currentGameMode.isCreative && world.worldBorder.contains(blockPos)) {
@@ -424,6 +424,8 @@ class PacketBreakBlock @Ta5kBuilder constructor(
         breakThreshold = 1.0f
     }
 
+    fun getSide() = side
+
     enum class SwingHandStyle {
         Constant,
         StartAndEnd,