Add ESP and full Nametag info to LogoutLogger (#281)

Nep Nep · Avanatiker · web-flow · commit 2a5fefd3d06e · 2022-04-07T21:06:48.000+02:00
* Add LogoutLogger ESP

* Add clearing on disable

* Make box 2 blocks tall and add outline option

* Fix ConcurrentModifcationException, render correct AABB, render metadata

* Fix graphic glitches caused by interpolation and clean up

Co-authored-by: Constructor &lt;fractalminds@protonmail.com&gt;
diff --git a/src/main/kotlin/com/lambda/client/module/modules/misc/LogoutLogger.kt b/src/main/kotlin/com/lambda/client/module/modules/misc/LogoutLogger.kt
@@ -1,68 +1,111 @@
 package com.lambda.client.module.modules.misc
 
 import com.lambda.client.event.events.ConnectionEvent
+import com.lambda.client.event.events.RenderWorldEvent
 import com.lambda.client.event.listener.asyncListener
+import com.lambda.client.event.listener.listener
 import com.lambda.client.manager.managers.WaypointManager
 import com.lambda.client.module.Category
 import com.lambda.client.module.Module
-import com.lambda.client.util.EntityUtils.flooredPosition
+import com.lambda.client.module.modules.client.GuiColors
 import com.lambda.client.util.EntityUtils.isFakeOrSelf
 import com.lambda.client.util.TickTimer
 import com.lambda.client.util.TimeUnit
+import com.lambda.client.util.graphics.ESPRenderer
 import com.lambda.client.util.math.CoordinateConverter.asString
+import com.lambda.client.util.math.VectorUtils.toBlockPos
 import com.lambda.client.util.text.MessageSendHelper
 import com.lambda.client.util.threads.onMainThread
 import com.lambda.client.util.threads.safeListener
 import com.mojang.authlib.GameProfile
 import net.minecraft.client.entity.EntityOtherPlayerMP
-import net.minecraft.util.math.BlockPos
+import net.minecraft.util.text.TextFormatting
 import net.minecraftforge.fml.common.gameevent.TickEvent
+import java.util.concurrent.ConcurrentHashMap
 
 object LogoutLogger : Module(
     name = "LogoutLogger",
     description = "Logs when a player leaves the game",
     category = Category.MISC
 ) {
-    private val saveWaypoint by setting("Save Waypoint", true)
+    private val saveWaypoint by setting("Save Waypoint", false)
     private val print by setting("Print To Chat", true)
+    private val esp by setting("ESP", true)
+    private val espFilledAlpha by setting("ESP Filled Alpha", 47, 0..255, 1, { esp })
+    private val espOutlineAlpha by setting("ESP Outline Alpha", 0, 0..255, 1, { esp })
+    private val espColor by setting("ESP Color", GuiColors.primary, false, { esp })
+    private val clearEsp by setting("Clear ESP", true, { esp })
 
-    private val loggedPlayers = LinkedHashMap<GameProfile, BlockPos>()
-    private val timer = TickTimer(TimeUnit.SECONDS)
+    private val loggedPlayers = ConcurrentHashMap<GameProfile, EntityOtherPlayerMP>()
+    val loggedOutPlayers = ConcurrentHashMap<GameProfile, EntityOtherPlayerMP>()
+    private val renderer = ESPRenderer()
+    private val renderTimer = TickTimer(TimeUnit.SECONDS)
 
     init {
         asyncListener<ConnectionEvent.Disconnect> {
             onMainThread {
                 loggedPlayers.clear()
+                if (clearEsp) loggedOutPlayers.clear()
             }
         }
 
         safeListener<TickEvent.ClientTickEvent> {
             if (it.phase != TickEvent.Phase.END) return@safeListener
 
-            for (loadedPlayer in world.playerEntities) {
-                if (loadedPlayer !is EntityOtherPlayerMP) continue
-                if (loadedPlayer.isFakeOrSelf) continue
+            world.playerEntities
+                .filterIsInstance<EntityOtherPlayerMP>()
+                .filter { entityOtherPlayerMP -> !entityOtherPlayerMP.isFakeOrSelf }
+                .forEach { entityOtherPlayerMP ->
+                    @Suppress("UNNECESSARY_SAFE_CALL")
+                    connection.getPlayerInfo(entityOtherPlayerMP.gameProfile.id)?.let { networkPlayerInfo ->
+                        loggedPlayers[networkPlayerInfo.gameProfile] = entityOtherPlayerMP
 
-                val info = connection.getPlayerInfo(loadedPlayer.gameProfile.id) ?: continue
-                loggedPlayers[info.gameProfile] = loadedPlayer.flooredPosition
-            }
-
-            if (timer.tick(1L)) {
-                val toRemove = ArrayList<GameProfile>()
+                        loggedOutPlayers.entries.removeIf { (profile, _) ->
+                            profile.id == networkPlayerInfo.gameProfile.id
+                        }
+                    }
+                }
 
-                loggedPlayers.entries.removeIf { (profile, pos) ->
-                    @Suppress("SENSELESS_COMPARISON")
-                    if (connection.getPlayerInfo(profile.id) == null) {
-                        if (saveWaypoint) WaypointManager.add(pos, "${profile.name} Logout Spot")
-                        if (print) MessageSendHelper.sendChatMessage("${profile.name} logged out at ${pos.asString()}")
-                        true
-                    } else {
-                        false
+            loggedPlayers.entries.removeIf { (profile, entityOtherPlayerMP) ->
+                @Suppress("SENSELESS_COMPARISON")
+                if (connection.getPlayerInfo(profile.id) == null) {
+                    if (saveWaypoint) {
+                        WaypointManager.add(entityOtherPlayerMP.entityBoundingBox.center.toBlockPos(), "${profile.name} Logout Spot")
                     }
+                    if (print) {
+                        MessageSendHelper.sendChatMessage("$chatName ${TextFormatting.RED}${profile.name}${TextFormatting.RESET} logged out at (${entityOtherPlayerMP.entityBoundingBox.center.toBlockPos().asString()})")
+                    }
+
+                    // prevent render glitches caused by interpolation
+                    entityOtherPlayerMP.prevPosX = entityOtherPlayerMP.posX
+                    entityOtherPlayerMP.prevPosY = entityOtherPlayerMP.posY
+                    entityOtherPlayerMP.prevPosZ = entityOtherPlayerMP.posZ
+
+                    loggedOutPlayers[profile] = entityOtherPlayerMP
+                    true
+                } else {
+                    false
                 }
+            }
+        }
+
+        onDisable {
+            if (clearEsp) loggedOutPlayers.clear()
+        }
 
-                loggedPlayers.keys.removeAll(toRemove.toSet())
+        listener<RenderWorldEvent> {
+            if (!esp) return@listener
+
+            renderer.aFilled = espFilledAlpha
+            renderer.aOutline = espOutlineAlpha
+
+            if (renderTimer.tick(1)) {
+                renderer.clear()
+                loggedOutPlayers.values.forEach {
+                    renderer.add(it, espColor)
+                }
             }
+            renderer.render(false)
         }
     }
 }
diff --git a/src/main/kotlin/com/lambda/client/module/modules/render/Nametags.kt b/src/main/kotlin/com/lambda/client/module/modules/render/Nametags.kt
@@ -1,5 +1,6 @@
 package com.lambda.client.module.modules.render
 
+import com.lambda.client.LambdaMod
 import com.lambda.client.event.events.RenderOverlayEvent
 import com.lambda.client.module.Category
 import com.lambda.client.module.Module
@@ -20,6 +21,7 @@ import com.lambda.client.commons.extension.ceilToInt
 import com.lambda.client.commons.extension.floorToInt
 import com.lambda.client.commons.utils.MathUtils
 import com.lambda.client.event.listener.listener
+import com.lambda.client.module.modules.misc.LogoutLogger
 import net.minecraft.client.entity.EntityOtherPlayerMP
 import net.minecraft.client.renderer.RenderHelper
 import net.minecraft.entity.Entity
@@ -113,7 +115,7 @@ object Nametags : Module(
 
     private val line1Settings = arrayOf(line1left, line1center, line1right)
     private val line2Settings = arrayOf(line2left, line2center, line2right)
-    private val entityMap = TreeMap<Entity, TextComponent>(compareByDescending { mc.player.getPositionEyes(1f).distanceTo(it.getPositionEyes(1f)) })
+    val entityMap = TreeMap<Entity, TextComponent>(compareByDescending { mc.player.getPositionEyes(1f).distanceTo(it.getPositionEyes(1f)) })
     private val itemMap = TreeSet<ItemGroup>(compareByDescending { mc.player.getPositionEyes(1f).distanceTo(it.getCenter(1f)) })
 
     private var updateTick = 0
@@ -348,6 +350,12 @@ object Nametags : Module(
                         if (player.getDistance(entity) > range) continue
                         entityMap[entity] = TextComponent()
                     }
+
+                    LogoutLogger.loggedOutPlayers.values.filter {
+                        player.getDistance(it) <= range
+                    }.forEach {
+                        entityMap[it] = TextComponent()
+                    }
                 }
                 2 -> { // Removing items
                     val loadEntitySet = world.loadedEntityList.toHashSet()
