Tick Shift renderer & refactor

Author: bladekt

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

@@ -6,6 +6,8 @@ import com.lambda.event.callback.Cancellable
 import com.lambda.event.callback.ICancellable
 import com.lambda.event.events.PacketEvent.Receive
 import com.lambda.event.events.PacketEvent.Send
+import com.lambda.util.ClientPacket
+import com.lambda.util.ServerPacket
 import net.minecraft.network.listener.ClientPacketListener
 import net.minecraft.network.listener.ServerPacketListener
 import net.minecraft.network.packet.Packet
@@ -36,14 +38,14 @@ abstract class PacketEvent : Event {
          *
          * @param packet the packet that is about to be sent.
          */
-        class Pre(val packet: Packet<out ServerPacketListener>) : Send(), ICancellable by Cancellable()
+        class Pre(val packet: ClientPacket) : Send(), ICancellable by Cancellable()
 
         /**
          * Represents the event triggered after a packet is sent.
          *
          * @param packet the packet that has been sent.
          */
-        class Post(val packet: Packet<out ServerPacketListener>) : Send()
+        class Post(val packet: ClientPacket) : Send()
     }
 
     /**
@@ -56,13 +58,13 @@ abstract class PacketEvent : Event {
          *
          * @param packet the packet that is about to be received.
          */
-        class Pre(val packet: Packet<out ClientPacketListener>) : Receive(), ICancellable by Cancellable()
+        class Pre(val packet: ServerPacket) : Receive(), ICancellable by Cancellable()
 
         /**
          * Represents the event triggered after a packet is received.
          *
          * @param packet the packet that has been received.
          */
-        class Post(val packet: Packet<out ClientPacketListener>) : Receive()
+        class Post(val packet: ServerPacket) : Receive()
     }
 }

common/src/main/kotlin/com/lambda/graphics/renderer/gui/rect/FilledRectRenderer.kt

@@ -41,7 +41,7 @@ class FilledRectRenderer : AbstractRectRenderer(
         val halfSize = size * 0.5
         val maxRadius = min(halfSize.x, halfSize.y)
 
-        val round = min(roundRadius, maxRadius)
+        val round = roundRadius.coerceAtMost(maxRadius).coerceAtLeast(0.0)
 
         val p1 = pos1 - 0.25
         val p2 = pos2 + 0.25

common/src/main/kotlin/com/lambda/graphics/renderer/gui/rect/OutlineRectRenderer.kt

@@ -47,7 +47,7 @@ class OutlineRectRenderer : AbstractRectRenderer(
 
             val halfSize = r.size * 0.5
             val maxRadius = min(halfSize.x, halfSize.y) - 0.5
-            val round = (roundRadius + size).coerceAtMost(maxRadius)
+            val round = (roundRadius + size).coerceAtMost(maxRadius).coerceAtLeast(0.0)
 
             fun MutableList<Int>.buildCorners(base: Vec2d, c: Color, angleRange: IntRange) = repeat(quality) {
                 val min = angleRange.first.toDouble()

common/src/main/kotlin/com/lambda/module/HudModule.kt

@@ -1,7 +1,10 @@
 package com.lambda.module
 
 import com.lambda.event.events.RenderEvent
+import com.lambda.event.events.TickEvent
 import com.lambda.event.listener.SafeListener.Companion.listener
+import com.lambda.graphics.animation.AnimationTicker
+import com.lambda.gui.api.GuiEvent
 import com.lambda.gui.api.RenderLayer
 import com.lambda.gui.api.component.core.DockingRect
 import com.lambda.module.tag.ModuleTag
@@ -52,6 +55,7 @@ abstract class HudModule(
 
     var position by rectHandler::position
     val rect by rectHandler::rect
+    val animation = AnimationTicker()
 
     private val renderer = RenderLayer()
 
@@ -68,5 +72,9 @@ abstract class HudModule(
 
             renderer.render()
         }
+
+        listener<TickEvent.Pre> {
+            animation.tick()
+        }
     }
 }

common/src/main/kotlin/com/lambda/module/hud/TickShiftCharge.kt

@@ -0,0 +1,55 @@
+package com.lambda.module.hud
+
+import com.lambda.graphics.animation.Animation.Companion.exp
+import com.lambda.module.HudModule
+import com.lambda.module.modules.client.ClickGui
+import com.lambda.module.modules.client.GuiSettings
+import com.lambda.module.modules.client.GuiSettings.primaryColor
+import com.lambda.module.modules.movement.TickShift
+import com.lambda.module.tag.ModuleTag
+import com.lambda.util.math.ColorUtils.multAlpha
+import com.lambda.util.math.Rect
+import java.awt.Color
+
+object TickShiftCharge : HudModule(
+    name = "TickShiftCharge",
+    defaultTags = setOf(ModuleTag.CLIENT),
+) {
+    private val isActive get() = TickShift.isEnabled && TickShift.isActive && TickShift.boost
+    private val activeAnimation by animation.exp(0.0, 1.0, 0.6, ::isActive)
+
+    private val progress get() = if (!TickShift.isActive) 0.0
+    else (TickShift.balance / TickShift.maxBalance.toDouble()).coerceIn(0.0..1.0)
+
+    private val renderProgress by animation.exp(::progress, 0.8)
+
+    override val width = 70.0
+    override val height = 14.0
+
+    init {
+        onRender {
+            filled.build(
+                rect = rect,
+                roundRadius = ClickGui.windowRadius,
+                color =  GuiSettings.backgroundColor,
+                shade = GuiSettings.shadeBackground
+            )
+
+            val padding = 1.0
+            filled.build(
+                rect = Rect.basedOn(rect.leftTop, rect.size.x * renderProgress, rect.size.y).shrink(padding),
+                roundRadius = ClickGui.windowRadius - padding,
+                color = GuiSettings.mainColor.multAlpha(0.3),
+                shade = true
+            )
+
+            outline.build(
+                rect = rect,
+                roundRadius = ClickGui.windowRadius,
+                color = (if (GuiSettings.shadeBackground) Color.WHITE else primaryColor).multAlpha(activeAnimation),
+                glowRadius = ClickGui.glowRadius * activeAnimation,
+                shade = true
+            )
+        }
+    }
+}

common/src/main/kotlin/com/lambda/module/modules/movement/TickShift.kt

@@ -10,30 +10,37 @@ import com.lambda.module.modules.combat.KillAura
 import com.lambda.module.tag.ModuleTag
 import com.lambda.threading.runConcurrent
 import com.lambda.util.Communication.info
+import com.lambda.util.PacketUtils.handlePacketSilently
 import com.lambda.util.PacketUtils.sendPacketSilently
 import kotlinx.coroutines.delay
-import net.minecraft.network.ClientConnection
 import net.minecraft.network.packet.c2s.common.CommonPongC2SPacket
+import net.minecraft.network.packet.c2s.play.PlayerMoveC2SPacket
 import net.minecraft.network.packet.s2c.play.EntityVelocityUpdateS2CPacket
 
 object TickShift : Module(
     name = "TickShift",
     description = "Smort tickshift for smort anticheats",
     defaultTags = setOf(ModuleTag.MOVEMENT)
 ) {
-    private val maxBalance by setting("Max Balance", 20, 3..400, 1)
+    val maxBalance by setting("Max Balance", 20, 3..400, 1)
     private val boostAmount by setting("Boost", 3.0, 1.1..20.0, 0.01)
     private val slowdown by setting("Slowdown", 0.35, 0.01..0.9, 0.01)
+    private val delaySetting by setting("Delay", 0, 0..2000, 10)
+    private val strict by setting("Strict", true)
     private val shiftVelocity by setting("Shift velocity", true)
     private val requiresAura by setting("Requires Aura", false)
 
-    private val isActive get() = (KillAura.isEnabled && KillAura.target != null) || !requiresAura
+    val isActive: Boolean get() {
+        if (requiresAura && (!KillAura.isEnabled || KillAura.target == null)) return false
+        return System.currentTimeMillis() - lastBoost > delaySetting
+    }
 
     private var pingPool = ArrayDeque<CommonPongC2SPacket>()
     private var lastVelocity: EntityVelocityUpdateS2CPacket? = null
 
-    private var balance = 0
-    private var boost = false
+    var balance = 0
+    var boost = false
+    private var lastBoost = 0L
 
     init {
         listener<TickEvent.Post> {
@@ -42,26 +49,43 @@ object TickShift : Module(
                 disable()
             }
 
-            if (--balance <= 0) {
+            if (strict) balance--
+
+            if (balance <= 0) {
                 balance = 0
-                boost = false
                 poolPackets()
+
+                if (boost) {
+                    boost = false
+                    lastBoost = System.currentTimeMillis()
+                }
             }
         }
 
+        listener<PacketEvent.Send.Pre> {
+            if (it.packet !is PlayerMoveC2SPacket) return@listener
+            if (!strict) balance--
+        }
+
         runConcurrent {
             while (true) {
                 delay(50)
 
-                if (++balance >= maxBalance) {
-                    balance = maxBalance
-                    boost = isActive
+                if (isEnabled) {
+                    if (++balance >= maxBalance) {
+                        balance = maxBalance
+                        boost = isActive
+                    }
                 }
             }
         }
 
         listener<ClientEvent.Timer> {
-            if (!isActive) return@listener
+            if (!isActive) {
+                poolPackets()
+                return@listener
+            }
+
             it.speed = if (boost) boostAmount else slowdown
         }
 
@@ -94,17 +118,20 @@ object TickShift : Module(
         }
 
         onDisable {
+            balance = 0
+            boost = false
+
             poolPackets()
         }
     }
-    
+
     private fun SafeContext.poolPackets() {
         while (pingPool.isNotEmpty()) {
             connection.sendPacketSilently(pingPool.removeFirst())
         }
 
-        lastVelocity?.let { velocity ->
-            ClientConnection.handlePacket(velocity, connection.connection.packetListener)
+        lastVelocity?.let {
+            connection.handlePacketSilently(it)
             lastVelocity = null
         }
     }

common/src/main/kotlin/com/lambda/util/PacketUtils.kt

@@ -14,7 +14,7 @@ object PacketUtils {
      *
      * @param packet The packet to send.
      */
-    fun ClientPlayNetworkHandler.sendPacketSilently(packet: Packet<out ServerPacketListener>) {
+    fun ClientPlayNetworkHandler.sendPacketSilently(packet: ClientPacket) {
         if (!connection.isOpen) return
         connection.send(packet, null, true)
         connection.packetsSentCounter++
@@ -27,11 +27,14 @@ object PacketUtils {
      *
      * @param packet The packet to handle.
      */
-    fun ClientPlayNetworkHandler.handlePacketSilently(packet: Packet<out ClientPacketListener>) {
+    fun ClientPlayNetworkHandler.handlePacketSilently(packet: ServerPacket) {
         if (!connection.isOpen) return
         if (connection.packetListener?.accepts(packet) == false) return
 
         ClientConnection.handlePacket(packet, connection.packetListener)
         connection.packetsReceivedCounter++
     }
 }
+
+typealias ClientPacket = Packet<out ServerPacketListener>
+typealias ServerPacket = Packet<out ClientPacketListener>