Feature: PacketMine

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

@@ -11,6 +11,8 @@
 import net.minecraft.util.ActionResult;
 import net.minecraft.util.Hand;
 import net.minecraft.util.hit.BlockHitResult;
+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;
@@ -26,6 +28,9 @@ public class ClientPlayInteractionManagerMixin {
     @Shadow
     private MinecraftClient client;
 
+    @Shadow
+    public float currentBreakingProgress;
+
     @Inject(method = "interactBlock", at = @At("HEAD"))
     public void interactBlockHead(final ClientPlayerEntity player, final Hand hand, final BlockHitResult hitResult, final CallbackInfoReturnable<ActionResult> cir) {
         if (client.world == null) return;
@@ -41,4 +46,27 @@ void onAttackPre(PlayerEntity player, Entity target, CallbackInfo ci) {
     void onAttackPost(PlayerEntity player, Entity target, CallbackInfo ci) {
         EventFlow.post(new AttackEvent.Post(target));
     }
+
+    @Inject(method = "attackBlock", at = @At("HEAD"), cancellable = true)
+    public void onAttackBlock(BlockPos pos, Direction side, CallbackInfoReturnable<Boolean> cir) {
+        if (EventFlow.post(new InteractionEvent.BlockAttack.Pre(pos, side)).isCanceled()) cir.cancel();
+    }
+
+    @Inject(method = "attackBlock", at = @At("TAIL"))
+    public void onAttackBlockPost(BlockPos pos, Direction side, CallbackInfoReturnable<Boolean> cir) {
+        EventFlow.post(new InteractionEvent.BlockAttack.Post(pos, side));
+    }
+
+    @Inject(method = "updateBlockBreakingProgress", at = @At("HEAD"), cancellable = true)
+    private void updateBlockBreakingProgressPre(BlockPos pos, Direction side, CallbackInfoReturnable<Boolean> cir) {
+        var event = EventFlow.post(new InteractionEvent.BreakingProgress.Pre(pos, side, currentBreakingProgress));
+        if (event.isCanceled()) cir.cancel();
+
+        currentBreakingProgress = event.getProgress();
+    }
+
+    @Inject(method = "updateBlockBreakingProgress", at = @At("TAIL"))
+    private void updateBlockBreakingProgressPost(BlockPos pos, Direction side, CallbackInfoReturnable<Boolean> cir) {
+        EventFlow.post(new InteractionEvent.BreakingProgress.Post(pos, side, currentBreakingProgress));
+    }
 }

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

@@ -2,13 +2,15 @@
 
 import com.lambda.Lambda;
 import com.lambda.event.EventFlow;
+import com.lambda.event.events.EntityEvent;
 import com.lambda.event.events.MovementEvent;
 import com.lambda.event.events.TickEvent;
 import com.lambda.interaction.PlayerPacketManager;
 import com.lambda.interaction.RotationManager;
 import net.minecraft.client.input.Input;
 import net.minecraft.client.network.ClientPlayerEntity;
 import net.minecraft.entity.MovementType;
+import net.minecraft.util.Hand;
 import net.minecraft.util.math.Vec3d;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -91,4 +93,9 @@ float fixHeldItemYaw(ClientPlayerEntity instance) {
     float fixHeldItemPitch(ClientPlayerEntity instance) {
         return Objects.requireNonNullElse(RotationManager.getHandPitch(), instance.getPitch());
     }
+
+    @Inject(method = "swingHand", at = @At("HEAD"), cancellable = true)
+    void onSwingHandPre(Hand hand, CallbackInfo ci) {
+        if (EventFlow.post(new EntityEvent.SwingHand(hand)).isCanceled()) ci.cancel();
+    }
 }

common/src/main/kotlin/com/lambda/config/groups/RotationSettings.kt

@@ -16,7 +16,7 @@ class RotationSettings(
         vis
     )
 
-    override val keepTicks by c.setting("Keep Rotation", 3, 1..10, 1, "Ticks to keep rotation", " ticks", vis)
+    override val keepTicks by c.setting("Keep Rotation", 3, 0..10, 1, "Ticks to keep rotation", " ticks", vis)
     override val resetTicks by c.setting("Reset Rotation", 3, 1..10, 1, "Ticks before rotation is reset", " ticks", vis)
 
     /**

common/src/main/kotlin/com/lambda/event/events/EntityEvent.kt

@@ -3,10 +3,15 @@ package com.lambda.event.events
 import com.lambda.event.Event
 import com.lambda.event.callback.Cancellable
 import com.lambda.event.callback.ICancellable
+import net.minecraft.util.Hand
 
 abstract class EntityEvent : Event {
     class ChangeLookDirection(
         val deltaYaw: Double,
         val deltaPitch: Double,
     ) : EntityEvent(), ICancellable by Cancellable()
+
+    class SwingHand(
+        val hand: Hand
+    ) : EntityEvent(), ICancellable by Cancellable()
 }

common/src/main/kotlin/com/lambda/event/events/InteractionEvent.kt

@@ -1,12 +1,42 @@
 package com.lambda.event.events
 
 import com.lambda.event.Event
+import com.lambda.event.callback.Cancellable
+import com.lambda.event.callback.ICancellable
 import net.minecraft.client.world.ClientWorld
 import net.minecraft.util.hit.BlockHitResult
+import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Direction
 
 sealed class InteractionEvent : Event {
     class Block(
         val world: ClientWorld,
         val blockHitResult: BlockHitResult
     ) : InteractionEvent()
-}
+
+    sealed class BlockAttack : InteractionEvent() {
+        class Pre(
+            val pos: BlockPos,
+            val side: Direction
+        ) : BlockAttack(), ICancellable by Cancellable()
+
+        class Post(
+            val pos: BlockPos,
+            val side: Direction
+        ) : BlockAttack()
+    }
+
+    sealed class BreakingProgress : InteractionEvent() {
+        class Pre(
+            val pos: BlockPos,
+            val side: Direction,
+            var progress: Float,
+        ) : BreakingProgress(), ICancellable by Cancellable()
+
+        class Post(
+            val pos: BlockPos,
+            val side: Direction,
+            val progress: Float,
+        ) : BreakingProgress()
+    }
+}

common/src/main/kotlin/com/lambda/interaction/RotationManager.kt

@@ -30,7 +30,7 @@ object RotationManager : Loadable {
     var currentRotation = Rotation.ZERO
     var prevRotation = Rotation.ZERO
 
-    private var currentContext: RotationContext? = null
+    var currentContext: RotationContext? = null
 
     private var keepTicks = 0
     private var pauseTicks = 0

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

@@ -0,0 +1,182 @@
+package com.lambda.module.modules.player
+
+import com.lambda.context.SafeContext
+import com.lambda.event.events.*
+import com.lambda.event.listener.SafeListener.Companion.listener
+import com.lambda.graphics.renderer.esp.DynamicAABB
+import com.lambda.graphics.renderer.esp.builders.buildFilled
+import com.lambda.graphics.renderer.esp.builders.buildOutline
+import com.lambda.graphics.renderer.esp.global.DynamicESP
+import com.lambda.module.Module
+import com.lambda.module.tag.ModuleTag
+import com.lambda.util.math.transform
+import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket
+import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket.Action
+import com.lambda.util.math.MathUtils.lerp
+import net.minecraft.util.math.Box
+import java.awt.Color
+
+object FastBreak : Module(
+    name = "FastBreak",
+    description = "Break blocks faster.",
+    defaultTags = setOf(
+        ModuleTag.PLAYER, ModuleTag.WORLD
+    )
+) {
+    private val page by setting("Page", Page.Mining)
+
+    private val breakDelay by setting("Break Delay", 5, 0..5, 1, unit = "ticks", description = "The tick delay between breaking blocks", visibility = { page == Page.Mining })
+    private val breakThreshold by setting("Break Threshold", 0.7f, 0.2f..1.0f, 0.1f, description = "The progress at which the block will break.", visibility = { page == Page.Mining })
+
+    private val renderMode by setting("Render Mode", RenderMode.Out, "The animation style of the renders", visibility = { page == Page.Render })
+    private val renderSetting by setting("Render Setting", RenderSetting.Both, "The different ways to draw the renders", visibility = { page == Page.Render && renderMode.isEnabled() })
+
+    private val fillColourMode by setting("Fill Mode", ColourMode.Dynamic, visibility = { page == Page.Render && renderSetting != RenderSetting.Outline })
+    private val staticFillColour by setting("Static Fill Colour", Color(1f, 0f, 0f, 0.3f), "The colour used to render the static fill of the box", visibility = { page == Page.Render && renderMode.isEnabled() && renderSetting != RenderSetting.Outline && fillColourMode == ColourMode.Static })
+    private val startFillColour by setting("Start Fill Colour", Color(1f, 0f, 0f, 0.3f), "The colour used to render the start fill of the box", visibility = { page == Page.Render && renderMode.isEnabled() && renderSetting != RenderSetting.Outline && fillColourMode == ColourMode.Dynamic })
+    private val endFillColour by setting("End Fill Colour", Color(0f, 1f, 0f, 0.3f), "The colour used to render the end fill of the box", visibility = { page == Page.Render && renderMode.isEnabled() && renderSetting != RenderSetting.Outline && fillColourMode == ColourMode.Dynamic  })
+
+    private val outlineColourMode by setting("Outline Mode", ColourMode.Dynamic, visibility = { page == Page.Render && renderSetting != RenderSetting.Fill })
+    private val staticOutlineColour by setting("Static Outline Colour", Color(1f, 0f, 0f, 0.3f), "The colour used to render the static outline of the box", visibility = { page == Page.Render && renderMode.isEnabled() && renderSetting != RenderSetting.Fill && outlineColourMode == ColourMode.Static })
+    private val startOutlineColour by setting("Start Outline Colour", Color(1f, 0f, 0f, 0.3f), "The colour used to render the start outline of the box", visibility = { page == Page.Render && renderMode.isEnabled() && renderSetting != RenderSetting.Fill && outlineColourMode == ColourMode.Dynamic })
+    private val endOutlineColour by setting("End Outline Colour", Color(0f, 1f, 0f, 0.3f), "The colour used to render the end outline of the box", visibility = { page == Page.Render && renderMode.isEnabled() && renderSetting != RenderSetting.Fill && outlineColourMode == ColourMode.Dynamic  })
+    private val outlineWidth by setting("Outline Width", 1f, 0f..3f, 0.1f, "the thickness of the outline", visibility = { page == Page.Render && renderMode.isEnabled() && renderSetting != RenderSetting.Fill })
+
+
+    private val renderer = DynamicESP
+    private var boxSet = emptySet<Box>()
+
+    private enum class Page {
+        Mining, Render
+    }
+
+    private enum class RenderMode {
+        Out, In, InOut, OutIn, Static, None;
+
+        fun isEnabled(): Boolean =
+            this != None
+    }
+
+    private enum class ColourMode {
+        Static, Dynamic
+    }
+
+    private enum class RenderSetting {
+        Both, Fill, Outline
+    }
+
+    init {
+        listener<PacketEvent.Send.Pre> {
+            if (it.packet !is PlayerActionC2SPacket
+                || it.packet.action != Action.STOP_DESTROY_BLOCK
+            ) return@listener
+
+            connection.sendPacket(
+                PlayerActionC2SPacket(
+                    Action.ABORT_DESTROY_BLOCK,
+                    // For the exploit to work, the position must be outside the player range, so any
+                    // position farther than 6 blocks will work.
+                    // This is only required for grim 2 and potentially grim 3 in the future if they update it
+                    it.packet.pos.up(2024 - 4 - 18),
+                    it.packet.direction
+                )
+            )
+        }
+
+        listener<TickEvent.Pre> {
+            interaction.blockBreakingCooldown = interaction.blockBreakingCooldown.coerceAtMost(breakDelay)
+        }
+
+        listener<InteractionEvent.BreakingProgress.Pre> {
+            it.progress += world.getBlockState(it.pos)
+                .calcBlockBreakingDelta(player, world, it.pos) * (1 - breakThreshold)
+        }
+
+        listener<TickEvent.Post> {
+            if (!renderMode.isEnabled()) return@listener
+
+            val pos = interaction.currentBreakingPos
+            boxSet = world.getBlockState(pos).getOutlineShape(world, pos).boundingBoxes.toSet()
+        }
+
+        listener<RenderEvent.World> {
+            if (!interaction.isBreakingBlock || !renderMode.isEnabled()) return@listener
+
+            val pos = interaction.currentBreakingPos
+            val breakDelta = world.getBlockState(pos).calcBlockBreakingDelta(player, world, pos)
+
+            renderer.clear()
+            boxSet.forEach { box ->
+                val previousFactor = interaction.currentBreakingProgress - breakDelta
+                val nextFactor = interaction.currentBreakingProgress
+                val currentFactor = lerp(previousFactor, nextFactor, mc.tickDelta)
+
+                val fillColour = if (fillColourMode == ColourMode.Dynamic) {
+                    lerp(startFillColour, endFillColour, currentFactor.toDouble())
+                } else {
+                    staticFillColour
+                }
+
+                val outlineColour = if (outlineColourMode == ColourMode.Dynamic) {
+                    lerp(startOutlineColour, endOutlineColour, currentFactor.toDouble())
+                } else {
+                    staticOutlineColour
+                }
+
+                val renderBox = if (renderMode != RenderMode.Static) {
+                    getLerpBox(box, currentFactor).offset(pos)
+                } else {
+                    box.offset(pos)
+                }
+
+                val dynamicAABB = DynamicAABB()
+                dynamicAABB.update(renderBox)
+
+                if (renderSetting != RenderSetting.Outline) {
+                    renderer.buildFilled(dynamicAABB, fillColour)
+                }
+
+                if (renderSetting != RenderSetting.Fill) {
+                    renderer.buildOutline(dynamicAABB, outlineColour)
+                }
+            }
+            renderer.upload()
+        }
+    }
+
+    private fun getLerpBox(box: Box, factor: Float): Box {
+        val boxCenter = Box(box.center, box.center)
+        when (renderMode) {
+            RenderMode.Out -> {
+                return lerp(boxCenter, box, factor.toDouble())
+            }
+
+            RenderMode.In -> {
+                return lerp(box, boxCenter, factor.toDouble())
+            }
+
+            RenderMode.InOut -> {
+                return if (factor >= 0.5f) {
+                    lerp(boxCenter, box, (factor.toDouble() - 0.5) * 2)
+                } else {
+                    lerp(box, boxCenter, factor.toDouble() * 2)
+                }
+            }
+
+            RenderMode.OutIn -> {
+                return if (factor >= 0.5f) {
+                    lerp(box, boxCenter, (factor.toDouble() - 0.5) * 2)
+                } else {
+                    lerp(boxCenter, box, factor.toDouble() * 2)
+                }
+            }
+
+            else -> {
+                return box
+            }
+        }
+    }
+
+    fun SafeContext.interpolateProgress(min: Double = 0.0, max: Double = 1.0) =
+        transform(interaction.currentBreakingProgress.toDouble(), 0.0, 1.0, min, max)
+}

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

@@ -8,8 +8,6 @@ object Interact : Module(
     description = "Modify players interaction with the world",
     defaultTags = setOf(ModuleTag.PLAYER)
 ) {
-    // ToDo: Is this fast place / fast use? Should it be relocated with more options?
     @JvmStatic val placeDelay by setting("Item Use / Place Delay", 4, 0..20, 1, "Sets the delay between placing blocks or using items")
-//    @JvmStatic val breakDelay by setting("Attack / Break Delay", 10, 0..20, 1)
     @JvmStatic val multiAction by setting("Multi Action", false, "Allows to use many items while breaking blocks")
 }