added break renders, currently only static however, so render at 20 fps

beanbag44 · beanbag44 · commit 0c021c64248c · 2025-06-08T05:44:08.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
@@ -22,6 +22,7 @@ import com.lambda.event.events.TickEvent
 import com.lambda.interaction.request.Priority
 import com.lambda.interaction.request.breaking.BreakConfig
 import com.lambda.util.BlockUtils.allSigns
+import java.awt.Color
 
 class BreakSettings(
     c: Configurable,
@@ -52,4 +53,20 @@ class BreakSettings(
     override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks", visibility = vis)
     override val forceFortunePickaxe by c.setting("Force Fortune Pickaxe", false, "Force fortune pickaxe when breaking blocks", visibility = vis)
     override val minFortuneLevel by c.setting("Min Fortune Level", 1, 1..3, 1, "The minimum fortune level to use") { vis() && forceFortunePickaxe }
+
+    override val renders by c.setting("Renders", true, "Enables the render settings for breaking progress", visibility = vis)
+    override val fill by c.setting("Fill", true, "Renders the sides of the box to display break progress") { vis() && renders }
+    override val outline by c.setting("Outline", true, "Renders the lines of the box to display break progress") { vis() && renders }
+    override val outlineWidth by c.setting("Outline Width", 2, 0..5, 1, "The width of the outline") { vis() && renders && outline }
+    override val animation by c.setting("Animation", AnimationMode.Out, "The style of animation used for the box") { vis() && renders }
+
+    override val dynamicFillColor by c.setting("Dynamic Colour", true, "Enables fill color interpolation from start to finish for fill when breaking a block") { vis() && renders && fill }
+    override val staticFillColor by c.setting("Fill Color", Color(255, 0, 0, 60), "The color of the fill") { vis() && renders && !dynamicFillColor && fill }
+    override val startFillColor by c.setting("Start Fill Color", Color(255, 0, 0, 60), "The color of the fill at the start of breaking") { vis() && renders && dynamicFillColor && fill }
+    override val endFillColor by c.setting("End Fill Color", Color(0, 255, 0, 60), "The color of the fill at the end of breaking") { vis() && renders && dynamicFillColor && fill }
+
+    override val dynamicOutlineColor by c.setting("Dynamic Outline Color", true, "Enables color interpolation from start to finish for the outline when breaking a block") { vis() && renders && outline }
+    override val staticOutlineColor by c.setting("Outline Color", Color(255, 0, 0, 255), "The Color of the outline at the start of breaking") { vis() && renders && !dynamicOutlineColor && outline }
+    override val startOutlineColor by c.setting("Start Outline Color", Color(255, 0, 0, 255), "The color of the outline at the start of breaking") { vis() && renders && dynamicOutlineColor && outline }
+    override val endOutlineColor by c.setting("End Outline Color", Color(0, 255, 0, 255), "The color of the outline at the end of breaking") { vis() && renders && dynamicOutlineColor && outline }
 }
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
@@ -22,6 +22,7 @@ import com.lambda.event.Event
 import com.lambda.interaction.request.Priority
 import com.lambda.interaction.request.RequestConfig
 import net.minecraft.block.Block
+import java.awt.Color
 
 abstract class BreakConfig(
     priority: Priority = 0
@@ -51,6 +52,22 @@ abstract class BreakConfig(
     abstract val minFortuneLevel: Int
     abstract val ignoredBlocks: Set<Block>
 
+    abstract val renders: Boolean
+    abstract val fill: Boolean
+    abstract val outline: Boolean
+    abstract val outlineWidth: Int
+    abstract val animation: AnimationMode
+
+    abstract val dynamicFillColor: Boolean
+    abstract val staticFillColor: Color
+    abstract val startFillColor: Color
+    abstract val endFillColor: Color
+
+    abstract val dynamicOutlineColor: Boolean
+    abstract val staticOutlineColor: Color
+    abstract val startOutlineColor: Color
+    abstract val endOutlineColor: Color
+
     override fun requestInternal(request: BreakRequest, queueIfClosed: Boolean) {
         BreakManager.request(request, queueIfClosed)
     }
@@ -75,4 +92,12 @@ abstract class BreakConfig(
         BreakThenAwait,
         AwaitThenBreak
     }
+
+    enum class AnimationMode {
+        None,
+        Out,
+        In,
+        OutIn,
+        InOut,
+    }
 }
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
@@ -22,11 +22,14 @@ import com.lambda.event.Event
 import com.lambda.event.EventFlow.post
 import com.lambda.event.events.ConnectionEvent
 import com.lambda.event.events.EntityEvent
+import com.lambda.event.events.RenderEvent
 import com.lambda.event.events.TickEvent
 import com.lambda.event.events.UpdateManagerEvent
 import com.lambda.event.events.WorldEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.event.listener.UnsafeListener.Companion.listenUnsafe
+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.request.PositionBlocking
 import com.lambda.interaction.request.Priority
@@ -51,6 +54,7 @@ import com.lambda.util.BlockUtils.isBroken
 import com.lambda.util.BlockUtils.isEmpty
 import com.lambda.util.Communication.warn
 import com.lambda.util.item.ItemUtils.block
+import com.lambda.util.math.lerp
 import com.lambda.util.player.gamemode
 import com.lambda.util.player.swingHand
 import net.minecraft.client.sound.PositionedSoundInstance
@@ -59,6 +63,7 @@ import net.minecraft.entity.ItemEntity
 import net.minecraft.sound.SoundCategory
 import net.minecraft.util.Hand
 import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Box
 
 object BreakManager : RequestHandler<BreakRequest>(
     0,
@@ -169,6 +174,40 @@ object BreakManager : RequestHandler<BreakRequest>(
                 ?.internalOnItemDrop(it.entity)
         }
 
+        listen<RenderEvent.StaticESP> { event ->
+            breakInfos
+                .filterNotNull()
+                .forEach { info ->
+                    val config = info.breakConfig
+                    if (!config.renders) return@listen
+                    val breakDelta = info.context.checkedState.calcItemBlockBreakingDelta(
+                        player,
+                        world,
+                        info.context.expectedPos,
+                        player.inventory.getStack(info.context.hotbarIndex)
+                    )
+                    val progress = (info.breakingTicks * breakDelta).let {
+                        if (info.isPrimary) it * (2 - info.breakConfig.breakThreshold)
+                        else it
+                    }.toDouble()
+                    val state = info.context.checkedState
+                    val boxes = state.getOutlineShape(world, info.context.expectedPos).boundingBoxes.map {
+                        it.offset(info.context.expectedPos)
+                    }
+
+                    val fillColor = if (config.dynamicFillColor) lerp(progress, config.startFillColor, config.endFillColor)
+                    else config.staticFillColor
+                    val outlineColor = if (config.dynamicOutlineColor) lerp(progress, config.startOutlineColor, config.endOutlineColor)
+                    else config.staticOutlineColor
+
+                    boxes.forEach boxes@ { box ->
+                        val interpolated = interpolateBox(box, progress, info.breakConfig)
+                        if (config.fill) event.renderer.buildFilled(interpolated, fillColor)
+                        if (config.outline) event.renderer.buildOutline(interpolated, outlineColor)
+                    }
+                }
+        }
+
         listenUnsafe<ConnectionEvent.Connect.Pre>(priority = Int.MIN_VALUE) {
             breakInfos.forEach { it?.nullify() }
             breakCooldown = 0
@@ -689,5 +728,20 @@ object BreakManager : RequestHandler<BreakRequest>(
         return inRange && correctMaterial
     }
 
+    private fun interpolateBox(box: Box, progress: Double, config: BreakConfig): Box {
+        val boxCenter = Box(box.center, box.center)
+        return when (config.animation) {
+            BreakConfig.AnimationMode.Out -> lerp(progress, boxCenter, box)
+            BreakConfig.AnimationMode.In -> lerp(progress, box, boxCenter)
+            BreakConfig.AnimationMode.InOut ->
+                if (progress >= 0.5f) lerp((progress - 0.5) * 2, boxCenter, box)
+                else lerp(progress * 2, box, boxCenter)
+            BreakConfig.AnimationMode.OutIn ->
+                if (progress >= 0.5f) lerp((progress - 0.5) * 2, box, boxCenter)
+                else lerp(progress * 2, boxCenter, box)
+            else -> box
+        }
+    }
+
     override fun preEvent(): Event = UpdateManagerEvent.Break.post()
 }
diff --git a/common/src/main/kotlin/com/lambda/module/modules/player/PacketMine.kt b/common/src/main/kotlin/com/lambda/module/modules/player/PacketMine.kt
@@ -24,8 +24,12 @@ import com.lambda.config.groups.InventorySettings
 import com.lambda.config.groups.RotationSettings
 import com.lambda.context.SafeContext
 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.graphics.renderer.esp.impl.StaticESPRenderer
 import com.lambda.interaction.construction.blueprint.StaticBlueprint.Companion.toBlueprint
 import com.lambda.interaction.construction.context.BreakContext
 import com.lambda.interaction.construction.context.BuildContext
@@ -37,8 +41,12 @@ import com.lambda.module.Module
 import com.lambda.module.tag.ModuleTag
 import com.lambda.util.BlockUtils.blockState
 import com.lambda.util.math.distSq
+import com.lambda.util.math.lerp
+import com.lambda.util.math.setAlpha
 import com.lambda.util.world.raycast.InteractionMask
 import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Box
+import java.awt.Color
 import java.util.*
 import java.util.concurrent.ConcurrentLinkedQueue
 
@@ -62,6 +70,14 @@ object PacketMine : Module(
     private val queue by setting("Queue", false, "Queues blocks to break so you can select multiple at once")
         .onValueChange { _, to -> if (!to) queuePositions.clear() }
     private val queueOrder by setting("Queue Order", QueueOrder.Standard, "Which end of the queue to break blocks from") { queue }
+    private val renderQueue by setting("Render Queue", true, "Adds renders to signify what block positions are queued") { queue }
+    private val renderSize by setting("Render Size", 0.3f, 0.01f..1f, 0.01f, "The scale of the queue renders") { queue && renderQueue }
+    private val renderMode by setting("Render Mode", RenderMode.State, "The style of the queue renders") { queue && renderQueue }
+    private val dynamicColor by setting("Dynamic Color", true, "Interpolates the color between start and end") { queue && renderQueue }
+    private val staticColor by setting("Color", Color(255, 0, 0, 60)) { queue && renderQueue && !dynamicColor }
+    private val startColor by setting("Start Color", Color(255, 255, 0, 60), "The color of the start (closest to breaking) of the queue") { queue && renderQueue && dynamicColor }
+    private val endColor by setting("End Color", Color(255, 0, 0, 60), "The color of the end (farthest from breaking) of the queue") { queue && renderQueue && dynamicColor }
+
 
     private val pendingInteractionsList = ConcurrentLinkedQueue<BuildContext>()
 
@@ -125,6 +141,25 @@ object PacketMine : Module(
             }
         }
 
+        listen<RenderEvent.StaticESP> { event ->
+            if (!renderQueue) return@listen
+            queuePositions.forEachIndexed { index, positions ->
+                positions.forEach { pos ->
+                    val color = if (dynamicColor) lerp(index / queuePositions.size.toDouble(), startColor, endColor)
+                    else staticColor
+                    val boxes = when (renderMode) {
+                        RenderMode.State -> blockState(pos).getOutlineShape(world, pos).boundingBoxes
+                        RenderMode.Box -> listOf(Box(0.0, 0.0, 0.0, 1.0, 1.0, 1.0))
+                    }.map { lerp(renderSize.toDouble(), Box(it.center, it.center), it).offset(pos) }
+
+                    boxes.forEach { box ->
+                        event.renderer.buildFilled(box, color)
+                        event.renderer.buildOutline(box, Color(color.rgb).setAlpha(1.0))
+                    }
+                }
+            }
+        }
+
         onDisable {
             breakPositions[0] = null
             breakPositions[1] = null
@@ -222,4 +257,9 @@ object PacketMine : Module(
         Standard,
         Reversed
     }
+
+    private enum class RenderMode {
+        State,
+        Box
+    }
 }
