semi working

Author: beanbag44

common/src/main/java/com/lambda/mixin/entity/ClientPlayInteractionManagerMixin.java

@@ -19,7 +19,6 @@
 
 import com.lambda.event.EventFlow;
 import com.lambda.event.events.PlayerEvent;
-import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.network.ClientPlayerEntity;
 import net.minecraft.client.network.ClientPlayerInteractionManager;
 import net.minecraft.entity.Entity;
@@ -31,7 +30,6 @@
 import net.minecraft.util.hit.EntityHitResult;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Direction;
-import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;

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

@@ -33,6 +33,7 @@ import com.lambda.util.BlockUtils.blockState
 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.util.Hand
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.hit.HitResult
@@ -61,6 +62,14 @@ object PacketMineTaskRewrite : Module(
         false,
         "Allows usage of tools within the players inventory"
     ) { page == Page.General }
+    private val interactionDelay by setting(
+        "Interact Delay",
+        0,
+        0..10,
+        1,
+        "The delay between interacting with blocks",
+        "ticks"
+    ) { page == Page.General }
 
     private val reBreak by setting(
         "Re-Break",
@@ -90,14 +99,12 @@ object PacketMineTaskRewrite : Module(
     private val blockQueue = ArrayDeque<BlockPos>()
 
     init {
-        listen<PlayerEvent.Attack.Block> { event ->
+        listen<PlayerEvent.Attack.Block>(1) { event ->
             event.cancel()
 
             val pos = event.pos
             val blockState = pos.blockState(world)
-            val bestTool =
-                findBestAvailableTool(blockState)?.select()?.itemStack
-                    ?: player.mainHandStack
+            val bestTool = findBestAvailableTool(blockState)
 
             if (doubleBreak && secondaryBreakTask == null) {
                 secondaryBreakTask = primaryBreakTask
@@ -110,7 +117,12 @@ object PacketMineTaskRewrite : Module(
                 blockState,
                 player.activeHand,
                 event.side,
-                instantBreakable(blockState, pos, bestTool)
+                bestTool,
+                instantBreakable(
+                    blockState,
+                    pos,
+                    bestTool?.select()?.itemStack ?: player.mainHandStack
+                )
             ).run()
         }
 
@@ -128,6 +140,7 @@ object PacketMineTaskRewrite : Module(
         val blockState: BlockState,
         val hand: Hand,
         val side: Direction,
+        bestTool: Item?,
         instantBreak: Boolean
     ) {
         private val breakContext: BreakContext
@@ -147,13 +160,13 @@ object PacketMineTaskRewrite : Module(
             )
             packetBreakTask = PacketBreakBlock(
                 breakContext,
+                bestTool,
                 false,
-                TaskFlowModule.rotation,
-                TaskFlowModule.interact,
-                validateBreak,
-                Direction.entries.toSet(),
-                TaskFlowModule.build.rotateForBreak,
                 PacketBreakBlock.SwingHandStyle.Start,
+                breakingTexture = true,
+                breakingSound = true,
+                breakingParticles = true,
+                collectDrop = false
             )
         }
 

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

@@ -26,32 +26,44 @@ import com.lambda.event.events.WorldEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.interaction.RotationManager.rotate
 import com.lambda.interaction.construction.context.BreakContext
+import com.lambda.interaction.material.StackSelection.Companion.select
 import com.lambda.interaction.visibilty.VisibilityChecker.lookAtBlock
 import com.lambda.module.modules.client.TaskFlowModule
 import com.lambda.task.Task
 import com.lambda.util.BaritoneUtils
 import com.lambda.util.BlockUtils.blockState
+import com.lambda.util.BlockUtils.calcItemBlockBreakingDelta
 import com.lambda.util.extension.inventorySlots
+import com.lambda.util.item.ItemStackUtils.equal
 import com.lambda.util.item.ItemUtils.block
 import com.lambda.util.player.SlotUtils.clickSlot
 import com.lambda.util.player.SlotUtils.hotbarAndStorage
 import net.minecraft.block.BlockState
+import net.minecraft.client.sound.PositionedSoundInstance
+import net.minecraft.client.sound.SoundInstance
 import net.minecraft.entity.ItemEntity
+import net.minecraft.item.Item
+import net.minecraft.item.ItemStack
 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.sound.SoundCategory
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
 
 class PacketBreakBlock @Ta5kBuilder constructor(
     private val ctx: BreakContext,
+    private var tool: Item?,
+    private val validateBreak: Boolean = true,
+    private val swingHand: SwingHandStyle = SwingHandStyle.Start,
+    private val breakingTexture: Boolean = true,
+    private val breakingSound: Boolean = true,
+    private val breakingParticles: Boolean = true,
     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: SwingHandStyle = SwingHandStyle.Start,
 ) : Task<ItemEntity?>() {
     override val name get() = "Packet breaking ${ctx.result.blockPos.toShortString()}"
 
@@ -65,7 +77,11 @@ class PacketBreakBlock @Ta5kBuilder constructor(
     private var state = State.BREAKING
     private var isValid = false
 
-    private var breakAmount = 0f
+    private var previousToolStack: ItemStack? = null
+    private var toolStack: ItemStack? = null
+    private var toolSlot: Int = -1
+
+    private var pendingConfirmation = false
 
     enum class State {
         BREAKING, COLLECTING
@@ -80,8 +96,9 @@ class PacketBreakBlock @Ta5kBuilder constructor(
         beginState = blockState
 
         if (!rotate || ctx.instantBreak) {
+            updateToolInformation()
             stepDamage(ctx.result.side)
-            if (swingHand != SwingHandStyle.End) player.swingHand(ctx.hand)
+            if (swingHand != SwingHandStyle.End && swingHand.notNone()) swing()
         }
     }
 
@@ -120,7 +137,27 @@ class PacketBreakBlock @Ta5kBuilder constructor(
             } ?: BaritoneUtils.cancel()
 
             if (isValid || !rotate || ctx.instantBreak) {
+                updateToolInformation()
+                if (!toolStack.equal(previousToolStack)) {
+                    val currentBlockState = blockState
+                    val currentBreakDelta = currentBlockState.calcItemBlockBreakingDelta(
+                        player, world, ctx.expectedPos, toolStack!!
+                    )
+                    val previousBreakDelta = currentBlockState.calcItemBlockBreakingDelta(
+                        player, world, ctx.expectedPos, toolStack!!
+                    )
+                    val multiplier = previousBreakDelta / currentBreakDelta
+                    interaction.currentBreakingProgress *= multiplier
+                }
                 stepDamage(ctx.result.side)
+                if ((
+                            swingHand != SwingHandStyle.Start && swingHand.notNone()
+                            && interaction.blockBreakingProgress >= 1.0f
+                        )
+                    || swingHand == SwingHandStyle.Constant
+                    ) {
+                    swing()
+                }
             }
 
             if (done()) {
@@ -145,14 +182,145 @@ class PacketBreakBlock @Ta5kBuilder constructor(
     }
 
     private fun SafeContext.done() =
-        !collectDrop && (blockState.isAir || (!validateBreak && breakAmount >= 1.0f))
+        !collectDrop && blockState.isAir
+
+    private fun SafeContext.stepDamage(side: Direction) =
+        updateBlockBreakingProgress(blockPos, side)
+
+    /**
+     * modified version of the vanilla method to change some behaviours like removing the block breaking cooldown
+     * and allow for validating the break by waiting for the server to respond
+     */
+    private fun SafeContext.updateBlockBreakingProgress(pos: BlockPos, side: Direction): Boolean {
+        if (interaction.currentGameMode.isCreative && world.worldBorder.contains(pos)) {
+            interaction.sendSequencedPacket(world) { sequence: Int ->
+                interaction.breakBlock(pos)
+                PlayerActionC2SPacket(Action.START_DESTROY_BLOCK, pos, side, sequence)
+            }
+            return true
+        }
+
+        if (!interaction.isCurrentlyBreaking(pos)) return attackBlock(pos, side)
+
+        val blockState: BlockState = world.getBlockState(pos)
+        if (blockState.isAir) {
+            interaction.breakingBlock = false
+            return false
+        }
+
+        interaction.currentBreakingProgress += blockState.calcItemBlockBreakingDelta(
+            player,
+            world,
+            pos,
+            toolStack!!
+        )
+
+        if (breakingSound && interaction.blockBreakingSoundCooldown % 4.0f == 0.0f) {
+            val blockSoundGroup = blockState.soundGroup
+            mc
+                .soundManager
+                .play(
+                    PositionedSoundInstance(
+                        blockSoundGroup.hitSound,
+                        SoundCategory.BLOCKS,
+                        (blockSoundGroup.getVolume() + 1.0f) / 8.0f,
+                        blockSoundGroup.getPitch() * 0.5f,
+                        SoundInstance.createRandom(),
+                        pos
+                    )
+                )
+        }
+
+        interaction.blockBreakingSoundCooldown++
+        if (interaction.currentBreakingProgress >= 1.0f) {
+            interaction.breakingBlock = false
+            interaction.sendSequencedPacket(world) { sequence: Int ->
+                interaction.breakBlock(pos)
+                PlayerActionC2SPacket(Action.STOP_DESTROY_BLOCK, pos, side, sequence)
+            }
+            interaction.blockBreakingSoundCooldown = 0.0f
+        }
 
-    private fun SafeContext.stepDamage(side: Direction) {
-        if (interaction.updateBlockBreakingProgress(blockPos, side)) {
-            if (player.isCreative) interaction.blockBreakingCooldown = 0
+        if (breakingTexture) {
+            world.setBlockBreakingInfo(
+                player.id,
+                interaction.currentBreakingPos,
+                interaction.blockBreakingProgress
+            )
         }
+
+        return true
     }
 
+    /**
+     * modified version of the vanilla method
+     */
+    private fun SafeContext.attackBlock(pos: BlockPos, side: Direction): Boolean {
+        if (player.isBlockBreakingRestricted(world, pos, interaction.currentGameMode)) return false
+        if (!world.worldBorder.contains(pos)) return false
+
+        if (interaction.currentGameMode.isCreative) {
+            interaction.sendSequencedPacket(world) { sequence: Int ->
+                interaction.breakBlock(pos)
+                PlayerActionC2SPacket(Action.START_DESTROY_BLOCK, pos, side, sequence)
+            }
+        } else if (!interaction.breakingBlock || !interaction.isCurrentlyBreaking(pos)) {
+            if (interaction.breakingBlock) {
+                connection.sendPacket(
+                    PlayerActionC2SPacket(
+                        Action.ABORT_DESTROY_BLOCK,
+                        interaction.currentBreakingPos, side
+                    )
+                )
+            }
+
+            val blockState: BlockState = world.getBlockState(pos)
+            interaction.sendSequencedPacket(world) { sequence: Int ->
+                val notAir = !blockState.isAir
+                if (notAir && interaction.currentBreakingProgress == 0.0f) {
+                    blockState.onBlockBreakStart(world, pos, player)
+                }
+
+                if (notAir && blockState.calcItemBlockBreakingDelta(player, world, pos, getToolItemStack()) >= 1.0f) {
+                    interaction.breakBlock(pos)
+                } else {
+                    interaction.apply {
+                        breakingBlock = true
+                        currentBreakingPos = pos
+                        selectedStack = toolStack
+                        currentBreakingProgress = 0.0f
+                        blockBreakingSoundCooldown = 0.0f
+                        if (breakingTexture) {
+                            world.setBlockBreakingInfo(
+                                player.id,
+                                currentBreakingPos,
+                                blockBreakingProgress
+                            )
+                        }
+                    }
+                }
+                PlayerActionC2SPacket(Action.START_DESTROY_BLOCK, pos, side, sequence)
+            }
+        }
+
+        return true
+    }
+
+    private fun SafeContext.updateToolInformation() {
+        previousToolStack = toolStack
+        toolStack = tool?.select()?.itemStack ?: player.mainHandStack
+        if (previousToolStack == null) {
+            previousToolStack = toolStack
+        }
+        toolSlot = player.inventory.getSlotWithStack(toolStack)
+    }
+
+    private fun SafeContext.swing() =
+        player.swingHand(player.activeHand)
+
+    private fun SafeContext.getToolItemStack(): ItemStack =
+        tool?.select()?.itemStack ?: player.mainHandStack
+
     private fun SafeContext.startBreakPacket(pos: BlockPos, direction: Direction) =
         breakPacket(pos, direction, Action.START_DESTROY_BLOCK)
 
@@ -175,6 +343,9 @@ class PacketBreakBlock @Ta5kBuilder constructor(
         Constant,
         StartAndEnd,
         Start,
-        End
+        End,
+        None;
+
+        fun notNone() = this != None
     }
 }

common/src/main/resources/lambda.accesswidener

@@ -16,6 +16,11 @@ accessible field net/minecraft/client/world/ClientChunkManager$ClientChunkMap ch
 accessible field net/minecraft/client/network/ClientPlayerInteractionManager currentBreakingProgress F
 accessible field net/minecraft/client/network/ClientPlayerInteractionManager blockBreakingCooldown I
 accessible field net/minecraft/client/network/ClientPlayerInteractionManager currentBreakingPos Lnet/minecraft/util/math/BlockPos;
+accessible method net/minecraft/client/network/ClientPlayerInteractionManager sendSequencedPacket (Lnet/minecraft/client/world/ClientWorld;Lnet/minecraft/client/network/SequencedPacketCreator;)V
+accessible method net/minecraft/client/network/ClientPlayerInteractionManager isCurrentlyBreaking (Lnet/minecraft/util/math/BlockPos;)Z
+accessible field net/minecraft/client/network/ClientPlayerInteractionManager blockBreakingSoundCooldown F
+accessible field net/minecraft/client/network/ClientPlayerInteractionManager breakingBlock Z
+accessible field net/minecraft/client/network/ClientPlayerInteractionManager selectedStack Lnet/minecraft/item/ItemStack;
 
 # Entity
 accessible field net/minecraft/entity/projectile/FireworkRocketEntity shooter Lnet/minecraft/entity/LivingEntity;