refactor: target tracking (#5515)

* TargetHUD now also displays the current enemy when attacking normally
* Integrates range setting into TargetTracker
* Splits TargetTracker class into TargetTracker and TargetSelector for modules that don't need the tracking part or do it on their own
* Renames functions and properties

---------

Co-authored-by: Izuna <[email protected]>

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/combat/ModuleAimbot.kt

@@ -31,9 +31,8 @@ import net.ccbluex.liquidbounce.utils.aiming.anglesmooth.LinearAngleSmoothMode
 import net.ccbluex.liquidbounce.utils.aiming.anglesmooth.SigmoidAngleSmoothMode
 import net.ccbluex.liquidbounce.utils.client.Chronometer
 import net.ccbluex.liquidbounce.utils.client.Timer
-import net.ccbluex.liquidbounce.utils.combat.PriorityEnum
+import net.ccbluex.liquidbounce.utils.combat.TargetPriority
 import net.ccbluex.liquidbounce.utils.combat.TargetTracker
-import net.ccbluex.liquidbounce.utils.entity.boxedDistanceTo
 import net.ccbluex.liquidbounce.utils.entity.rotation
 import net.ccbluex.liquidbounce.utils.inventory.InventoryManager
 import net.ccbluex.liquidbounce.utils.render.WorldTargetRenderer
@@ -48,7 +47,7 @@ import net.minecraft.util.math.MathHelper
  */
 object ModuleAimbot : ClientModule("Aimbot", Category.COMBAT, aliases = arrayOf("AimAssist", "AutoAim")) {
 
-    private val range by float("Range", 4.2f, 1f..8f)
+    private val range = float("Range", 4.2f, 1f..8f)
 
     private object OnClick : ToggleableConfigurable(this, "OnClick", false) {
         val delayUntilStop by int("DelayUntilStop", 3, 0..10, "ticks")
@@ -58,7 +57,7 @@ object ModuleAimbot : ClientModule("Aimbot", Category.COMBAT, aliases = arrayOf(
         tree(OnClick)
     }
 
-    private val targetTracker = tree(TargetTracker(PriorityEnum.DIRECTION))
+    val targetTracker = tree(TargetTracker(TargetPriority.DIRECTION, range = range))
     private val targetRenderer = tree(WorldTargetRenderer(this))
     private val pointTracker = tree(PointTracker())
     private val clickTimer = Chronometer()
@@ -79,20 +78,19 @@ object ModuleAimbot : ClientModule("Aimbot", Category.COMBAT, aliases = arrayOf(
     private var playerRotation: Rotation? = null
 
     private val tickHandler = handler<RotationUpdateEvent> { _ ->
-        this.targetTracker.validateLock { target -> target.boxedDistanceTo(player) <= range }
-        this.playerRotation = player.rotation
+        playerRotation = player.rotation
 
         if (mc.options.attackKey.isPressed) {
             clickTimer.reset()
         }
 
         if (OnClick.enabled && (clickTimer.hasElapsed(OnClick.delayUntilStop * 50L)
-                || !mc.options.attackKey.isPressed && ModuleAutoClicker.running)) {
-            this.targetRotation = null
+        || !mc.options.attackKey.isPressed && ModuleAutoClicker.running)) {
+            targetRotation = null
             return@handler
         }
 
-        this.targetRotation = findNextTargetRotation()?.let { (target, rotation) ->
+        targetRotation = findNextTargetRotation()?.let { (target, rotation) ->
             angleSmooth.activeChoice.limitAngleChange(
                 slowStart.rotationFactor,
                 player.rotation,
@@ -103,18 +101,17 @@ object ModuleAimbot : ClientModule("Aimbot", Category.COMBAT, aliases = arrayOf(
         }
 
         // Update Auto Weapon
-        ModuleAutoWeapon.prepare(targetTracker.lockedOnTarget)
+        ModuleAutoWeapon.prepare(targetTracker.target)
     }
 
     override fun disable() {
-        targetTracker.cleanup()
-        super.disable()
+        targetTracker.reset()
     }
 
     val renderHandler = handler<WorldRenderEvent> { event ->
         val matrixStack = event.matrixStack
         val partialTicks = event.partialTicks
-        val target = targetTracker.lockedOnTarget ?: return@handler
+        val target = targetTracker.target ?: return@handler
 
         renderEnvironmentForWorld(matrixStack) {
             targetRenderer.render(this, target, partialTicks)
@@ -159,35 +156,30 @@ object ModuleAimbot : ClientModule("Aimbot", Category.COMBAT, aliases = arrayOf(
     }
 
     private fun findNextTargetRotation(): Pair<Entity, VecRotation>? {
-        for (target in targetTracker.enemies()) {
-            if (target.boxedDistanceTo(player) > range) {
-                continue
-            }
-
-            val pointOnHitbox = pointTracker.gatherPoint(target,
-                PointTracker.AimSituation.FOR_NOW)
-
+        for (target in targetTracker.targets()) {
+            val pointOnHitbox = pointTracker.gatherPoint(target, PointTracker.AimSituation.FOR_NOW)
             val rotationPreference = LeastDifferencePreference(player.rotation, pointOnHitbox.toPoint)
 
             val spot = raytraceBox(
                 pointOnHitbox.fromPoint,
                 pointOnHitbox.cutOffBox,
-                range = range.toDouble(),
+                range = targetTracker.maxRange.toDouble(),
                 wallsRange = 0.0,
                 rotationPreference = rotationPreference
             ) ?: raytraceBox(
-                pointOnHitbox.fromPoint, pointOnHitbox.box, range = range.toDouble(),
+                pointOnHitbox.fromPoint, pointOnHitbox.box, range = targetTracker.maxRange.toDouble(),
                 wallsRange = 0.0,
                 rotationPreference = rotationPreference
             ) ?: continue
 
-            if (targetTracker.lockedOnTarget != target) {
+            if (target != targetTracker.target) {
                 slowStart.onTrigger()
             }
-            targetTracker.lock(target)
+            targetTracker.target = target
             return target to spot
         }
 
+        targetTracker.reset()
         return null
     }
 

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/combat/ModuleAutoShoot.kt

@@ -39,9 +39,8 @@ import net.ccbluex.liquidbounce.utils.clicking.ClickScheduler
 import net.ccbluex.liquidbounce.utils.client.SilentHotbar
 import net.ccbluex.liquidbounce.utils.client.interactItem
 import net.ccbluex.liquidbounce.utils.combat.CombatManager
-import net.ccbluex.liquidbounce.utils.combat.PriorityEnum
+import net.ccbluex.liquidbounce.utils.combat.TargetPriority
 import net.ccbluex.liquidbounce.utils.combat.TargetTracker
-import net.ccbluex.liquidbounce.utils.entity.boxedDistanceTo
 import net.ccbluex.liquidbounce.utils.inventory.InventoryManager
 import net.ccbluex.liquidbounce.utils.inventory.Slots
 import net.ccbluex.liquidbounce.utils.item.isNothing
@@ -65,7 +64,6 @@ import net.minecraft.util.Hand
  */
 object ModuleAutoShoot : ClientModule("AutoShoot", Category.COMBAT) {
 
-    private val range by floatRange("Range", 3.0f..6f, 1f..50f)
     private val throwableType by enumChoice("ThrowableType", ThrowableType.EGG_AND_SNOWBALL)
     private val gravityType by enumChoice("GravityType", GravityType.AUTO).apply { tagBy(this) }
 
@@ -74,7 +72,7 @@ object ModuleAutoShoot : ClientModule("AutoShoot", Category.COMBAT) {
     /**
      * The target tracker to find the best enemy to attack.
      */
-    internal val targetTracker = tree(TargetTracker(defaultPriority = PriorityEnum.DISTANCE))
+    internal val targetTracker = tree(TargetTracker(TargetPriority.DISTANCE, floatRange("Range", 3.0f..6f, 1f..50f)))
     private val pointTracker = tree(
         PointTracker(
             lowestPointDefault = PointTracker.PreferredBoxPart.HEAD,
@@ -111,10 +109,8 @@ object ModuleAutoShoot : ClientModule("AutoShoot", Category.COMBAT) {
      */
     @Suppress("unused")
     val simulatedTickHandler = handler<RotationUpdateEvent> {
-        targetTracker.cleanup()
-
         // Find the recommended target
-        val target = targetTracker.enemies().firstOrNull {
+        val target = targetTracker.selectFirst {
             // Check if we can see the enemy
             player.canSee(it)
         } ?: return@handler
@@ -127,10 +123,6 @@ object ModuleAutoShoot : ClientModule("AutoShoot", Category.COMBAT) {
             return@handler
         }
 
-        if (target.boxedDistanceTo(player) !in range) {
-            return@handler
-        }
-
         // Check if we have a throwable, if not we can't shoot.
         val (hand, slot) = getThrowable() ?: return@handler
 
@@ -149,25 +141,18 @@ object ModuleAutoShoot : ClientModule("AutoShoot", Category.COMBAT) {
             rotationConfigurable.toAimPlan(rotation ?: return@handler, considerInventory = considerInventory),
             Priority.IMPORTANT_FOR_USAGE_2, this
         )
-        targetTracker.lock(target)
+    }
+
+    override fun disable() {
+        targetTracker.reset()
     }
 
     /**
      * Handles the auto shoot logic.
      */
     @Suppress("unused")
     val handleAutoShoot = tickHandler {
-        val target = targetTracker.lockedOnTarget ?: return@tickHandler
-
-        // Cannot happen but we want to smart-cast
-        @Suppress("USELESS_IS_CHECK")
-        if (target !is LivingEntity) {
-            return@tickHandler
-        }
-
-        if (target.boxedDistanceTo(player) !in range) {
-            return@tickHandler
-        }
+        val target = targetTracker.target ?: return@tickHandler
 
         if (notDuringCombat && CombatManager.isInCombat) {
             return@tickHandler
@@ -218,7 +203,7 @@ object ModuleAutoShoot : ClientModule("AutoShoot", Category.COMBAT) {
 
     val renderHandler = handler<WorldRenderEvent> { event ->
         val matrixStack = event.matrixStack
-        val target = targetTracker.lockedOnTarget ?: return@handler
+        val target = targetTracker.target ?: return@handler
 
         renderEnvironmentForWorld(matrixStack) {
             targetRenderer.render(this, target, event.partialTicks)

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/combat/ModuleFakeLag.kt

@@ -19,29 +19,20 @@
 package net.ccbluex.liquidbounce.features.module.modules.combat
 
 import net.ccbluex.liquidbounce.config.types.NamedChoice
-import net.ccbluex.liquidbounce.event.events.NotificationEvent
-import net.ccbluex.liquidbounce.event.events.QueuePacketEvent
-import net.ccbluex.liquidbounce.event.events.TransferOrigin
+import net.ccbluex.liquidbounce.event.events.*
 import net.ccbluex.liquidbounce.event.handler
 import net.ccbluex.liquidbounce.event.tickHandler
 import net.ccbluex.liquidbounce.features.module.Category
 import net.ccbluex.liquidbounce.features.module.ClientModule
 import net.ccbluex.liquidbounce.features.module.modules.movement.autododge.ModuleAutoDodge
-import net.ccbluex.liquidbounce.utils.client.Chronometer
-import net.ccbluex.liquidbounce.utils.client.PacketQueueManager
+import net.ccbluex.liquidbounce.utils.client.*
 import net.ccbluex.liquidbounce.utils.client.PacketQueueManager.positions
-import net.ccbluex.liquidbounce.utils.client.notification
-import net.ccbluex.liquidbounce.utils.combat.findEnemy
-import net.ccbluex.liquidbounce.utils.combat.getEntitiesBoxInRange
-import net.ccbluex.liquidbounce.utils.combat.shouldBeAttacked
+import net.ccbluex.liquidbounce.utils.combat.*
 import net.ccbluex.liquidbounce.utils.entity.box
 import net.ccbluex.liquidbounce.utils.item.isConsumable
 import net.minecraft.network.packet.c2s.common.ResourcePackStatusC2SPacket
 import net.minecraft.network.packet.c2s.play.*
-import net.minecraft.network.packet.s2c.play.EntityVelocityUpdateS2CPacket
-import net.minecraft.network.packet.s2c.play.ExplosionS2CPacket
-import net.minecraft.network.packet.s2c.play.HealthUpdateS2CPacket
-import net.minecraft.network.packet.s2c.play.PlayerPositionLookS2CPacket
+import net.minecraft.network.packet.s2c.play.*
 import kotlin.jvm.optionals.getOrNull
 
 /**
@@ -181,9 +172,7 @@ object ModuleFakeLag : ClientModule("FakeLag", Category.COMBAT) {
         }
 
         // Support auto shoot with fake lag
-        if (running && ModuleAutoShoot.constantLag &&
-            ModuleAutoShoot.targetTracker.lockedOnTarget == null
-        ) {
+        if (running && ModuleAutoShoot.constantLag && ModuleAutoShoot.targetTracker.target == null) {
             event.action = PacketQueueManager.Action.QUEUE
             return@handler
         }

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/combat/ModuleTimerRange.kt

@@ -64,7 +64,7 @@ object ModuleTimerRange : ClientModule("TimerRange", Category.COMBAT) {
 
     val repeatable = tickHandler {
         if (onlyOnGround && !player.isOnGround) return@tickHandler
-        if (requiresKillAura && (!ModuleKillAura.running || ModuleKillAura.targetTracker.lockedOnTarget == null)) {
+        if (requiresKillAura && (!ModuleKillAura.running || ModuleKillAura.targetTracker.target == null)) {
             return@tickHandler
         }
 

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/combat/aimbot/ModuleAutoBow.kt

@@ -20,9 +20,7 @@ package net.ccbluex.liquidbounce.features.module.modules.combat.aimbot
 
 import net.ccbluex.liquidbounce.features.module.Category
 import net.ccbluex.liquidbounce.features.module.ClientModule
-import net.ccbluex.liquidbounce.features.module.modules.combat.aimbot.autobow.AutoBowAimbotFeature
-import net.ccbluex.liquidbounce.features.module.modules.combat.aimbot.autobow.AutoBowAutoShootFeature
-import net.ccbluex.liquidbounce.features.module.modules.combat.aimbot.autobow.AutoBowFastChargeFeature
+import net.ccbluex.liquidbounce.features.module.modules.combat.aimbot.autobow.*
 import net.ccbluex.liquidbounce.utils.client.Chronometer
 import net.minecraft.item.BowItem
 import java.util.*
@@ -49,7 +47,7 @@ object ModuleAutoBow : ClientModule("AutoBow", Category.COMBAT, aliases = arrayO
     }
 
     override fun disable() {
-        AutoBowAimbotFeature.targetTracker.cleanup()
+        AutoBowAimbotFeature.targetTracker.reset()
     }
 
     init {

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/combat/aimbot/ModuleProjectileAimbot.kt

@@ -6,21 +6,23 @@ import net.ccbluex.liquidbounce.features.module.ClientModule
 import net.ccbluex.liquidbounce.utils.aiming.RotationManager
 import net.ccbluex.liquidbounce.utils.aiming.RotationsConfigurable
 import net.ccbluex.liquidbounce.utils.aiming.projectiles.SituationalProjectileAngleCalculator
-import net.ccbluex.liquidbounce.utils.combat.TargetTracker
+import net.ccbluex.liquidbounce.utils.combat.TargetSelector
 import net.ccbluex.liquidbounce.utils.kotlin.Priority
 import net.ccbluex.liquidbounce.utils.render.trajectory.TrajectoryData
 
 object ModuleProjectileAimbot : ClientModule("ProjectileAimbot", Category.COMBAT) {
-    private val targetTracker = TargetTracker()
+
+    private val targetSelector = TargetSelector()
     private val rotations = RotationsConfigurable(this)
 
     init {
-        tree(targetTracker)
+        tree(targetSelector)
         tree(rotations)
     }
 
+    @Suppress("unused")
     private val tickHandler = tickHandler {
-        val target = targetTracker.enemies().firstOrNull() ?: return@tickHandler
+        val target = targetSelector.targets().firstOrNull() ?: return@tickHandler
 
         val rotation = player.handItems.firstNotNullOfOrNull {
             if (it.item == null) {

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/combat/aimbot/autobow/AutoBowAimbotFeature.kt

@@ -10,7 +10,7 @@ import net.ccbluex.liquidbounce.utils.aiming.Rotation
 import net.ccbluex.liquidbounce.utils.aiming.RotationManager
 import net.ccbluex.liquidbounce.utils.aiming.RotationsConfigurable
 import net.ccbluex.liquidbounce.utils.aiming.projectiles.SituationalProjectileAngleCalculator
-import net.ccbluex.liquidbounce.utils.combat.PriorityEnum
+import net.ccbluex.liquidbounce.utils.combat.TargetPriority
 import net.ccbluex.liquidbounce.utils.combat.TargetTracker
 import net.ccbluex.liquidbounce.utils.kotlin.Priority
 import net.ccbluex.liquidbounce.utils.render.OverlayTargetRenderer
@@ -24,13 +24,11 @@ import net.minecraft.item.TridentItem
 object AutoBowAimbotFeature : ToggleableConfigurable(ModuleAutoBow, "BowAimbot", true) {
 
     // Target
-    val targetTracker = TargetTracker(PriorityEnum.DISTANCE)
+    val targetTracker = TargetTracker(TargetPriority.DISTANCE)
 
     // Rotation
     val rotationConfigurable = RotationsConfigurable(this)
 
-    val minExpectedPull by int("MinExpectedPull", 5, 0..20, suffix = "ticks")
-
     init {
         tree(targetTracker)
         tree(rotationConfigurable)
@@ -39,8 +37,8 @@ object AutoBowAimbotFeature : ToggleableConfigurable(ModuleAutoBow, "BowAimbot",
     private val targetRenderer = tree(OverlayTargetRenderer(ModuleAutoBow))
 
     @Suppress("unused")
-    val tickRepeatable = tickHandler {
-        targetTracker.cleanup()
+    private val tickRepeatable = tickHandler {
+        targetTracker.reset()
 
         // Should check if player is using bow
         val activeItem = player.activeItem?.item
@@ -55,30 +53,22 @@ object AutoBowAimbotFeature : ToggleableConfigurable(ModuleAutoBow, "BowAimbot",
         ) ?: return@tickHandler
 
         var rotation: Rotation? = null
-
-        for (enemy in targetTracker.enemies()) {
-            val rot = SituationalProjectileAngleCalculator.calculateAngleForEntity(projectileInfo, enemy) ?: continue
-
-            targetTracker.lock(enemy)
-            rotation = rot
-            break
-        }
-
-        if (rotation == null) {
-            return@tickHandler
-        }
+        targetTracker.selectFirst { enemy ->
+            rotation = SituationalProjectileAngleCalculator.calculateAngleForEntity(projectileInfo, enemy)
+            rotation != null
+        } ?: return@tickHandler
 
         RotationManager.aimAt(
-            rotation,
+            rotation!!,
             priority = Priority.IMPORTANT_FOR_USAGE_1,
             provider = ModuleAutoBow,
             configurable = rotationConfigurable
         )
     }
 
     @Suppress("unused")
-    val renderHandler = handler<OverlayRenderEvent> { event ->
-        val target = targetTracker.lockedOnTarget ?: return@handler
+    private val renderHandler = handler<OverlayRenderEvent> { event ->
+        val target = targetTracker.target ?: return@handler
 
         renderEnvironmentForGUI {
             targetRenderer.render(this, target, event.tickDelta)