use break manager for fast break

beanbag44 · beanbag44 · commit a0cca20be2dc · 2025-07-27T20:21:56.000+01:00
diff --git a/common/src/main/kotlin/com/lambda/config/groups/BreakSettings.kt b/common/src/main/kotlin/com/lambda/config/groups/BreakSettings.kt
@@ -36,9 +36,9 @@ class BreakSettings(
     override val breakMode by c.setting("Break Mode", BreakMode.Packet) { vis() && page == Page.General }
     override val sorter by c.setting("Sorter", SortMode.Closest, "The order in which breaks are performed") { vis() && page == Page.General }
     override val reBreak by c.setting("ReBreak", true, "Re-breaks blocks after they've been broken once") { vis() && page == Page.General }
-    override val unsafeCancels by c.setting("Unsafe Cancels", true, "Allows cancelling block breaking even if the server might continue breaking sever side, potentially causing unexpected state changes") { vis() && page == Page.General }
     override val breakThreshold by c.setting("Break Threshold", 0.70f, 0.1f..1.0f, 0.01f, "The break amount at which the block is considered broken") { vis() && page == Page.General }
     override val doubleBreak by c.setting("Double Break", true, "Allows breaking two blocks at once") { vis() && page == Page.General }
+    override val unsafeCancels by c.setting("Unsafe Cancels", true, "Allows cancelling block breaking even if the server might continue breaking sever side, potentially causing unexpected state changes") { vis() && page == Page.General }
     override val fudgeFactor by c.setting("Fudge Factor", 1, 0..5, 1, "The amount of ticks to give double, aka secondary breaks extra for the server to recognise the break") { vis() && page == Page.General }
 //    override val desyncFix by c.setting("Desync Fix", false, "Predicts if the players breaking will be slowed next tick as block break packets are processed using the players next position") { vis() && page == Page.General }
     override val breakDelay by c.setting("Break Delay", 0, 0..6, 1, "The delay between breaking blocks", " ticks") { vis() && page == Page.General }
diff --git a/common/src/main/kotlin/com/lambda/interaction/construction/context/BreakContext.kt b/common/src/main/kotlin/com/lambda/interaction/construction/context/BreakContext.kt
@@ -25,7 +25,6 @@ import com.lambda.interaction.request.breaking.BreakRequest
 import com.lambda.interaction.request.hotbar.HotbarManager
 import com.lambda.interaction.request.hotbar.HotbarRequest
 import com.lambda.interaction.request.rotating.RotationRequest
-import com.lambda.module.modules.client.TaskFlowModule
 import com.lambda.util.BlockUtils.emptyState
 import net.minecraft.block.BlockState
 import net.minecraft.block.FallingBlock
@@ -38,9 +37,9 @@ data class BreakContext(
     override val result: BlockHitResult,
     override val rotation: RotationRequest,
     override var hotbarIndex: Int,
-    override var cachedState: BlockState,
     var instantBreak: Boolean,
-    val sortMode: BreakConfig.SortMode = TaskFlowModule.build.breaking.sorter
+    override var cachedState: BlockState,
+    val sortMode: BreakConfig.SortMode
 ) : BuildContext() {
     private val baseColor = Color(222, 0, 0, 25)
     private val sideColor = Color(222, 0, 0, 100)
diff --git a/common/src/main/kotlin/com/lambda/interaction/construction/simulation/BuildSimulator.kt b/common/src/main/kotlin/com/lambda/interaction/construction/simulation/BuildSimulator.kt
@@ -697,8 +697,8 @@ object BuildSimulator {
                     blockHit,
                     rotationRequest,
                     player.inventory.selectedSlot,
-                    state,
                     instantBreakable(state, pos, breaking.breakThreshold),
+                    state,
                     breaking.sorter
                 )
                 acc.add(BreakResult.Break(pos, breakContext))
@@ -746,7 +746,7 @@ object BuildSimulator {
         val rotationRequest = RotationRequest(target, rotation)
         val instant = instantBreakable(state, pos, breaking.breakThreshold)
 
-        val breakContext = BreakContext(blockHit, rotationRequest, player.inventory.selectedSlot, state, instant)
+        val breakContext = BreakContext(blockHit, rotationRequest, player.inventory.selectedSlot, instant, state, breaking.sorter)
 
         if (gamemode.isCreative) {
             acc.add(BreakResult.Break(pos, breakContext))
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakConfig.kt b/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakConfig.kt
@@ -27,9 +27,9 @@ interface BreakConfig : RequestConfig {
     val breakMode: BreakMode
     val sorter: SortMode
     val reBreak: Boolean
-    val unsafeCancels: Boolean
     val breakThreshold: Float
     val doubleBreak: Boolean
+    val unsafeCancels: Boolean
     val fudgeFactor: Int
     //ToDo: Needs a more advanced player simulation implementation to predict the next ticks onGround / submerged status
 //    abstract val desyncFix: Boolean
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakManager.kt b/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakManager.kt
@@ -351,7 +351,7 @@ object BreakManager : RequestHandler<BreakRequest>(
         // Sanitize the new breaks
         val newBreaks = request.contexts
             .distinctBy { it.blockPos }
-            .filter { ctx -> canAccept(ctx, request.build.breaking) }
+            .filter { ctx -> canAccept(ctx, request.config) }
             .let { acceptable ->
                 acceptable.firstOrNull()?.let { first ->
                     acceptable.filter { it.hotbarIndex == first.hotbarIndex }
@@ -387,7 +387,7 @@ object BreakManager : RequestHandler<BreakRequest>(
             .filter { !it.instantBreak }
             .toMutableList()
 
-        val breakConfig = request.build.breaking
+        val breakConfig = request.config
         val pendingLimit = (breakConfig.maxPendingBreaks - pendingBreakCount).coerceAtLeast(0)
         maxBreaksThisTick = breakConfig.breaksPerTick.coerceAtMost(pendingLimit)
     }
@@ -425,8 +425,8 @@ object BreakManager : RequestHandler<BreakRequest>(
             val ctx = iterator.next()
 
             if (!ctx.requestDependencies(request)) return false
-            rotationRequest = if (request.build.breaking.rotateForBreak) ctx.rotation.submit(false) else null
-            if (!rotated || tickStage !in request.build.breaking.breakStageMask) return false
+            rotationRequest = if (request.config.rotateForBreak) ctx.rotation.submit(false) else null
+            if (!rotated || tickStage !in request.config.breakStageMask) return false
 
             val breakInfo = initNewBreak(ctx, request) ?: return false
             updateBreakProgress(breakInfo)
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakRequest.kt b/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakRequest.kt
@@ -25,6 +25,7 @@ import com.lambda.interaction.request.Request
 import com.lambda.interaction.request.hotbar.HotbarConfig
 import com.lambda.interaction.request.inventory.InventoryConfig
 import com.lambda.interaction.request.rotating.RotationConfig
+import com.lambda.module.modules.client.TaskFlowModule
 import com.lambda.threading.runSafe
 import com.lambda.util.BlockUtils.blockState
 import com.lambda.util.BlockUtils.isEmpty
@@ -34,11 +35,11 @@ import net.minecraft.util.math.BlockPos
 data class BreakRequest(
     val contexts: Collection<BreakContext>,
     val pendingInteractions: MutableCollection<BuildContext>,
-    val build: BuildConfig,
-    val hotbar: HotbarConfig,
-    val rotation: RotationConfig,
-    val inventory: InventoryConfig,
-    val interact: InteractionConfig
+    val build: BuildConfig = TaskFlowModule.build,
+    val hotbar: HotbarConfig = TaskFlowModule.hotbar,
+    val rotation: RotationConfig = TaskFlowModule.rotation,
+    val inventory: InventoryConfig = TaskFlowModule.inventory,
+    val interact: InteractionConfig = TaskFlowModule.interaction
 ) : Request() {
     override val config = build.breaking
     var onStart: ((BlockPos) -> Unit)? = null
@@ -114,11 +115,11 @@ data class BreakRequest(
         fun breakRequest(
             contexts: Collection<BreakContext>,
             pendingInteractions: MutableCollection<BuildContext>,
-            rotation: RotationConfig,
-            hotbar: HotbarConfig,
-            interact: InteractionConfig,
-            inventory: InventoryConfig,
-            build: BuildConfig,
+            rotation: RotationConfig = TaskFlowModule.rotation,
+            hotbar: HotbarConfig = TaskFlowModule.hotbar,
+            interact: InteractionConfig = TaskFlowModule.interaction,
+            inventory: InventoryConfig = TaskFlowModule.inventory,
+            build: BuildConfig = TaskFlowModule.build,
             builder: RequestBuilder.() -> Unit
         ) = RequestBuilder(contexts, pendingInteractions, rotation, hotbar, interact, inventory, build).apply(builder).build()
     }
diff --git a/common/src/main/kotlin/com/lambda/module/modules/player/FastBreak.kt b/common/src/main/kotlin/com/lambda/module/modules/player/FastBreak.kt
@@ -17,20 +17,22 @@
 
 package com.lambda.module.modules.player
 
-import com.lambda.event.events.PacketEvent
+import com.lambda.config.groups.BuildSettings
 import com.lambda.event.events.PlayerEvent
-import com.lambda.event.events.RenderEvent
-import com.lambda.event.events.TickEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
-import com.lambda.graphics.renderer.esp.builders.buildFilled
-import com.lambda.graphics.renderer.esp.builders.buildOutline
+import com.lambda.interaction.construction.context.BreakContext
+import com.lambda.interaction.construction.context.BuildContext
+import com.lambda.interaction.request.breaking.BreakRequest
+import com.lambda.interaction.request.rotating.Rotation.Companion.rotation
+import com.lambda.interaction.request.rotating.RotationRequest
+import com.lambda.interaction.request.rotating.visibilty.lookAt
 import com.lambda.module.Module
+import com.lambda.module.modules.client.TaskFlowModule
 import com.lambda.module.tag.ModuleTag
-import com.lambda.util.math.lerp
-import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket
-import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket.Action
-import net.minecraft.util.math.Box
-import java.awt.Color
+import com.lambda.util.BlockUtils.blockState
+import net.minecraft.util.Hand
+import net.minecraft.util.hit.BlockHitResult
+import java.util.concurrent.ConcurrentLinkedQueue
 
 object FastBreak : Module(
     name = "FastBreak",
@@ -39,100 +41,30 @@ object FastBreak : Module(
         ModuleTag.PLAYER, ModuleTag.WORLD
     )
 ) {
-    private val page by setting("Page", Page.Mining)
+    private val buildConfig = BuildSettings(this)
 
-    private val breakDelay by setting("Break Delay", 5, 0..5, 1, "The tick delay between breaking blocks", unit = " ticks") { page == Page.Mining }
-    private val breakThreshold by setting("Break Threshold", 0.7f, 0.2f..1.0f, 0.1f, "The progress at which the block will break.") { page == Page.Mining }
-
-    private val render by setting("Render", true, "Render block breaking progress")
-    private val renderMode by setting("Render Mode", RenderMode.Out, "The animation style of the renders") { page == Page.Render }
-    private val renderSetting by setting("Render Setting", RenderSetting.Both, "The different ways to draw the renders") { page == Page.Render && render }
-
-    private val fillColourMode by setting("Fill Mode", ColourMode.Dynamic) { 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") { page == Page.Render && render && 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") { page == Page.Render && render && 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") { page == Page.Render && render && renderSetting != RenderSetting.Outline && fillColourMode == ColourMode.Dynamic }
-
-    private val outlineColourMode by setting("Outline Mode", ColourMode.Dynamic) { 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") { page == Page.Render && render && 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") { page == Page.Render && render && 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") { page == Page.Render && render && renderSetting != RenderSetting.Fill && outlineColourMode == ColourMode.Dynamic }
-    private val outlineWidth by setting("Outline Width", 1f, 0f..3f, 0.1f, "the thickness of the outline") { page == Page.Render && render && renderSetting != RenderSetting.Fill }
+    private val pendingInteractions = ConcurrentLinkedQueue<BuildContext>()
 
     init {
-        listen<PacketEvent.Send.Pre> {
-            if (it.packet !is PlayerActionC2SPacket
-                || it.packet.action != Action.STOP_DESTROY_BLOCK
-            ) return@listen
-
-            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
-                )
+        listen<PlayerEvent.Attack.Block> { it.cancel() }
+        listen<PlayerEvent.Breaking.Update> { event ->
+            event.cancel()
+            player.swingHand(Hand.MAIN_HAND)
+
+            val hitResult = mc.crosshairTarget as? BlockHitResult ?: return@listen
+            val pos = event.pos
+            val state = blockState(pos)
+
+            val breakContext = BreakContext(
+                hitResult,
+                RotationRequest(lookAt(player.rotation), TaskFlowModule.rotation),
+                player.inventory.selectedSlot,
+                state.calcBlockBreakingDelta(player, world, pos) >= buildConfig.breaking.breakThreshold,
+                state,
+                buildConfig.breaking.sorter
             )
-        }
-
-        listen<TickEvent.Pre> {
-            interaction.blockBreakingCooldown = interaction.blockBreakingCooldown.coerceAtMost(breakDelay)
-        }
 
-        listen<PlayerEvent.Breaking.Update> {
-            it.progress += world.getBlockState(it.pos)
-                .calcBlockBreakingDelta(player, world, it.pos) * (1 - breakThreshold)
+            BreakRequest(setOf(breakContext), pendingInteractions, buildConfig).submit()
         }
-
-        listen<RenderEvent.StaticESP> { event ->
-            if (!render || !interaction.isBreakingBlock) return@listen
-
-            val pos = interaction.currentBreakingPos
-            val breakDelta = world.getBlockState(pos).calcBlockBreakingDelta(player, world, pos)
-
-            world.getBlockState(pos).getOutlineShape(world, pos).boundingBoxes.forEach {
-                val previousFactor = interaction.currentBreakingProgress - breakDelta
-                val nextFactor = interaction.currentBreakingProgress
-                val factor = lerp(mc.tickDelta, previousFactor, nextFactor).toDouble()
-
-                val fillColour = fillColourMode.block(factor, if (fillColourMode == ColourMode.Static) staticFillColour else startFillColour, endFillColour)
-                val outlineColor = outlineColourMode.block(factor, if (fillColourMode == ColourMode.Static) staticOutlineColour else startOutlineColour, endOutlineColour)
-                val box = renderMode.block(factor, it)
-                    .offset(pos)
-
-                when (renderSetting) {
-                    RenderSetting.Both -> {
-                        event.renderer.buildFilled(box, fillColour)
-                        event.renderer.buildOutline(box, outlineColor)
-                    }
-
-                    RenderSetting.Fill -> event.renderer.buildFilled(box, fillColour)
-                    RenderSetting.Outline -> event.renderer.buildOutline(box, outlineColor)
-                }
-            }
-        }
-    }
-
-    enum class Page {
-        Mining, Render
-    }
-
-    enum class RenderSetting {
-        Both, Fill, Outline
-    }
-
-    enum class ColourMode(val block: (Double, Color, Color) -> Color) {
-        Static({ _, start, _ -> start }),
-        Dynamic({ factor, start, end -> lerp(factor, start, end) })
-    }
-
-    val Box.ofCenter: Box get() = Box(center, center)
-
-    enum class RenderMode(val block: (Double, Box) -> Box) {
-        Out({ factor, box -> lerp(factor, box.ofCenter, box)}),
-        In({ factor, box -> lerp(factor, box, box.ofCenter)}),
-        Static({ _, box -> box });
     }
 }
