Backtrack improvements

Author: bladekt

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

@@ -12,13 +12,16 @@ import com.lambda.module.Module
 import com.lambda.module.modules.client.GuiSettings
 import com.lambda.module.modules.combat.KillAura
 import com.lambda.module.tag.ModuleTag
+import com.lambda.util.ClientPacket
 import com.lambda.util.PacketUtils.handlePacketSilently
+import com.lambda.util.PacketUtils.sendPacketSilently
 import com.lambda.util.ServerPacket
 import com.lambda.util.math.ColorUtils.multAlpha
 import com.lambda.util.math.MathUtils.lerp
 import com.lambda.util.math.VecUtils.dist
 import com.lambda.util.math.VecUtils.minus
 import com.lambda.util.math.VecUtils.plus
+import net.minecraft.entity.LivingEntity
 import net.minecraft.network.packet.s2c.play.EntityAnimationS2CPacket
 import net.minecraft.network.packet.s2c.play.EntityPositionS2CPacket
 import net.minecraft.network.packet.s2c.play.EntityS2CPacket
@@ -38,19 +41,22 @@ object BackTrack : Module(
     description = "Gives reach advantage by delaying your packets",
     defaultTags = setOf(ModuleTag.MOVEMENT)
 ) {
+    private val outbound by setting("Outbound", true)
     private val mode by setting("Mode", Mode.FIXED)
     private val delay by setting("Delay", 500, 100..2000) { mode == Mode.FIXED }
     private val maxDelay by setting("Max Delay", 1000, 100..2000) { mode == Mode.RANGED || mode == Mode.ADAPTIVE }
     private val distance by setting("Distance", 3.0, 1.0..5.0, 0.1) { mode == Mode.RANGED || mode == Mode.ADAPTIVE }
 
-    private val target get() = if (KillAura.isDisabled) null else KillAura.target
+    private var target: LivingEntity? = null
     private var targetPos: Vec3d? = null
 
     private val box = DynamicAABB()
 
     private const val POSITION_PACKET_SCALE = 1 / 4096.0
     private val currentTime get() = System.currentTimeMillis()
-    private val packetPool = ConcurrentLinkedDeque<Pair<ServerPacket, Long>>()
+
+    private val sendPool = ConcurrentLinkedDeque<Pair<ClientPacket, Long>>()
+    private val receivePool = ConcurrentLinkedDeque<Pair<ServerPacket, Long>>()
 
     enum class Mode(val shouldSend: SafeContext.(Vec3d, Vec3d, Long) -> Boolean) {
         FIXED({ _, _, timing ->
@@ -70,18 +76,22 @@ object BackTrack : Module(
 
     init {
         listener<TickEvent.Pre> {
-            target?.let { target ->
-                val pos = targetPos ?: target.pos
-                targetPos = pos
-
-                box.update(target.boundingBox.offset(pos - target.pos))
-                poolPackets()
+            val prevTarget = target
+            target = if (KillAura.isDisabled) null else KillAura.target
+            val currentTarget = target
+
+            if (prevTarget != currentTarget || currentTarget == null) {
+                poolPackets(true)
+                targetPos = null
+                box.reset()
                 return@listener
             }
 
-            poolPackets(true)
-            targetPos = null
-            box.reset()
+            val pos = targetPos ?: currentTarget.pos
+            targetPos = pos
+
+            box.update(currentTarget.boundingBox.offset(pos - currentTarget.pos))
+            poolPackets()
         }
 
         listener<RenderEvent.DynamicESP> {
@@ -95,6 +105,12 @@ object BackTrack : Module(
             it.renderer.build(box, c.multAlpha(0.3), c.multAlpha(0.8))
         }
 
+        listener<PacketEvent.Send.Pre> { event ->
+            if (!outbound || target == null) return@listener
+            sendPool.add(event.packet to currentTime)
+            event.cancel()
+        }
+
         listener<PacketEvent.Receive.Pre> { event ->
             val target = target ?: return@listener
 
@@ -126,16 +142,18 @@ object BackTrack : Module(
                 }
             }
 
-            packetPool.add(packet to currentTime)
+            receivePool.add(packet to currentTime)
             event.cancel()
         }
 
         listener<ConnectionEvent.Connect> {
-            packetPool.clear()
+            receivePool.clear()
+            sendPool.clear()
         }
 
         onEnable {
-            poolPackets(true)
+            receivePool.clear()
+            sendPool.clear()
         }
 
         onDisable {
@@ -144,8 +162,21 @@ object BackTrack : Module(
     }
 
     private fun SafeContext.poolPackets(all: Boolean = false) {
-        while (packetPool.isNotEmpty()) {
-            val (packet, timing) = packetPool.poll() ?: break
+        while (receivePool.isNotEmpty()) {
+            val (packet, timing) = receivePool.poll() ?: break
+
+            val receive = all || targetPos?.let { serverPos ->
+                target?.pos?.let { clientPos ->
+                    mode.shouldSend(this, clientPos, serverPos, timing)
+                }
+            } ?: true
+
+            if (!receive) break
+            connection.handlePacketSilently(packet)
+        }
+
+        while (sendPool.isNotEmpty()) {
+            val (packet, timing) = sendPool.poll() ?: break
 
             val send = all || targetPos?.let { serverPos ->
                 target?.pos?.let { clientPos ->
@@ -154,7 +185,7 @@ object BackTrack : Module(
             } ?: true
 
             if (!send) break
-            connection.handlePacketSilently(packet)
+            connection.sendPacketSilently(packet)
         }
     }
 }