From e28c722117cdce771d25c39205705699b95d3982 Mon Sep 17 00:00:00 2001
From: RtxOP <137506596+RtxOP@users.noreply.github.com>
Date: Sun, 16 Feb 2025 14:45:35 +0000
Subject: [PATCH 01/19] targethud

---
 .../ui/client/hud/element/elements/Target.kt  | 101 +++++++++++-------
 .../net/ccbluex/liquidbounce/ui/font/Fonts.kt |  11 +-
 2 files changed, 69 insertions(+), 43 deletions(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
index 60374ab18dd..ecffdf0bfd6 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
@@ -18,9 +18,13 @@ import net.ccbluex.liquidbounce.utils.render.ColorUtils.withAlpha
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.deltaTime
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawHead
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRect
+import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRoundedRect
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRoundedBorderRect
 import net.ccbluex.liquidbounce.utils.render.animation.AnimationUtil
 import net.ccbluex.liquidbounce.utils.render.shader.shaders.RainbowShader
+import net.ccbluex.liquidbounce.utils.render.shader.shaders.GradientShader
+import net.ccbluex.liquidbounce.utils.render.ColorSettingsFloat
+import net.ccbluex.liquidbounce.utils.render.toColorArray
 import net.minecraft.client.gui.GuiChat
 import net.minecraft.entity.EntityLivingBase
 import org.lwjgl.opengl.GL11.*
@@ -30,6 +34,7 @@ import java.text.DecimalFormatSymbols
 import java.util.*
 import kotlin.math.abs
 import kotlin.math.pow
+import kotlin.math.max
 
 /**
  * A Target HUD
@@ -44,6 +49,12 @@ class Target : Element("Target") {
     private val backgroundMode by choices("Background-ColorMode", arrayOf("Custom", "Rainbow"), "Custom")
     private val backgroundColor by color("Background-Color", Color.BLACK.withAlpha(150)) { backgroundMode == "Custom" }
 
+    private val gradientHealthSpeed by float("Health-Gradient-Speed", 1f, 0.5f..10f)
+    private val maxGradientHealthColors by int("Max-Health-Gradient-Colors", 2, 2..MAX_GRADIENT_COLORS)
+    private val gradientHealthColors = ColorSettingsFloat.create(this, "Health-Gradient") { it <= maxGradientHealthColors }
+    private val gradientX by float("Gradient-X", -250F, -2000F..2000F)
+    private val gradientY by float("Gradient-Y", -1000F, -2000F..2000F)
+
     private val borderMode by choices("Border-ColorMode", arrayOf("Custom", "Rainbow"), "Custom")
     private val borderColor by color("Border-Color", Color.BLACK) { borderMode == "Custom" }
 
@@ -53,7 +64,7 @@ class Target : Element("Target") {
     private val rainbowY by float("Rainbow-Y", -1000F, -2000F..2000F) { backgroundMode == "Rainbow" }
 
     private val titleFont by font("TitleFont", Fonts.fontSemibold40)
-    private val bodyFont by font("BodyFont", Fonts.fontSemibold35)
+    private val healthFont by font("healthFont", Fonts.fontRegular30)
     private val textShadow by boolean("TextShadow", false)
 
     private val fadeSpeed by float("FadeSpeed", 2F, 1F..9F)
@@ -103,7 +114,6 @@ class Target : Element("Target") {
                 val targetHealth = getHealth(target!!, healthFromScoreboard, absorption)
                 val maxHealth = target.maxHealth + if (absorption) target.absorptionAmount else 0F
 
-                // Calculate health color based on entity's health
                 val healthColor = when {
                     targetHealth <= 0 -> Color(255, 0, 0, if (fadeMode) alphaText else textColor.alpha)
                     else -> {
@@ -119,7 +129,10 @@ class Target : Element("Target") {
                     }
                 }
 
-                if (target != lastTarget || easingHealth < 0 || easingHealth > maxHealth || abs(easingHealth - targetHealth) < 0.01) {
+                easingHealth += ((targetHealth - easingHealth) / 2f.pow(10f - fadeSpeed)) * deltaTime
+                easingHealth = easingHealth.coerceIn(0f, maxHealth)
+
+                if (target != lastTarget || abs(easingHealth - targetHealth) < 0.01) {
                     easingHealth = targetHealth
                 }
 
@@ -176,6 +189,10 @@ class Target : Element("Target") {
                 val rainbowX = if (rainbowX == 0f) 0f else 1f / rainbowX
                 val rainbowY = if (rainbowY == 0f) 0f else 1f / rainbowY
 
+                val gradientOffset = System.currentTimeMillis() % 10000 / 10000F
+                val gradientX = if (gradientX == 0f) 0f else 1f / gradientX
+                val gradientY = if (gradientY == 0f) 0f else 1f / gradientY
+
                 glPushMatrix()
 
                 glEnable(GL_BLEND)
@@ -198,49 +215,58 @@ class Target : Element("Target") {
                         )
                     }
 
-                    // Health bar
-                    val healthBarWidth = (targetHealth / maxHealth).coerceIn(0F, 1F) * (width - 6f).coerceAtLeast(0F)
-                    drawRect(3F, 34F, 3f + healthBarWidth, 36F, healthColor.rgb)
-
-                    // Easing health update
-                    easingHealth += ((targetHealth - easingHealth) / 2f.pow(10f - fadeSpeed)) * deltaTime
-                    val easingHealthWidth = (easingHealth / maxHealth) * (width - 6f)
-
-                    // Heal animation, only animate from the right side
-                    if (easingHealth < targetHealth) {
-                        drawRect(3f + easingHealthWidth, 34F, 3f + healthBarWidth, 36F, Color(44, 201, 144).rgb)
+                    val healthBarTop = 26F
+                    val healthBarHeight = 8F
+                    val healthBarStart = 36F
+                    val healthBarTotal = (width - 39F).coerceAtLeast(0F)
+                    val currentWidth = (easingHealth / maxHealth).coerceIn(0F, 1F) * healthBarTotal
+
+                    drawRoundedRect(
+                        healthBarStart,
+                        healthBarTop,
+                        healthBarStart + healthBarTotal,
+                        healthBarTop + healthBarHeight,
+                        Color.BLACK.rgb,
+                        3F,
+                    )
+
+                    GradientShader.begin(
+                        true,
+                        gradientX,
+                        gradientY,
+                        gradientHealthColors.toColorArray(maxGradientHealthColors),
+                        gradientHealthSpeed,
+                        gradientOffset
+                    ).use {
+                        drawRoundedRect(
+                            healthBarStart, 
+                            healthBarTop, 
+                            healthBarStart + currentWidth, 
+                            healthBarTop + healthBarHeight, 
+                            0, 
+                            3F
+                        )
                     }
 
-                    // Damage animation, only animate from the right side
-                    if (easingHealth > targetHealth) {
-                        drawRect(3f + healthBarWidth, 34F, 3f + easingHealthWidth, 36F, Color(252, 185, 65).rgb)
-                    }
+                    val healthPercentage = ((easingHealth / maxHealth) * 100).toInt()
+                    val percentageText = "$healthPercentage%"
+                    val textWidth = healthFont.getStringWidth(percentageText)
+                    val calcX = healthBarStart + currentWidth - textWidth
+                    val textX = max(healthBarStart, calcX)
+                    val textY = healthBarTop - Fonts.fontRegular30.fontHeight / 2 - 4F
+                    healthFont.drawString(percentageText, textX, textY, textCustomColor, textShadow)
 
                     val shouldRenderBody =
                         (fadeMode && alphaText + alphaBackground + alphaBorder > 100) || (smoothMode && width + height > 100)
 
                     if (shouldRenderBody) {
-                        // Draw title text
-                        target.name?.let { titleFont.drawString(it, 36F, 5F, textCustomColor, textShadow) }
-
-                        // Draw body text
-                        bodyFont.drawString(
-                            "Distance: ${decimalFormat.format(mc.thePlayer.getDistanceToEntityBox(target))}",
-                            36F,
-                            15F,
-                            textCustomColor,
-                            textShadow
-                        )
-
-                        // Draw info
                         mc.netHandler?.getPlayerInfo(target.uniqueID)?.let {
-                            bodyFont.drawString(
-                                "Ping: ${it.responseTime.coerceAtLeast(0)}", 36F, 24F, textCustomColor, textShadow
-                            )
-
-                            // Draw head
                             val locationSkin = it.locationSkin
-                            drawHead(locationSkin, 4, 4, 8F, 8F, 8, 8, 30 - 2, 30 - 2, 64F, 64F)
+                            drawHead(locationSkin, 4, 6, 8F, 8F, 8, 8, 30 - 2, 30 - 2, 64F, 64F)
+                        }
+                        
+                        target.name?.let { 
+                            titleFont.drawString(it, 36F, 8F, textCustomColor, textShadow)
                         }
                     }
                 }
@@ -252,5 +278,4 @@ class Target : Element("Target") {
         lastTarget = target
         return Border(0F, 0F, stringWidth, 40F)
     }
-
 }
\ No newline at end of file
diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/font/Fonts.kt b/src/main/java/net/ccbluex/liquidbounce/ui/font/Fonts.kt
index ea1d41a27aa..be5b3f272be 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/font/Fonts.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/font/Fonts.kt
@@ -61,6 +61,7 @@ object Fonts : MinecraftInstance {
     lateinit var fontRegular40: GameFontRenderer
     lateinit var fontRegular45: GameFontRenderer
     lateinit var fontRegular35: GameFontRenderer
+    lateinit var fontRegular30: GameFontRenderer
     lateinit var fontBold180: GameFontRenderer
 
     private fun <T : FontRenderer> register(fontInfo: FontInfo, fontRenderer: T): T {
@@ -90,6 +91,11 @@ object Fonts : MinecraftInstance {
 
             register(minecraftFontInfo, minecraftFont)
 
+            fontRegular30 = register(
+                FontInfo(name = "Outfit Regular", size = 30),
+                getFontFromFile("Outfit-Regular.ttf", 30).asGameFontRenderer()
+            )
+
             fontSemibold35 = register(
                 FontInfo(name = "Outfit Semibold", size = 35),
                 getFontFromFile("Outfit-Semibold.ttf", 35).asGameFontRenderer()
@@ -110,11 +116,6 @@ object Fonts : MinecraftInstance {
                 getFontFromFile("Outfit-Semibold.ttf", 40).asGameFontRenderer()
             )
 
-            fontSemibold35 = register(
-                FontInfo(name = "Outfit Semibold", size = 35),
-                getFontFromFile("Outfit-Semibold.ttf", 35).asGameFontRenderer()
-            )
-
             fontRegular45 = register(
                 FontInfo(name = "Outfit Regular", size = 45),
                 getFontFromFile("Outfit-Regular.ttf", 45).asGameFontRenderer()

From e8a5f9aa7c519e0d4ea44d6817cba7a3cb076a1d Mon Sep 17 00:00:00 2001
From: mems01 <70612656+mems01@users.noreply.github.com>
Date: Sun, 16 Feb 2025 18:06:04 +0200
Subject: [PATCH 02/19] clipping + wifi-render code if needed

avatar pos fix
---
 .../ui/client/hud/element/elements/Target.kt  | 55 +++++++++++++++----
 .../liquidbounce/utils/render/RenderUtils.kt  | 50 +++++++++++++++++
 src/main/resources/liquidbounce_at.cfg        |  4 +-
 3 files changed, 98 insertions(+), 11 deletions(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
index ecffdf0bfd6..dfdae77f727 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
@@ -12,20 +12,19 @@ import net.ccbluex.liquidbounce.ui.client.hud.element.ElementInfo
 import net.ccbluex.liquidbounce.ui.font.AWTFontRenderer.Companion.assumeNonVolatile
 import net.ccbluex.liquidbounce.ui.font.Fonts
 import net.ccbluex.liquidbounce.utils.attack.EntityUtils.getHealth
-import net.ccbluex.liquidbounce.utils.extensions.getDistanceToEntityBox
+import net.ccbluex.liquidbounce.utils.render.ColorSettingsFloat
 import net.ccbluex.liquidbounce.utils.render.ColorUtils
 import net.ccbluex.liquidbounce.utils.render.ColorUtils.withAlpha
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.deltaTime
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawHead
-import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRect
-import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRoundedRect
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRoundedBorderRect
+import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRoundedRect
 import net.ccbluex.liquidbounce.utils.render.animation.AnimationUtil
-import net.ccbluex.liquidbounce.utils.render.shader.shaders.RainbowShader
 import net.ccbluex.liquidbounce.utils.render.shader.shaders.GradientShader
-import net.ccbluex.liquidbounce.utils.render.ColorSettingsFloat
+import net.ccbluex.liquidbounce.utils.render.shader.shaders.RainbowShader
 import net.ccbluex.liquidbounce.utils.render.toColorArray
 import net.minecraft.client.gui.GuiChat
+import net.minecraft.entity.Entity
 import net.minecraft.entity.EntityLivingBase
 import org.lwjgl.opengl.GL11.*
 import java.awt.Color
@@ -33,8 +32,8 @@ import java.text.DecimalFormat
 import java.text.DecimalFormatSymbols
 import java.util.*
 import kotlin.math.abs
-import kotlin.math.pow
 import kotlin.math.max
+import kotlin.math.pow
 
 /**
  * A Target HUD
@@ -260,11 +259,47 @@ class Target : Element("Target") {
                         (fadeMode && alphaText + alphaBackground + alphaBorder > 100) || (smoothMode && width + height > 100)
 
                     if (shouldRenderBody) {
-                        mc.netHandler?.getPlayerInfo(target.uniqueID)?.let {
-                            val locationSkin = it.locationSkin
-                            drawHead(locationSkin, 4, 6, 8F, 8F, 8, 8, 30 - 2, 30 - 2, 64F, 64F)
+                        val renderer = mc.renderManager.getEntityRenderObject<Entity>(target)
+
+                        if (renderer != null) {
+                            val entityTexture = renderer.getEntityTexture(target)
+
+                            if (entityTexture != null) {
+                                drawHead(entityTexture, 4, 6, 8F, 8F, 8, 8, 32, 32, 64F, 64F)
+                            }
                         }
-                        
+
+                        /*
+
+                        If you decide to make the avatar shrinkable on hit, see the translate and scale code
+
+                        in your case you must find the midpoint X/Y of the avatar position, then do the scaling
+                        but make sure the scaling is within the original element scale, check code below
+                        then after you are done with the scaling, revert back to the original position by translating the positions
+                        against them so it becomes back to 0. push/pop matrix is needed so it only handles the avatar.
+                        just check code below.
+
+                        remove if you know what to do
+
+                        val renderer = mc.renderManager.getEntityRenderObject<Entity>(target)
+                        if (renderer != null) {
+                            val entityTexture = renderer.getEntityTexture(target)
+
+                            if (entityTexture != null) {
+                                glPushMatrix()
+                                val scale = 1 - hurtTime / 10f
+                                val f1 = (0.7F..1F).lerpWith(scale) * this.scale * elementScale
+                                val color = ColorUtils.interpolateColor(Color.RED, Color.WHITE, scale)
+                                val centerX1 = (4..32).lerpWith(0.5F)
+
+                                glTranslatef(centerX1, midY, 0f)
+                                glScalef(f1, f1, f1)
+                                glTranslatef(-centerX1, -midY, 0f)
+                                drawHead(entityTexture, 4, (midY - 16).roundToInt(), 8F, 8F, 8, 8, 32, 32, 64F, 64F, color)
+                                glPopMatrix()
+                            }
+                        }*/
+
                         target.name?.let { 
                             titleFont.drawString(it, 36F, 8F, textCustomColor, textShadow)
                         }
diff --git a/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt b/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
index cdfc1d1e91f..26510fc9e9b 100644
--- a/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
@@ -5,11 +5,13 @@
  */
 package net.ccbluex.liquidbounce.utils.render
 
+import co.uk.hexeption.utils.OutlineUtils
 import net.ccbluex.liquidbounce.config.ColorValue
 import net.ccbluex.liquidbounce.ui.font.Fonts
 import net.ccbluex.liquidbounce.utils.block.block
 import net.ccbluex.liquidbounce.utils.block.center
 import net.ccbluex.liquidbounce.utils.block.toVec
+import net.ccbluex.liquidbounce.utils.client.ClientUtils.disableFastRender
 import net.ccbluex.liquidbounce.utils.client.MinecraftInstance
 import net.ccbluex.liquidbounce.utils.extensions.*
 import net.ccbluex.liquidbounce.utils.io.flipSafely
@@ -45,6 +47,34 @@ object RenderUtils : MinecraftInstance {
     }
     var deltaTime = 0
 
+    /**
+     * Useful for clipping any top-layered rectangle that falls outside a bottom-layered rectangle.
+     */
+    inline fun withClipping(main: () -> Unit, toClip: () -> Unit) {
+        disableFastRender()
+        OutlineUtils.checkSetupFBO()
+        glPushMatrix()
+
+        glEnable(GL_STENCIL_TEST)
+        glStencilFunc(GL_ALWAYS, 1, 1)
+        glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE)
+        glStencilMask(1)
+        glClear(GL_STENCIL_BUFFER_BIT)
+
+        main()
+
+        glStencilFunc(GL_EQUAL, 1, 1)
+        glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP)
+        glStencilMask(0)
+
+        toClip()
+
+        glStencilMask(0xFF)
+        glDisable(GL_STENCIL_TEST)
+
+        glPopMatrix()
+    }
+
     fun deltaTimeNormalized(ticks: Int = 1) = (deltaTime safeDivD ticks * 50.0).coerceAtMost(1.0)
 
     private const val CIRCLE_STEPS = 40
@@ -1324,6 +1354,26 @@ object RenderUtils : MinecraftInstance {
         glPopMatrix()
     }
 
+    // Used to draw a WIFI-like icon.
+    fun drawQuarterCircle(x: Int, y: Int, radius: Float, color: Color) {
+        glPushMatrix()
+        glDisable(GL_TEXTURE_2D)
+        glColor(color)
+        glBegin(GL_TRIANGLE_FAN)
+
+        glVertex2f(x.toFloat(), y.toFloat())
+
+        for (i in CIRCLE_STEPS / 8..CIRCLE_STEPS * 3 / 8) {
+            val point = circlePoints[i]
+            glVertex2f(x + radius * point.z.toFloat(), y + radius * point.x.toFloat())
+        }
+
+        glColor4f(1f, 1f, 1f, 1f)
+        glEnd()
+        glEnable(GL_TEXTURE_2D)
+        glPopMatrix()
+    }
+
     fun renderNameTag(string: String, x: Double, y: Double, z: Double) {
         val renderManager = mc.renderManager
         val (x1, y1, z1) = Vec3(x, y, z) - renderManager.renderPos
diff --git a/src/main/resources/liquidbounce_at.cfg b/src/main/resources/liquidbounce_at.cfg
index 112547ecb1c..424217b9c07 100644
--- a/src/main/resources/liquidbounce_at.cfg
+++ b/src/main/resources/liquidbounce_at.cfg
@@ -149,4 +149,6 @@ public net.minecraft.client.renderer.entity.Render field_76989_e # shadowSize
 
 public net.minecraft.client.Minecraft field_71429_W # leftClickCounter
 
-public net.minecraft.client.renderer.ItemRenderer field_78453_b # itemToRender
\ No newline at end of file
+public net.minecraft.client.renderer.ItemRenderer field_78453_b # itemToRender
+
+public net.minecraft.client.renderer.entity.Render func_110775_a(Lnet/minecraft/entity/Entity;)Lnet/minecraft/util/ResourceLocation; # getEntityTexture
\ No newline at end of file

From 4a4ee024c092cc4a1c49ff2172379ea09e5b5700 Mon Sep 17 00:00:00 2001
From: RtxOP <137506596+RtxOP@users.noreply.github.com>
Date: Sun, 16 Feb 2025 17:57:23 +0000
Subject: [PATCH 03/19] current version

---
 .../ui/client/hud/element/elements/Target.kt  | 40 ++++++++-----------
 .../liquidbounce/utils/render/RenderUtils.kt  |  7 +++-
 2 files changed, 21 insertions(+), 26 deletions(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
index dfdae77f727..01c6ee3c09d 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
@@ -12,17 +12,16 @@ import net.ccbluex.liquidbounce.ui.client.hud.element.ElementInfo
 import net.ccbluex.liquidbounce.ui.font.AWTFontRenderer.Companion.assumeNonVolatile
 import net.ccbluex.liquidbounce.ui.font.Fonts
 import net.ccbluex.liquidbounce.utils.attack.EntityUtils.getHealth
-import net.ccbluex.liquidbounce.utils.render.ColorSettingsFloat
 import net.ccbluex.liquidbounce.utils.render.ColorUtils
 import net.ccbluex.liquidbounce.utils.render.ColorUtils.withAlpha
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.deltaTime
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawHead
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRoundedBorderRect
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRoundedRect
+import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawGradientRect
+import net.ccbluex.liquidbounce.utils.render.RenderUtils.withClipping
 import net.ccbluex.liquidbounce.utils.render.animation.AnimationUtil
-import net.ccbluex.liquidbounce.utils.render.shader.shaders.GradientShader
 import net.ccbluex.liquidbounce.utils.render.shader.shaders.RainbowShader
-import net.ccbluex.liquidbounce.utils.render.toColorArray
 import net.minecraft.client.gui.GuiChat
 import net.minecraft.entity.Entity
 import net.minecraft.entity.EntityLivingBase
@@ -48,11 +47,8 @@ class Target : Element("Target") {
     private val backgroundMode by choices("Background-ColorMode", arrayOf("Custom", "Rainbow"), "Custom")
     private val backgroundColor by color("Background-Color", Color.BLACK.withAlpha(150)) { backgroundMode == "Custom" }
 
-    private val gradientHealthSpeed by float("Health-Gradient-Speed", 1f, 0.5f..10f)
-    private val maxGradientHealthColors by int("Max-Health-Gradient-Colors", 2, 2..MAX_GRADIENT_COLORS)
-    private val gradientHealthColors = ColorSettingsFloat.create(this, "Health-Gradient") { it <= maxGradientHealthColors }
-    private val gradientX by float("Gradient-X", -250F, -2000F..2000F)
-    private val gradientY by float("Gradient-Y", -1000F, -2000F..2000F)
+    private val healthbarColor1 by color("healthBar-Gradient1", Color(3, 65, 252))
+    private val healthbarColor2 by color("healthBar-Gradient2", Color(3, 252, 236))
 
     private val borderMode by choices("Border-ColorMode", arrayOf("Custom", "Rainbow"), "Custom")
     private val borderColor by color("Border-Color", Color.BLACK) { borderMode == "Custom" }
@@ -188,10 +184,6 @@ class Target : Element("Target") {
                 val rainbowX = if (rainbowX == 0f) 0f else 1f / rainbowX
                 val rainbowY = if (rainbowY == 0f) 0f else 1f / rainbowY
 
-                val gradientOffset = System.currentTimeMillis() % 10000 / 10000F
-                val gradientX = if (gradientX == 0f) 0f else 1f / gradientX
-                val gradientY = if (gradientY == 0f) 0f else 1f / gradientY
-
                 glPushMatrix()
 
                 glEnable(GL_BLEND)
@@ -220,6 +212,7 @@ class Target : Element("Target") {
                     val healthBarTotal = (width - 39F).coerceAtLeast(0F)
                     val currentWidth = (easingHealth / maxHealth).coerceIn(0F, 1F) * healthBarTotal
 
+                    // background bar
                     drawRoundedRect(
                         healthBarStart,
                         healthBarTop,
@@ -229,23 +222,22 @@ class Target : Element("Target") {
                         3F,
                     )
 
-                    GradientShader.begin(
-                        true,
-                        gradientX,
-                        gradientY,
-                        gradientHealthColors.toColorArray(maxGradientHealthColors),
-                        gradientHealthSpeed,
-                        gradientOffset
-                    ).use {
+                    // main bar
+                    withClipping(main = {
                         drawRoundedRect(
                             healthBarStart, 
                             healthBarTop, 
                             healthBarStart + currentWidth, 
                             healthBarTop + healthBarHeight, 
-                            0, 
+                            Color.BLACK.rgb, 
                             3F
-                        )
-                    }
+                        )}, toClip = {
+                        drawGradientRect(healthBarStart.toInt(), 
+                            healthBarTop.toInt(), 
+                            healthBarStart.toInt() + currentWidth.toInt(), 
+                            healthBarTop.toInt() + healthBarHeight.toInt(),
+                            healthbarColor1.rgb,
+                            healthbarColor2.rgb, 0f)})
 
                     val healthPercentage = ((easingHealth / maxHealth) * 100).toInt()
                     val percentageText = "$healthPercentage%"
@@ -295,7 +287,7 @@ class Target : Element("Target") {
                                 glTranslatef(centerX1, midY, 0f)
                                 glScalef(f1, f1, f1)
                                 glTranslatef(-centerX1, -midY, 0f)
-                                drawHead(entityTexture, 4, (midY - 16).roundToInt(), 8F, 8F, 8, 8, 32, 32, 64F, 64F, color)
+                                drawHead(entityTexture, 4, (midY - 16).roundToInt(), 8F, 8F, 8, 8, 28, 28, 64F, 64F, color)
                                 glPopMatrix()
                             }
                         }*/
diff --git a/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt b/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
index 26510fc9e9b..78b28474573 100644
--- a/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
@@ -61,7 +61,9 @@ object RenderUtils : MinecraftInstance {
         glStencilMask(1)
         glClear(GL_STENCIL_BUFFER_BIT)
 
+        glColorMask(false, false, false, false)
         main()
+        glColorMask(true, true, true, true)
 
         glStencilFunc(GL_EQUAL, 1, 1)
         glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP)
@@ -75,6 +77,7 @@ object RenderUtils : MinecraftInstance {
         glPopMatrix()
     }
 
+
     fun deltaTimeNormalized(ticks: Int = 1) = (deltaTime safeDivD ticks * 50.0).coerceAtMost(1.0)
 
     private const val CIRCLE_STEPS = 40
@@ -943,9 +946,9 @@ object RenderUtils : MinecraftInstance {
         val buffer = tessellator.worldRenderer
 
         buffer.begin(GL_QUADS, DefaultVertexFormats.POSITION_COLOR)
-        buffer.pos(right.toDouble(), top.toDouble(), zLevel.toDouble()).color(r1, g1, b1, a1).endVertex()
+        buffer.pos(right.toDouble(), top.toDouble(), zLevel.toDouble()).color(r2, g2, b2, a2).endVertex()
         buffer.pos(left.toDouble(), top.toDouble(), zLevel.toDouble()).color(r1, g1, b1, a1).endVertex()
-        buffer.pos(left.toDouble(), bottom.toDouble(), zLevel.toDouble()).color(r2, g2, b2, a2).endVertex()
+        buffer.pos(left.toDouble(), bottom.toDouble(), zLevel.toDouble()).color(r1, g1, b1, a1).endVertex()
         buffer.pos(right.toDouble(), bottom.toDouble(), zLevel.toDouble()).color(r2, g2, b2, a2).endVertex()
         tessellator.draw()
 

From c56d29ad4de7bc2fb91db06ab618fb8b69d8e095 Mon Sep 17 00:00:00 2001
From: RtxOP <137506596+RtxOP@users.noreply.github.com>
Date: Sun, 16 Feb 2025 17:59:09 +0000
Subject: [PATCH 04/19] I edited the comment

---
 .../liquidbounce/ui/client/hud/element/elements/Target.kt       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
index 01c6ee3c09d..6e04041ffa7 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
@@ -257,7 +257,7 @@ class Target : Element("Target") {
                             val entityTexture = renderer.getEntityTexture(target)
 
                             if (entityTexture != null) {
-                                drawHead(entityTexture, 4, 6, 8F, 8F, 8, 8, 32, 32, 64F, 64F)
+                                drawHead(entityTexture, 4, 6, 8F, 8F, 8, 8, 28, 28, 64F, 64F)
                             }
                         }
 

From 5a64746996a9f3562c5d6de0979d1f319c46fc6c Mon Sep 17 00:00:00 2001
From: RtxOP <137506596+RtxOP@users.noreply.github.com>
Date: Sun, 16 Feb 2025 18:18:59 +0000
Subject: [PATCH 05/19] rounded

---
 .../liquidbounce/ui/client/hud/element/elements/Target.kt    | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
index 6e04041ffa7..b7d9df4d0ae 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
@@ -257,7 +257,10 @@ class Target : Element("Target") {
                             val entityTexture = renderer.getEntityTexture(target)
 
                             if (entityTexture != null) {
-                                drawHead(entityTexture, 4, 6, 8F, 8F, 8, 8, 28, 28, 64F, 64F)
+                                withClipping(main = {
+                                    drawRoundedRect(4f, 6f, 28f + 4f, 28f + 6f, Color.BLACK.rgb, 2f)}, 
+                                    toClip = {
+                                drawHead(entityTexture, 4, 6, 8F, 8F, 8, 8, 28, 28, 64F, 64F)})
                             }
                         }
 

From 3e9ee5f03d1782f22335fc25053bc93bb65252b4 Mon Sep 17 00:00:00 2001
From: mems01 <70612656+mems01@users.noreply.github.com>
Date: Sun, 16 Feb 2025 20:25:26 +0200
Subject: [PATCH 06/19] roundedrectradius

---
 .../liquidbounce/ui/client/hud/element/elements/Target.kt     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
index b7d9df4d0ae..472a5afcc61 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
@@ -15,10 +15,10 @@ import net.ccbluex.liquidbounce.utils.attack.EntityUtils.getHealth
 import net.ccbluex.liquidbounce.utils.render.ColorUtils
 import net.ccbluex.liquidbounce.utils.render.ColorUtils.withAlpha
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.deltaTime
+import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawGradientRect
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawHead
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRoundedBorderRect
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRoundedRect
-import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawGradientRect
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.withClipping
 import net.ccbluex.liquidbounce.utils.render.animation.AnimationUtil
 import net.ccbluex.liquidbounce.utils.render.shader.shaders.RainbowShader
@@ -258,7 +258,7 @@ class Target : Element("Target") {
 
                             if (entityTexture != null) {
                                 withClipping(main = {
-                                    drawRoundedRect(4f, 6f, 28f + 4f, 28f + 6f, Color.BLACK.rgb, 2f)}, 
+                                    drawRoundedRect(4f, 6f, 28f + 4f, 28f + 6f, Color.BLACK.rgb, roundedRectRadius)},
                                     toClip = {
                                 drawHead(entityTexture, 4, 6, 8F, 8F, 8, 8, 28, 28, 64F, 64F)})
                             }

From 32f8d7727a680988214a121c2be139f0dad28d0c Mon Sep 17 00:00:00 2001
From: mems01 <70612656+mems01@users.noreply.github.com>
Date: Sun, 16 Feb 2025 20:28:57 +0200
Subject: [PATCH 07/19] colors

---
 .../ui/client/hud/element/elements/Target.kt  | 36 +++++++++++--------
 .../liquidbounce/utils/render/RenderUtils.kt  |  8 +++--
 2 files changed, 27 insertions(+), 17 deletions(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
index 472a5afcc61..d924e797c4c 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
@@ -225,21 +225,26 @@ class Target : Element("Target") {
                     // main bar
                     withClipping(main = {
                         drawRoundedRect(
-                            healthBarStart, 
-                            healthBarTop, 
-                            healthBarStart + currentWidth, 
-                            healthBarTop + healthBarHeight, 
-                            Color.BLACK.rgb, 
+                            healthBarStart,
+                            healthBarTop,
+                            healthBarStart + currentWidth,
+                            healthBarTop + healthBarHeight,
+                            Color.BLACK.rgb,
                             3F
-                        )}, toClip = {
-                        drawGradientRect(healthBarStart.toInt(), 
-                            healthBarTop.toInt(), 
-                            healthBarStart.toInt() + currentWidth.toInt(), 
+                        )
+                    }, toClip = {
+                        drawGradientRect(
+                            healthBarStart.toInt(),
+                            healthBarTop.toInt(),
+                            healthBarStart.toInt() + currentWidth.toInt(),
                             healthBarTop.toInt() + healthBarHeight.toInt(),
                             healthbarColor1.rgb,
-                            healthbarColor2.rgb, 0f)})
+                            healthbarColor2.rgb,
+                            0f
+                        )
+                    })
 
-                    val healthPercentage = ((easingHealth / maxHealth) * 100).toInt()
+                    val healthPercentage = (easingHealth / maxHealth * 100).toInt()
                     val percentageText = "$healthPercentage%"
                     val textWidth = healthFont.getStringWidth(percentageText)
                     val calcX = healthBarStart + currentWidth - textWidth
@@ -258,9 +263,10 @@ class Target : Element("Target") {
 
                             if (entityTexture != null) {
                                 withClipping(main = {
-                                    drawRoundedRect(4f, 6f, 28f + 4f, 28f + 6f, Color.BLACK.rgb, roundedRectRadius)},
-                                    toClip = {
-                                drawHead(entityTexture, 4, 6, 8F, 8F, 8, 8, 28, 28, 64F, 64F)})
+                                    drawRoundedRect(4f, 6f, 28f + 4f, 28f + 6f, Color.BLACK.rgb, roundedRectRadius)
+                                }, toClip = {
+                                    drawHead(entityTexture, 4, 6, 8F, 8F, 8, 8, 28, 28, 64F, 64F, Color.WHITE)
+                                })
                             }
                         }
 
@@ -295,7 +301,7 @@ class Target : Element("Target") {
                             }
                         }*/
 
-                        target.name?.let { 
+                        target.name?.let {
                             titleFont.drawString(it, 36F, 8F, textCustomColor, textShadow)
                         }
                     }
diff --git a/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt b/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
index 78b28474573..3ec4c5e67a4 100644
--- a/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
@@ -1178,13 +1178,17 @@ object RenderUtils : MinecraftInstance {
         width: Int,
         height: Int,
         tileWidth: Float,
-        tileHeight: Float
+        tileHeight: Float,
+        color: Color
     ) {
+        glPushMatrix()
         val texture: ResourceLocation = skin ?: mc.thePlayer.locationSkin
 
-        glColor4f(1F, 1F, 1F, 1F)
+        glColor(color)
         mc.textureManager.bindTexture(texture)
         drawScaledCustomSizeModalRect(x, y, u, v, uWidth, vHeight, width, height, tileWidth, tileHeight)
+        glColor(Color.WHITE)
+        glPopMatrix()
     }
 
     fun drawImage(

From 31d1518492c56541eae471d41de71f7064f46dde Mon Sep 17 00:00:00 2001
From: mems01 <70612656+mems01@users.noreply.github.com>
Date: Sun, 16 Feb 2025 20:43:16 +0200
Subject: [PATCH 08/19] hurttime shrinking colors

---
 .../ui/client/hud/element/elements/Target.kt  | 20 +++++++++++++++++--
 .../liquidbounce/utils/render/ColorUtils.kt   | 11 ++++++++++
 2 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
index d924e797c4c..050c1e6ea46 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
@@ -12,8 +12,10 @@ import net.ccbluex.liquidbounce.ui.client.hud.element.ElementInfo
 import net.ccbluex.liquidbounce.ui.font.AWTFontRenderer.Companion.assumeNonVolatile
 import net.ccbluex.liquidbounce.ui.font.Fonts
 import net.ccbluex.liquidbounce.utils.attack.EntityUtils.getHealth
+import net.ccbluex.liquidbounce.utils.extensions.lerpWith
 import net.ccbluex.liquidbounce.utils.render.ColorUtils
 import net.ccbluex.liquidbounce.utils.render.ColorUtils.withAlpha
+import net.ccbluex.liquidbounce.utils.render.RenderUtils
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.deltaTime
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawGradientRect
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawHead
@@ -88,6 +90,7 @@ class Target : Element("Target") {
         get() = alphaBorder > 0 || alphaBackground > 0 || alphaText > 0
 
     private var delayCounter = 0
+    private var easingHurtTime = 0F
 
     override fun drawElement(): Border {
         val smoothMode = animation == "Smooth"
@@ -127,6 +130,8 @@ class Target : Element("Target") {
                 easingHealth += ((targetHealth - easingHealth) / 2f.pow(10f - fadeSpeed)) * deltaTime
                 easingHealth = easingHealth.coerceIn(0f, maxHealth)
 
+                easingHurtTime = (easingHurtTime..target.hurtTime.toFloat()).lerpWith(RenderUtils.deltaTimeNormalized())
+
                 if (target != lastTarget || abs(easingHealth - targetHealth) < 0.01) {
                     easingHealth = targetHealth
                 }
@@ -261,13 +266,24 @@ class Target : Element("Target") {
                         if (renderer != null) {
                             val entityTexture = renderer.getEntityTexture(target)
 
+                            glPushMatrix()
+                            val scale = 1 - easingHurtTime / 10f
+                            val f1 = (0.7F..1F).lerpWith(scale) * this.scale
+                            val color = ColorUtils.interpolateColor(Color.RED, Color.WHITE, scale)
+                            val centerX1 = (4..32).lerpWith(0.5F)
+                            val midY = (6f..32f).lerpWith(0.5F)
+
+                            glTranslatef(centerX1, midY, 0f)
+                            glScalef(f1, f1, f1)
+                            glTranslatef(-centerX1, -midY, 0f)
                             if (entityTexture != null) {
                                 withClipping(main = {
-                                    drawRoundedRect(4f, 6f, 28f + 4f, 28f + 6f, Color.BLACK.rgb, roundedRectRadius)
+                                    drawRoundedRect(4f, 6f, 32f, 34f, Color.BLACK.rgb, roundedRectRadius)
                                 }, toClip = {
-                                    drawHead(entityTexture, 4, 6, 8F, 8F, 8, 8, 28, 28, 64F, 64F, Color.WHITE)
+                                    drawHead(entityTexture, 4, 6, 8F, 8F, 8, 8, 28, 28, 64F, 64F, color)
                                 })
                             }
+                            glPopMatrix()
                         }
 
                         /*
diff --git a/src/main/java/net/ccbluex/liquidbounce/utils/render/ColorUtils.kt b/src/main/java/net/ccbluex/liquidbounce/utils/render/ColorUtils.kt
index 5a809888afe..a55f3acac65 100644
--- a/src/main/java/net/ccbluex/liquidbounce/utils/render/ColorUtils.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/utils/render/ColorUtils.kt
@@ -123,6 +123,17 @@ object ColorUtils {
         return Color(currentColor.red / 255F, currentColor.green / 255F, currentColor.blue / 255F, alpha)
     }
 
+    fun interpolateColor(start: Color, end: Color, ratio: Float): Color {
+        val t = ratio.coerceIn(0.0f, 1.0f)
+
+        val r = (start.red + (end.red - start.red) * t).toInt()
+        val g = (start.green + (end.green - start.green) * t).toInt()
+        val b = (start.blue + (end.blue - start.blue) * t).toInt()
+        val a = (start.alpha + (end.alpha - start.alpha) * t).toInt()
+
+        return Color(r, g, b, a)
+    }
+
     fun interpolateHSB(startColor: Color, endColor: Color, process: Float): Color {
         val startHSB = Color.RGBtoHSB(startColor.red, startColor.green, startColor.blue, null)
         val endHSB = Color.RGBtoHSB(endColor.red, endColor.green, endColor.blue, null)

From 587b5746c9a6fa52439f8e0e5473a285853a00d6 Mon Sep 17 00:00:00 2001
From: mems01 <70612656+mems01@users.noreply.github.com>
Date: Mon, 17 Feb 2025 01:29:58 +0200
Subject: [PATCH 09/19] hardcoded face positions for sheep/cow/villager

---
 .../ui/client/hud/element/elements/Target.kt  | 109 ++++++++----------
 .../liquidbounce/utils/attack/EntityUtils.kt  |   2 +-
 .../liquidbounce/utils/render/RenderUtils.kt  |  12 +-
 3 files changed, 57 insertions(+), 66 deletions(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
index 050c1e6ea46..6609e0fe2d0 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
@@ -13,6 +13,7 @@ import net.ccbluex.liquidbounce.ui.font.AWTFontRenderer.Companion.assumeNonVolat
 import net.ccbluex.liquidbounce.ui.font.Fonts
 import net.ccbluex.liquidbounce.utils.attack.EntityUtils.getHealth
 import net.ccbluex.liquidbounce.utils.extensions.lerpWith
+import net.ccbluex.liquidbounce.utils.extensions.safeDiv
 import net.ccbluex.liquidbounce.utils.render.ColorUtils
 import net.ccbluex.liquidbounce.utils.render.ColorUtils.withAlpha
 import net.ccbluex.liquidbounce.utils.render.RenderUtils
@@ -27,11 +28,11 @@ import net.ccbluex.liquidbounce.utils.render.shader.shaders.RainbowShader
 import net.minecraft.client.gui.GuiChat
 import net.minecraft.entity.Entity
 import net.minecraft.entity.EntityLivingBase
+import net.minecraft.entity.passive.EntityCow
+import net.minecraft.entity.passive.EntitySheep
+import net.minecraft.entity.passive.EntityVillager
 import org.lwjgl.opengl.GL11.*
 import java.awt.Color
-import java.text.DecimalFormat
-import java.text.DecimalFormatSymbols
-import java.util.*
 import kotlin.math.abs
 import kotlin.math.max
 import kotlin.math.pow
@@ -49,8 +50,8 @@ class Target : Element("Target") {
     private val backgroundMode by choices("Background-ColorMode", arrayOf("Custom", "Rainbow"), "Custom")
     private val backgroundColor by color("Background-Color", Color.BLACK.withAlpha(150)) { backgroundMode == "Custom" }
 
-    private val healthbarColor1 by color("healthBar-Gradient1", Color(3, 65, 252))
-    private val healthbarColor2 by color("healthBar-Gradient2", Color(3, 252, 236))
+    private val healthBarColor1 by color("HealthBar-Gradient1", Color(3, 65, 252))
+    private val healthBarColor2 by color("HealthBar-Gradient2", Color(3, 252, 236))
 
     private val borderMode by choices("Border-ColorMode", arrayOf("Custom", "Rainbow"), "Custom")
     private val borderColor by color("Border-Color", Color.BLACK) { borderMode == "Custom" }
@@ -61,7 +62,7 @@ class Target : Element("Target") {
     private val rainbowY by float("Rainbow-Y", -1000F, -2000F..2000F) { backgroundMode == "Rainbow" }
 
     private val titleFont by font("TitleFont", Fonts.fontSemibold40)
-    private val healthFont by font("healthFont", Fonts.fontRegular30)
+    private val healthFont by font("HealthFont", Fonts.fontRegular30)
     private val textShadow by boolean("TextShadow", false)
 
     private val fadeSpeed by float("FadeSpeed", 2F, 1F..9F)
@@ -72,7 +73,6 @@ class Target : Element("Target") {
     private val animationSpeed by float("AnimationSpeed", 0.2F, 0.05F..1F)
     private val vanishDelay by int("VanishDelay", 300, 0..500)
 
-    private val decimalFormat = DecimalFormat("##0.00", DecimalFormatSymbols(Locale.ENGLISH))
     private var easingHealth = 0F
     private var lastTarget: EntityLivingBase? = null
 
@@ -97,7 +97,11 @@ class Target : Element("Target") {
         val fadeMode = animation == "Fade"
 
         val shouldRender = KillAura.handleEvents() && KillAura.target != null || mc.currentScreen is GuiChat
-        val target = KillAura.target ?: if (delayCounter >= vanishDelay) mc.thePlayer else lastTarget ?: mc.thePlayer
+        val target = KillAura.target ?: if (delayCounter >= vanishDelay && !isRendered) {
+            mc.thePlayer
+        } else {
+            lastTarget ?: mc.thePlayer
+        }
 
         val stringWidth = (40f + (target.name?.let(titleFont::getStringWidth) ?: 0)).coerceAtLeast(118F)
 
@@ -112,22 +116,7 @@ class Target : Element("Target") {
                 val targetHealth = getHealth(target!!, healthFromScoreboard, absorption)
                 val maxHealth = target.maxHealth + if (absorption) target.absorptionAmount else 0F
 
-                val healthColor = when {
-                    targetHealth <= 0 -> Color(255, 0, 0, if (fadeMode) alphaText else textColor.alpha)
-                    else -> {
-                        ColorUtils.interpolateHealthColor(
-                            target,
-                            255,
-                            255,
-                            0,
-                            if (fadeMode) alphaText else textColor.alpha,
-                            healthFromScoreboard,
-                            absorption
-                        )
-                    }
-                }
-
-                easingHealth += ((targetHealth - easingHealth) / 2f.pow(10f - fadeSpeed)) * deltaTime
+                easingHealth += (targetHealth - easingHealth) / 2f.pow(10f - fadeSpeed) * deltaTime
                 easingHealth = easingHealth.coerceIn(0f, maxHealth)
 
                 easingHurtTime = (easingHurtTime..target.hurtTime.toFloat()).lerpWith(RenderUtils.deltaTimeNormalized())
@@ -186,8 +175,8 @@ class Target : Element("Target") {
                 ).rgb
 
                 val rainbowOffset = System.currentTimeMillis() % 10000 / 10000F
-                val rainbowX = if (rainbowX == 0f) 0f else 1f / rainbowX
-                val rainbowY = if (rainbowY == 0f) 0f else 1f / rainbowY
+                val rainbowX = 1f safeDiv rainbowX
+                val rainbowY = 1f safeDiv rainbowY
 
                 glPushMatrix()
 
@@ -243,11 +232,11 @@ class Target : Element("Target") {
                             healthBarTop.toInt(),
                             healthBarStart.toInt() + currentWidth.toInt(),
                             healthBarTop.toInt() + healthBarHeight.toInt(),
-                            healthbarColor1.rgb,
-                            healthbarColor2.rgb,
+                            healthBarColor1.rgb,
+                            healthBarColor2.rgb,
                             0f
                         )
-                    })
+                    }, hide = true)
 
                     val healthPercentage = (easingHealth / maxHealth * 100).toInt()
                     val percentageText = "$healthPercentage%"
@@ -276,47 +265,43 @@ class Target : Element("Target") {
                             glTranslatef(centerX1, midY, 0f)
                             glScalef(f1, f1, f1)
                             glTranslatef(-centerX1, -midY, 0f)
+
+                            val w = when (target) {
+                                is EntitySheep -> 7.5F to 7
+                                is EntityCow -> 6.5F to 7
+                                else -> 8F to 8
+                            }
+
+                            val h = when (target) {
+                                is EntitySheep -> 16F to 11
+                                is EntityVillager -> 9F to 9
+                                is EntityCow -> 15F to 12
+                                else -> 8F to 8
+                            }
+
                             if (entityTexture != null) {
                                 withClipping(main = {
                                     drawRoundedRect(4f, 6f, 32f, 34f, Color.BLACK.rgb, roundedRectRadius)
                                 }, toClip = {
-                                    drawHead(entityTexture, 4, 6, 8F, 8F, 8, 8, 28, 28, 64F, 64F, color)
-                                })
+                                    drawHead(
+                                        entityTexture,
+                                        4,
+                                        6,
+                                        w.first,
+                                        h.first,
+                                        w.second,
+                                        h.second,
+                                        28,
+                                        28,
+                                        64F,
+                                        64F,
+                                        color
+                                    )
+                                }, hide = true)
                             }
                             glPopMatrix()
                         }
 
-                        /*
-
-                        If you decide to make the avatar shrinkable on hit, see the translate and scale code
-
-                        in your case you must find the midpoint X/Y of the avatar position, then do the scaling
-                        but make sure the scaling is within the original element scale, check code below
-                        then after you are done with the scaling, revert back to the original position by translating the positions
-                        against them so it becomes back to 0. push/pop matrix is needed so it only handles the avatar.
-                        just check code below.
-
-                        remove if you know what to do
-
-                        val renderer = mc.renderManager.getEntityRenderObject<Entity>(target)
-                        if (renderer != null) {
-                            val entityTexture = renderer.getEntityTexture(target)
-
-                            if (entityTexture != null) {
-                                glPushMatrix()
-                                val scale = 1 - hurtTime / 10f
-                                val f1 = (0.7F..1F).lerpWith(scale) * this.scale * elementScale
-                                val color = ColorUtils.interpolateColor(Color.RED, Color.WHITE, scale)
-                                val centerX1 = (4..32).lerpWith(0.5F)
-
-                                glTranslatef(centerX1, midY, 0f)
-                                glScalef(f1, f1, f1)
-                                glTranslatef(-centerX1, -midY, 0f)
-                                drawHead(entityTexture, 4, (midY - 16).roundToInt(), 8F, 8F, 8, 8, 28, 28, 64F, 64F, color)
-                                glPopMatrix()
-                            }
-                        }*/
-
                         target.name?.let {
                             titleFont.drawString(it, 36F, 8F, textCustomColor, textShadow)
                         }
diff --git a/src/main/java/net/ccbluex/liquidbounce/utils/attack/EntityUtils.kt b/src/main/java/net/ccbluex/liquidbounce/utils/attack/EntityUtils.kt
index f0fc9245c8f..ff3822af3f0 100644
--- a/src/main/java/net/ccbluex/liquidbounce/utils/attack/EntityUtils.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/utils/attack/EntityUtils.kt
@@ -115,7 +115,7 @@ object EntityUtils : MinecraftInstance {
         if (absorption)
             health += entity.absorptionAmount
 
-        return if (health > 0) health else 20f
+        return if (health >= 0) health else 20f
     }
 
     fun Entity.colorFromDisplayName(): Color? {
diff --git a/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt b/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
index 3ec4c5e67a4..617021b85aa 100644
--- a/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
@@ -50,7 +50,7 @@ object RenderUtils : MinecraftInstance {
     /**
      * Useful for clipping any top-layered rectangle that falls outside a bottom-layered rectangle.
      */
-    inline fun withClipping(main: () -> Unit, toClip: () -> Unit) {
+    inline fun withClipping(main: () -> Unit, toClip: () -> Unit, hide: Boolean = false) {
         disableFastRender()
         OutlineUtils.checkSetupFBO()
         glPushMatrix()
@@ -61,9 +61,15 @@ object RenderUtils : MinecraftInstance {
         glStencilMask(1)
         glClear(GL_STENCIL_BUFFER_BIT)
 
-        glColorMask(false, false, false, false)
+        if (hide) {
+            glColorMask(false, false, false, false)
+        }
+
         main()
-        glColorMask(true, true, true, true)
+
+        if (hide) {
+            glColorMask(true, true, true, true)
+        }
 
         glStencilFunc(GL_EQUAL, 1, 1)
         glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP)

From f4cea3eb7de1ab3a947bb1e830b25267ec4f67f7 Mon Sep 17 00:00:00 2001
From: mems01 <70612656+mems01@users.noreply.github.com>
Date: Mon, 17 Feb 2025 17:20:13 +0200
Subject: [PATCH 10/19] killaura circle gradient colors/button color update

---
 .../module/modules/combat/KillAura.kt         | 12 ++--
 .../forge/mixins/gui/MixinGuiButton.java      | 17 +++--
 .../forge/mixins/gui/MixinGuiButtonExt.java   | 17 +++--
 .../forge/mixins/gui/MixinGuiSlot.java        |  5 +-
 .../liquidbounce/utils/render/RenderUtils.kt  | 66 ++++++++++---------
 5 files changed, 61 insertions(+), 56 deletions(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/features/module/modules/combat/KillAura.kt b/src/main/java/net/ccbluex/liquidbounce/features/module/modules/combat/KillAura.kt
index c78962bbded..e34f8d7be85 100644
--- a/src/main/java/net/ccbluex/liquidbounce/features/module/modules/combat/KillAura.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/features/module/modules/combat/KillAura.kt
@@ -28,7 +28,6 @@ import net.ccbluex.liquidbounce.utils.inventory.ItemUtils.isConsumingItem
 import net.ccbluex.liquidbounce.utils.inventory.SilentHotbar
 import net.ccbluex.liquidbounce.utils.kotlin.RandomUtils.nextInt
 import net.ccbluex.liquidbounce.utils.render.ColorSettingsInteger
-import net.ccbluex.liquidbounce.utils.render.ColorUtils.rainbow
 import net.ccbluex.liquidbounce.utils.render.ColorUtils.withAlpha
 import net.ccbluex.liquidbounce.utils.render.RenderUtils
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawCircle
@@ -294,12 +293,8 @@ object KillAura : Module("KillAura", Category.COMBAT, Keyboard.KEY_R) {
     private val aimPointBoxSize by float("AimPointBoxSize", 0.1f, 0f..0.2F) { renderAimPointBox }.subjective()
 
     // Circle options
-    private val circleRainbow by boolean("CircleRainbow", false) { mark == "Circle" }.subjective()
-
-    // TODO: replace this with color value
-    private val colors = ColorSettingsInteger(
-        this, "CircleColor"
-    ) { mark == "Circle" && !circleRainbow }.with(132, 102, 255, 100)//.subjective()
+    private val circleStartColor by color("CircleStartColor", Color.BLUE) { mark == "Circle" }.subjective()
+    private val circleEndColor by color("CircleEndColor", Color.CYAN.withAlpha(0)) { mark == "Circle" }.subjective()
     private val fillInnerCircle by boolean("FillInnerCircle", false) { mark == "Circle" }.subjective()
     private val withHeight by boolean("WithHeight", true) { mark == "Circle" }.subjective()
     private val animateHeight by boolean("AnimateHeight", false) { withHeight }.subjective()
@@ -549,7 +544,8 @@ object KillAura : Module("KillAura", Category.COMBAT, Keyboard.KEY_R) {
                     fillInnerCircle,
                     withHeight,
                     circleYRange.takeIf { animateCircleY },
-                    if (circleRainbow) rainbow().withAlpha(colors.color().alpha) else colors.color()
+                    circleStartColor.rgb,
+                    circleEndColor.rgb
                 )
             }
         }
diff --git a/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiButton.java b/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiButton.java
index 62f188f5bfc..49072b4b6cc 100644
--- a/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiButton.java
+++ b/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiButton.java
@@ -103,13 +103,16 @@ public void drawButton(Minecraft mc, int mouseX, int mouseY) {
 
             float radius = 2.5F;
 
-            // Draw original
-            RenderUtils.INSTANCE.drawRoundedRect(xPosition, yPosition, xPosition + width, yPosition + height, enabled ? new Color(0F, 0F, 0F, 120 / 255f).getRGB() : new Color(0.5F, 0.5F, 0.5F, 0.5F).getRGB(), radius, RenderUtils.RoundedCorners.ALL);
-
-            if (enabled && progress != xPosition) {
-                // Draw blue overlay
-                RenderUtils.INSTANCE.drawRoundedRect(xPosition, yPosition, progress, yPosition + height, new Color(0F, 0F, 1F, 1F).getRGB(), radius, RenderUtils.RoundedCorners.ALL);
-            }
+            RenderUtils.INSTANCE.withClipping(() -> {
+                RenderUtils.INSTANCE.drawRoundedRect(xPosition, yPosition, xPosition + width, yPosition + height, enabled ? new Color(0F, 0F, 0F, 120 / 255f).getRGB() : new Color(0.5F, 0.5F, 0.5F, 0.5F).getRGB(), radius, RenderUtils.RoundedCorners.ALL);
+                return null;
+            }, () -> {
+                if (enabled && progress != xPosition) {
+                    // Draw blue overlay
+                    RenderUtils.INSTANCE.drawGradientRect(xPosition, yPosition, progress, yPosition + height, Color.CYAN.darker().getRGB(), Color.BLUE.darker().getRGB(), 0F);
+                }
+                return null;
+            }, false);
 
             mc.getTextureManager().bindTexture(buttonTextures);
             mouseDragged(mc, mouseX, mouseY);
diff --git a/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiButtonExt.java b/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiButtonExt.java
index a3447800635..05127975267 100644
--- a/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiButtonExt.java
+++ b/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiButtonExt.java
@@ -76,13 +76,16 @@ public void drawButton(Minecraft mc, int mouseX, int mouseY) {
 
         float radius = 2.5F;
 
-        // Draw original
-        RenderUtils.INSTANCE.drawRoundedRect(xPosition, yPosition, xPosition + width, yPosition + height, enabled ? new Color(0F, 0F, 0F, 120 / 255f).getRGB() : new Color(0.5F, 0.5F, 0.5F, 0.5F).getRGB(), radius, RenderUtils.RoundedCorners.ALL);
-
-        if (enabled && progress != xPosition) {
-            // Draw blue overlay
-            RenderUtils.INSTANCE.drawRoundedRect(xPosition, yPosition, progress, yPosition + height, new Color(0F, 0F, 1F, 1F).getRGB(), radius, RenderUtils.RoundedCorners.ALL);
-        }
+        RenderUtils.INSTANCE.withClipping(() -> {
+            RenderUtils.INSTANCE.drawRoundedRect(xPosition, yPosition, xPosition + width, yPosition + height, enabled ? new Color(0F, 0F, 0F, 120 / 255f).getRGB() : new Color(0.5F, 0.5F, 0.5F, 0.5F).getRGB(), radius, RenderUtils.RoundedCorners.ALL);
+            return null;
+        }, () -> {
+            if (enabled && progress != xPosition) {
+                // Draw blue overlay
+                RenderUtils.INSTANCE.drawGradientRect(xPosition, yPosition, progress, yPosition + height, Color.CYAN.darker().getRGB(), Color.BLUE.darker().getRGB(), 0F);
+            }
+            return null;
+        }, false);
 
         mc.getTextureManager().bindTexture(buttonTextures);
         mouseDragged(mc, mouseX, mouseY);
diff --git a/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiSlot.java b/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiSlot.java
index bdcda16f124..d48d1d761f9 100644
--- a/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiSlot.java
+++ b/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiSlot.java
@@ -256,9 +256,8 @@ private void injectClientDraw(int p_drawSelectionBox_1_, int p_drawSelectionBox_
                 int i1 = this.left + (this.width / 2 - this.getListWidth() / 2);
                 int j1 = this.left + this.width / 2 + this.getListWidth() / 2;
 
-                RenderUtils.INSTANCE.drawRoundedRect(i1 + 2, k, j1 - 1, k + l + 1, new Color(0, 0, 0, 100).getRGB(), 2F, RenderUtils.RoundedCorners.ALL);
-
-                RenderUtils.INSTANCE.drawRoundedBorder(i1 + 2, k + l + 1, j1 - 1, k + l + 1, 3F, Color.BLUE.getRGB(), 0F);
+                RenderUtils.INSTANCE.drawRoundedRect(i1 + 2, k, j1 - 1, k + l + 1, new Color(0, 0, 0, 100).getRGB(), 2F, RenderUtils.RoundedCorners.TOP_ONLY);
+                RenderUtils.INSTANCE.drawGradientRect(i1 + 2, k + l, j1 - 1, k + l + 1.5f, Color.CYAN.getRGB(), Color.BLUE.getRGB(), 0f);
             }
 
             this.drawSlot(j, p_drawSelectionBox_1_, k, l, p_drawSelectionBox_3_, p_drawSelectionBox_4_);
diff --git a/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt b/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
index 617021b85aa..69ab0e90716 100644
--- a/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
@@ -238,10 +238,10 @@ object RenderUtils : MinecraftInstance {
         filled: Boolean,
         withHeight: Boolean,
         circleY: ClosedFloatingPointRange<Float>? = null,
-        color: Color
+        startColor: Int,
+        endColor: Int
     ) {
         val manager = mc.renderManager
-
         val positions = mutableListOf<DoubleArray>()
 
         val renderX = manager.viewerPosX
@@ -254,13 +254,22 @@ object RenderUtils : MinecraftInstance {
         glDisable(GL_TEXTURE_2D)
         glEnable(GL_BLEND)
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
-        glEnable(GL_LINE_SMOOTH)
-        glDisable(GL_DEPTH_TEST)
         glDisable(GL_CULL_FACE)
         glEnable(GL_ALPHA_TEST)
         glAlphaFunc(GL_GREATER, 0.0f)
         mc.entityRenderer.disableLightmap()
 
+        shadeModel(GL_SMOOTH)
+
+        val a1 = (startColor shr 24 and 255) / 255f
+        val r1 = (startColor shr 16 and 255) / 255f
+        val g1 = (startColor shr 8 and 255) / 255f
+        val b1 = (startColor and 255) / 255f
+        val a2 = (endColor shr 24 and 255) / 255f
+        val r2 = (endColor shr 16 and 255) / 255f
+        val g2 = (endColor shr 8 and 255) / 255f
+        val b2 = (endColor and 255) / 255f
+
         val breathingT = AnimationUtil.breathe(speed)
         val entityHeight = (entity.hitBox.maxY - entity.hitBox.minY).toFloat()
 
@@ -268,51 +277,50 @@ object RenderUtils : MinecraftInstance {
         val animatedHeight = (0F..entityHeight).lerpWith(height.lerpWith(breathingT))
         val animatedCircleY = (0F..entityHeight).lerpWith(circleY?.lerpWith(breathingT) ?: 0F)
 
+        val tessellator = Tessellator.getInstance()
+        val buffer = tessellator.worldRenderer
+
         if (filled) {
-            glBegin(GL_TRIANGLE_FAN)
-            glColor(color)
+            buffer.begin(GL_TRIANGLE_FAN, DefaultVertexFormats.POSITION_COLOR)
         }
 
         entity.interpolatedPosition(entity.prevPos).let { pos ->
-            circlePoints.forEach {
+            circlePoints.forEachIndexed { index, it ->
                 val p = pos + Vec3(it.x * width, it.y + animatedCircleY, it.z * width)
-
                 positions += doubleArrayOf(p.xCoord, p.yCoord, p.zCoord)
 
                 if (filled) {
-                    glVertex3d(p.xCoord - renderX, p.yCoord - renderY, p.zCoord - renderZ)
+                    buffer.pos(p.xCoord - renderX, p.yCoord - renderY, p.zCoord - renderZ).color(r1, g1, b1, a1)
+                        .endVertex()
                 }
             }
         }
 
         if (filled) {
-            glEnd()
-            glColor(Color.WHITE)
+            tessellator.draw()
         }
 
         if (withHeight) {
-            glBegin(GL_QUADS)
-            glColor(color)
+            buffer.begin(GL_QUADS, DefaultVertexFormats.POSITION_COLOR)
 
             positions.forEachIndexed { index, pos ->
                 val endPos = positions.getOrNull(index + 1) ?: return@forEachIndexed
 
-                glVertex3d(pos[0] - renderX, pos[1] - renderY, pos[2] - renderZ)
-                glVertex3d(endPos[0] - renderX, endPos[1] - renderY, endPos[2] - renderZ)
-                glVertex3d(endPos[0] - renderX, endPos[1] - renderY + animatedHeight, endPos[2] - renderZ)
-                glVertex3d(pos[0] - renderX, pos[1] - renderY + animatedHeight, pos[2] - renderZ)
+                buffer.pos(pos[0] - renderX, pos[1] - renderY, pos[2] - renderZ).color(r1, g1, b1, a1).endVertex()
+                buffer.pos(endPos[0] - renderX, endPos[1] - renderY, endPos[2] - renderZ).color(r1, g1, b1, a1)
+                    .endVertex()
+                buffer.pos(endPos[0] - renderX, endPos[1] - renderY + animatedHeight, endPos[2] - renderZ)
+                    .color(r2, g2, b2, a2).endVertex()
+                buffer.pos(pos[0] - renderX, pos[1] - renderY + animatedHeight, pos[2] - renderZ).color(r2, g2, b2, a2)
+                    .endVertex()
             }
-
-            glEnd()
-
-            glColor(Color.WHITE)
+            tessellator.draw()
         }
 
-        glEnable(GL_CULL_FACE)
-        glEnable(GL_DEPTH_TEST)
+        shadeModel(GL_FLAT)
         glDisable(GL_ALPHA_TEST)
-        glDisable(GL_LINE_SMOOTH)
         glDisable(GL_BLEND)
+        glEnable(GL_CULL_FACE)
         glEnable(GL_TEXTURE_2D)
         glPopMatrix()
         glPopAttrib()
@@ -346,9 +354,7 @@ object RenderUtils : MinecraftInstance {
             val innerHue = ColorUtils.shiftHue(innerColor, (index / CIRCLE_STEPS).toInt())
             glColor4f(innerHue.red / 255f, innerHue.green / 255f, innerHue.blue / 255f, innerColor.alpha / 255f)
             glVertex3d(
-                position.xCoord - renderX + innerX,
-                position.yCoord - renderY,
-                position.zCoord - renderZ + innerZ
+                position.xCoord - renderX + innerX, position.yCoord - renderY, position.zCoord - renderZ + innerZ
             )
         }
         glEnd()
@@ -361,9 +367,7 @@ object RenderUtils : MinecraftInstance {
             val outerHue = ColorUtils.shiftHue(outerColor, (index / CIRCLE_STEPS).toInt())
             glColor4f(outerHue.red / 255f, outerHue.green / 255f, outerHue.alpha / 255f, outerColor.alpha / 255f)
             glVertex3d(
-                position.xCoord - renderX + outerX,
-                position.yCoord - renderY,
-                position.zCoord - renderZ + outerZ
+                position.xCoord - renderX + outerX, position.yCoord - renderY, position.zCoord - renderZ + outerZ
             )
         }
         glEnd()
@@ -930,7 +934,7 @@ object RenderUtils : MinecraftInstance {
      * @param endColor   the end color
      */
     fun drawGradientRect(
-        left: Int, top: Int, right: Int, bottom: Int, startColor: Int, endColor: Int, zLevel: Float
+        left: Number, top: Number, right: Number, bottom: Number, startColor: Int, endColor: Int, zLevel: Float
     ) {
         val a1 = (startColor shr 24 and 255) / 255f
         val r1 = (startColor shr 16 and 255) / 255f

From c51d0a60420d15b720a5bb27c62c2408e3da7e1a Mon Sep 17 00:00:00 2001
From: mems01 <70612656+mems01@users.noreply.github.com>
Date: Mon, 17 Feb 2025 19:42:32 +0200
Subject: [PATCH 11/19] scoreboardelement code simplified

---
 .../hud/element/elements/ScoreboardElement.kt | 251 +++++++++---------
 1 file changed, 122 insertions(+), 129 deletions(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/ScoreboardElement.kt b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/ScoreboardElement.kt
index c26d29eb2bf..30c413d89f6 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/ScoreboardElement.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/ScoreboardElement.kt
@@ -16,18 +16,20 @@ import net.ccbluex.liquidbounce.ui.font.Fonts
 import net.ccbluex.liquidbounce.ui.font.GameFontRenderer
 import net.ccbluex.liquidbounce.utils.client.ClientUtils.LOGGER
 import net.ccbluex.liquidbounce.utils.extensions.lerpWith
+import net.ccbluex.liquidbounce.utils.kotlin.removeEach
 import net.ccbluex.liquidbounce.utils.render.ColorUtils
 import net.ccbluex.liquidbounce.utils.render.ColorUtils.withAlpha
 import net.ccbluex.liquidbounce.utils.render.RenderUtils
+import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRect
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRoundedRect
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRoundedRectInt
+import net.ccbluex.liquidbounce.utils.render.RenderUtils.withClipping
 import net.minecraft.scoreboard.ScoreObjective
 import net.minecraft.scoreboard.ScorePlayerTeam
 import net.minecraft.util.EnumChatFormatting
 import org.lwjgl.opengl.GL11.glColor4f
 import java.awt.Color
 import kotlin.math.abs
-import kotlin.math.max
 
 /**
  * CustomHUD scoreboard
@@ -38,16 +40,9 @@ import kotlin.math.max
 class ScoreboardElement(
     x: Double = 7.0, y: Double = 100.0, scale: Float = 1F, side: Side = Side(Side.Horizontal.LEFT, Side.Vertical.MIDDLE)
 ) : Element("Scoreboard", x, y, scale, side) {
-
-    private val corners = RenderUtils.RoundedCorners.entries
-    private val options = corners.map { it.displayName }.toTypedArray()
-
     private val textColor by color("TextColor", Color.WHITE)
     private val backgroundColor by color("BackgroundColor", Color.BLACK.withAlpha(128))
     private val roundedRectRadius by float("Rounded-Radius", 3F, 0F..5F)
-    private val bgCornersToRound by choices(
-        "BackgroundCornersToRound", options, RenderUtils.RoundedCorners.ALL.displayName
-    )
 
     private val rect by boolean("Rect", true)
     private val rectColor = color("RectangleColor", Color(0, 111, 255)) { rect }
@@ -56,9 +51,6 @@ class ScoreboardElement(
     private val titleRectColor by color("TitleRectColor", Color.BLACK.withAlpha(128)) { drawRectOnTitle }
     private val titleRectExtraHeight by int("TitleRectExtraHeight", 5, 0..20) { drawRectOnTitle }
     private val rectHeightPadding by int("TitleRectHeightPadding", 0, 0..10) { drawRectOnTitle }
-    private val titleRectCornersToRound by choices(
-        "TitleRectCornersToRound", options, RenderUtils.RoundedCorners.TOP_ONLY.displayName
-    ) { drawRectOnTitle }
 
     private val serverIp by choices("ServerIP", arrayOf("Normal", "None", "Client", "Website"), "Normal")
     private val number by boolean("Number", false)
@@ -111,7 +103,7 @@ class ScoreboardElement(
             }
 
             val maxHeight = scoreCollection.size * fontHeight
-            val l1 = -maxWidth - 3 - if (rect) 3 else 0
+            val l1 = -maxWidth - 3
 
             val inc = if (drawRectOnTitle) titleRectExtraHeight else 0
 
@@ -123,144 +115,145 @@ class ScoreboardElement(
 
             val numberX = maxX - 7
 
-            drawRoundedRectInt(
-                minX,
-                -(4 + inc),
-                maxX,
-                maxHeight + fontHeight + 2,
-                backColor,
-                roundedRectRadius,
-                corners.first { it.displayName == bgCornersToRound })
-
-            scoreCollection.filterNotNull().forEachIndexed { index, score ->
-                val team = scoreboard.getPlayersTeam(score.playerName)
-
-                var name = ScorePlayerTeam.formatPlayerName(team, score.playerName)
-                val scorePoints = if (number) "${EnumChatFormatting.RED}${score.scorePoints}" else ""
-
-                val height = maxHeight - index * fontHeight.toFloat()
-
-                glColor4f(1f, 1f, 1f, 1f)
-
-                if (serverIp != "Normal") {
-                    try {
-                        val nameWithoutFormatting = name?.replace(EnumChatFormatting.RESET.toString(), "")
-                            ?.replace(Regex("[\u00a7&][0-9a-fk-or]"), "")?.trim()
-                        val trimmedServerIP = mc.currentServerData?.serverIP?.trim()?.lowercase() ?: ""
-
-                        val domainRegex =
-                            Regex("\\b(?:[a-zA-Z0-9](?:[a-zA-Z0-9\\-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]{2,63}\\b")
-                        val containsDomain = nameWithoutFormatting?.let { domainRegex.containsMatchIn(it) } == true
-
-                        runCatching {
-                            if (nameWithoutFormatting?.lowercase() == trimmedServerIP || containsDomain) {
-                                val colorCode = name?.substring(0, 2) ?: "§9"
-                                name = when (serverIp.lowercase()) {
-                                    "none" -> ""
-                                    "client" -> "$colorCode$CLIENT_NAME"
-                                    "website" -> "$colorCode$CLIENT_WEBSITE"
-                                    else -> return null
-                                }
-                            }
-                        }.onFailure {
-                            LOGGER.error("Error while changing Scoreboard Server IP: ${it.message}")
-                        }
-                    } catch (e: Exception) {
-                        LOGGER.error("Error while drawing ScoreboardElement", e)
-                    }
-                }
+            val indexRects = mutableListOf<() -> Unit>()
 
-                val textX = if (side.horizontal != Side.Horizontal.LEFT) {
-                    l1
+            withClipping(main = {
+                val corners = if (rect) {
+                    if (side.horizontal != Side.Horizontal.LEFT) {
+                        RenderUtils.RoundedCorners.LEFT_ONLY
+                    } else {
+                        RenderUtils.RoundedCorners.RIGHT_ONLY
+                    }
                 } else {
-                    minX + 4 + if (rect) 4 else 0
-                }.toFloat()
-
-                fontRenderer.drawString(name, textX, height, textColor, shadow)
-                if (number) {
-                    fontRenderer.drawString(
-                        scorePoints,
-                        (numberX - font.getStringWidth(scorePoints)).toFloat(),
-                        height,
-                        textColor,
-                        shadow
-                    )
+                    RenderUtils.RoundedCorners.ALL
                 }
 
-                if (index == scoreCollection.size - 1) {
-                    val title = objective.displayName ?: ""
-                    val displayName = if (serverIp != "Normal") {
+                drawRoundedRectInt(minX, -(4 + inc), maxX, maxHeight + fontHeight + 2, backColor, roundedRectRadius, corners)
+            }, toClip = {
+                scoreCollection.filterNotNull().forEachIndexed { index, score ->
+                    val team = scoreboard.getPlayersTeam(score.playerName)
+
+                    var name = ScorePlayerTeam.formatPlayerName(team, score.playerName)
+                    val scorePoints = if (number) "${EnumChatFormatting.RED}${score.scorePoints}" else ""
+
+                    val height = maxHeight - index * fontHeight.toFloat()
+
+                    glColor4f(1f, 1f, 1f, 1f)
+
+                    if (serverIp != "Normal") {
                         try {
-                            val nameWithoutFormatting = title.replace(EnumChatFormatting.RESET.toString(), "")
-                                .replace(Regex("[\u00a7&][0-9a-fk-or]"), "").trim()
+                            val nameWithoutFormatting = name?.replace(EnumChatFormatting.RESET.toString(), "")
+                                ?.replace(Regex("[\u00a7&][0-9a-fk-or]"), "")?.trim()
                             val trimmedServerIP = mc.currentServerData?.serverIP?.trim()?.lowercase() ?: ""
 
                             val domainRegex =
                                 Regex("\\b(?:[a-zA-Z0-9](?:[a-zA-Z0-9\\-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]{2,63}\\b")
-                            val containsDomain = nameWithoutFormatting.let { domainRegex.containsMatchIn(it) } == true
-
-                            if (nameWithoutFormatting.lowercase() == trimmedServerIP || containsDomain) {
-                                val colorCode = title.substring(0, 2)
-                                when (serverIp.lowercase()) {
-                                    "none" -> ""
-                                    "client" -> "$colorCode$CLIENT_NAME"
-                                    "website" -> "$colorCode$CLIENT_WEBSITE"
-                                    else -> return null
+                            val containsDomain = nameWithoutFormatting?.let { domainRegex.containsMatchIn(it) } == true
+
+                            runCatching {
+                                if (nameWithoutFormatting?.lowercase() == trimmedServerIP || containsDomain) {
+                                    val colorCode = name?.substring(0, 2) ?: "§9"
+                                    name = when (serverIp.lowercase()) {
+                                        "none" -> ""
+                                        "client" -> "$colorCode$CLIENT_NAME"
+                                        "website" -> "$colorCode$CLIENT_WEBSITE"
+                                        else -> return null
+                                    }
                                 }
-                            } else title
+                            }.onFailure {
+                                LOGGER.error("Error while changing Scoreboard Server IP: ${it.message}")
+                            }
                         } catch (e: Exception) {
                             LOGGER.error("Error while drawing ScoreboardElement", e)
-                            title
                         }
-                    } else title
-
-                    if (drawRectOnTitle) {
-                        drawRoundedRectInt(
-                            minX,
-                            -(4 + inc),
-                            maxX,
-                            fontHeight - inc + rectHeightPadding,
-                            titleRectColor.rgb,
-                            roundedRectRadius,
-                            corners.first { it.displayName == titleRectCornersToRound })
                     }
 
-                    glColor4f(1f, 1f, 1f, 1f)
+                    val textX = if (side.horizontal != Side.Horizontal.LEFT) {
+                        l1
+                    } else {
+                        minX + 4
+                    }.toFloat()
+
+                    fontRenderer.drawString(name, textX, height, textColor, shadow)
+                    if (number) {
+                        fontRenderer.drawString(
+                            scorePoints,
+                            (numberX - font.getStringWidth(scorePoints)).toFloat(),
+                            height,
+                            textColor,
+                            shadow
+                        )
+                    }
 
-                    fontRenderer.drawString(
-                        displayName,
-                        (minX..maxX).lerpWith(0.5F) - fontRenderer.getStringWidth(displayName) / 2,
-                        height - fontHeight - inc,
-                        textColor,
-                        shadow
-                    )
-                }
+                    if (index == scoreCollection.size - 1) {
+                        val title = objective.displayName ?: ""
+                        val displayName = if (serverIp != "Normal") {
+                            try {
+                                val nameWithoutFormatting = title.replace(EnumChatFormatting.RESET.toString(), "")
+                                    .replace(Regex("[\u00a7&][0-9a-fk-or]"), "").trim()
+                                val trimmedServerIP = mc.currentServerData?.serverIP?.trim()?.lowercase() ?: ""
+
+                                val domainRegex =
+                                    Regex("\\b(?:[a-zA-Z0-9](?:[a-zA-Z0-9\\-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]{2,63}\\b")
+                                val containsDomain =
+                                    nameWithoutFormatting.let { domainRegex.containsMatchIn(it) } == true
+
+                                if (nameWithoutFormatting.lowercase() == trimmedServerIP || containsDomain) {
+                                    val colorCode = title.substring(0, 2)
+                                    when (serverIp.lowercase()) {
+                                        "none" -> ""
+                                        "client" -> "$colorCode$CLIENT_NAME"
+                                        "website" -> "$colorCode$CLIENT_WEBSITE"
+                                        else -> return null
+                                    }
+                                } else title
+                            } catch (e: Exception) {
+                                LOGGER.error("Error while drawing ScoreboardElement", e)
+                                title
+                            }
+                        } else title
+
+                        if (drawRectOnTitle) {
+                            drawRect(minX, -(4 + inc), maxX, fontHeight - inc + rectHeightPadding, titleRectColor.rgb)
+                        }
+
+                        glColor4f(1f, 1f, 1f, 1f)
 
-                if (rect) {
-                    val rectColor = when {
-                        this.rectColor.rainbow -> ColorUtils.rainbow(400000000L * index).rgb
-                        else -> this.rectColor.selectedColor().rgb
+                        fontRenderer.drawString(
+                            displayName,
+                            (minX..maxX).lerpWith(0.5F) - fontRenderer.getStringWidth(displayName) / 2,
+                            height - fontHeight - inc,
+                            textColor,
+                            shadow
+                        )
                     }
 
-                    drawRoundedRect(
-                        (if (side.horizontal != Side.Horizontal.LEFT) maxX else minX).toFloat(),
-                        (if (index == scoreCollection.size - 1) -2F else height) - inc - 2F,
-                        if (side.horizontal != Side.Horizontal.LEFT) {
-                            maxX - max(roundedRectRadius, 3f)
-                        } else {
-                            minX + max(roundedRectRadius, 3f)
-                        },
-                        (if (index == 0) fontHeight.toFloat() else height + fontHeight * 2F) + 2F,
-                        rectColor,
-                        roundedRectRadius,
-                        if (side.horizontal != Side.Horizontal.LEFT) {
-                            RenderUtils.RoundedCorners.RIGHT_ONLY
-                        } else {
-                            RenderUtils.RoundedCorners.LEFT_ONLY
+                    indexRects += {
+                        if (rect) {
+                            val rectColor = when {
+                                this.rectColor.rainbow -> ColorUtils.rainbow(400000000L * index).rgb
+                                else -> this.rectColor.selectedColor().rgb
+                            }
+
+                            drawRoundedRect(
+                                (if (side.horizontal != Side.Horizontal.LEFT) maxX + 5 else minX - 5).toFloat(),
+                                (if (index == scoreCollection.size - 1) -2F else height) - inc - 2F,
+                                (if (side.horizontal != Side.Horizontal.LEFT) maxX else minX).toFloat(),
+                                (if (index == 0) fontHeight.toFloat() else height + fontHeight * 2F) + 2F,
+                                rectColor,
+                                roundedRectRadius,
+                                if (side.horizontal != Side.Horizontal.LEFT) {
+                                    RenderUtils.RoundedCorners.RIGHT_ONLY
+                                } else {
+                                    RenderUtils.RoundedCorners.LEFT_ONLY
+                                }
+                            )
                         }
-                    )
+                    }
                 }
-            }
+            })
+
+            indexRects.removeEach { it(); true }
 
             return Border(minX.toFloat(), -4F - inc, maxX.toFloat(), maxHeight + fontHeight + 2F)
         }

From 404496e9d5e34f44582c3f7d5dea244be4eb3ab6 Mon Sep 17 00:00:00 2001
From: mems01 <70612656+mems01@users.noreply.github.com>
Date: Mon, 17 Feb 2025 21:18:33 +0200
Subject: [PATCH 12/19] fixed alpha transparency issue

---
 .../forge/mixins/gui/MixinGuiButton.java      |   2 +-
 .../forge/mixins/gui/MixinGuiButtonExt.java   |   2 +-
 .../ui/client/hud/element/elements/TabGUI.kt  | 120 +++++++-----------
 .../ui/client/hud/element/elements/Target.kt  |  46 ++-----
 .../liquidbounce/utils/render/RenderUtils.kt  |  14 +-
 5 files changed, 63 insertions(+), 121 deletions(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiButton.java b/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiButton.java
index 49072b4b6cc..f4215eb4503 100644
--- a/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiButton.java
+++ b/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiButton.java
@@ -112,7 +112,7 @@ public void drawButton(Minecraft mc, int mouseX, int mouseY) {
                     RenderUtils.INSTANCE.drawGradientRect(xPosition, yPosition, progress, yPosition + height, Color.CYAN.darker().getRGB(), Color.BLUE.darker().getRGB(), 0F);
                 }
                 return null;
-            }, false);
+            });
 
             mc.getTextureManager().bindTexture(buttonTextures);
             mouseDragged(mc, mouseX, mouseY);
diff --git a/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiButtonExt.java b/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiButtonExt.java
index 05127975267..72e859e3ed1 100644
--- a/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiButtonExt.java
+++ b/src/main/java/net/ccbluex/liquidbounce/injection/forge/mixins/gui/MixinGuiButtonExt.java
@@ -85,7 +85,7 @@ public void drawButton(Minecraft mc, int mouseX, int mouseY) {
                 RenderUtils.INSTANCE.drawGradientRect(xPosition, yPosition, progress, yPosition + height, Color.CYAN.darker().getRGB(), Color.BLUE.darker().getRGB(), 0F);
             }
             return null;
-        }, false);
+        });
 
         mc.getTextureManager().bindTexture(buttonTextures);
         mouseDragged(mc, mouseX, mouseY);
diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/TabGUI.kt b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/TabGUI.kt
index 3ffbd3c1cbb..f6b0c4cb866 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/TabGUI.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/TabGUI.kt
@@ -5,7 +5,6 @@
  */
 package net.ccbluex.liquidbounce.ui.client.hud.element.elements
 
-import net.ccbluex.liquidbounce.LiquidBounce.moduleManager
 import net.ccbluex.liquidbounce.features.module.Category
 import net.ccbluex.liquidbounce.features.module.Module
 import net.ccbluex.liquidbounce.features.module.ModuleManager
@@ -19,9 +18,10 @@ import net.ccbluex.liquidbounce.utils.render.ColorUtils.withAlpha
 import net.ccbluex.liquidbounce.utils.render.RenderUtils
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.deltaTime
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawImage
+import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRect
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRoundedBorder
 import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRoundedRect
-import net.ccbluex.liquidbounce.utils.render.RenderUtils.drawRoundedRect2
+import net.ccbluex.liquidbounce.utils.render.RenderUtils.withClipping
 import net.ccbluex.liquidbounce.utils.render.shader.shaders.RainbowShader
 import net.minecraft.client.gui.FontRenderer
 import net.minecraft.util.ResourceLocation
@@ -133,61 +133,37 @@ class TabGUI(x: Double = 16.0, y: Double = 43.0) : Element("TabGUI", x = x, y =
         }
 
         AWTFontRenderer.assumeNonVolatile {
-            drawRoundedRect(
-                2F, 0F, widthWithPadding, guiHeight, bgColor.rgb, roundedRectRadius, if (displayIcons) {
-                    corners[if (side.horizontal != Side.Horizontal.RIGHT) 0 else 1]
-                } else {
-                    RenderUtils.RoundedCorners.ALL
-                }
-            )
-            if (displayIcons) {
-                drawRoundedRect(
-                    iconSideX.first,
-                    0F,
-                    iconSideX.second,
-                    guiHeight,
-                    iconRectColor.rgb,
-                    roundedRectRadius,
-                    corners[if (side.horizontal != Side.Horizontal.RIGHT) 1 else 0]
-                )
-            }
-
             val rectColor = if (rectRainbow) Color.black else rectColor.selectedColor()
 
-            RainbowShader.begin(
-                rectRainbow,
-                if (rainbowX == 0f) 0f else 1f / rainbowX,
-                if (rainbowY == 0f) 0f else 1f / rainbowY,
-                System.currentTimeMillis() % 10000 / 10000F
-            ).use {
-                val cornerToRound = when (selectedCategory) {
-                    0 -> if (displayIcons) {
-                        if (side.horizontal != Side.Horizontal.RIGHT) {
-                            RenderUtils.RoundedCorners.TOP_RIGHT_ONLY
-                        } else {
-                            RenderUtils.RoundedCorners.TOP_LEFT_ONLY
-                        }
-                    } else {
-                        RenderUtils.RoundedCorners.TOP_ONLY
-                    }
-
-                    tabs.lastIndex -> if (displayIcons) {
-                        if (side.horizontal != Side.Horizontal.RIGHT) {
-                            RenderUtils.RoundedCorners.BOTTOM_RIGHT_ONLY
-                        } else {
-                            RenderUtils.RoundedCorners.BOTTOM_LEFT_ONLY
-                        }
+            withClipping(main = {
+                drawRoundedRect(
+                    2F, 0F, widthWithPadding, guiHeight, bgColor.rgb, roundedRectRadius, if (displayIcons) {
+                        corners[if (side.horizontal != Side.Horizontal.RIGHT) 0 else 1]
                     } else {
-                        RenderUtils.RoundedCorners.BOTTOM_ONLY
+                        RenderUtils.RoundedCorners.ALL
                     }
-
-                    else -> RenderUtils.RoundedCorners.NONE
-                }
-
-                drawRoundedRect2(
-                    2F, 1 + tabY - 1, widthWithPadding, tabY + tabHeight, rectColor, roundedRectRadius, cornerToRound
                 )
-            }
+                if (displayIcons) {
+                    drawRoundedRect(
+                        iconSideX.first,
+                        0F,
+                        iconSideX.second,
+                        guiHeight,
+                        iconRectColor.rgb,
+                        roundedRectRadius,
+                        corners[if (side.horizontal != Side.Horizontal.RIGHT) 1 else 0]
+                    )
+                }
+            }, toClip = {
+                RainbowShader.begin(
+                    rectRainbow,
+                    if (rainbowX == 0f) 0f else 1f / rainbowX,
+                    if (rainbowY == 0f) 0f else 1f / rainbowY,
+                    System.currentTimeMillis() % 10000 / 10000F
+                ).use {
+                    drawRect(2F, 1 + tabY - 1, widthWithPadding, tabY + tabHeight, rectColor)
+                }
+            })
 
             glColor4f(1f, 1f, 1f, 1f)
 
@@ -402,30 +378,26 @@ class TabGUI(x: Double = 16.0, y: Double = 43.0) : Element("TabGUI", x = x, y =
 
             val menuHeight = modules.size * tabHeight
 
-            drawRoundedRect(x - 1F, y - 1F, x + menuWidth - 2F, y + menuHeight - 1F, backgroundColor, roundedRectRadius)
-
-            RainbowShader.begin(
-                rectRainbow,
-                if (rainbowX == 0f) 0f else 1f / rainbowX,
-                if (rainbowY == 0f) 0f else 1f / rainbowY,
-                System.currentTimeMillis() % 10000 / 10000F
-            ).use {
-                val cornerToRound = when (selectedModule) {
-                    0 -> RenderUtils.RoundedCorners.TOP_ONLY
-                    tabs[selectedCategory].modules.lastIndex -> RenderUtils.RoundedCorners.BOTTOM_ONLY
-                    else -> RenderUtils.RoundedCorners.NONE
-                }
-
+            withClipping(main = {
                 drawRoundedRect(
-                    x - if (borderValue) 0 else 1,
-                    y + itemY - 1,
-                    x + menuWidth - 2F,
-                    y + itemY + tabHeight - 1,
-                    color,
-                    roundedRectRadius,
-                    cornerToRound
+                    x - 1F, y - 1F, x + menuWidth - 2F, y + menuHeight - 1F, backgroundColor, roundedRectRadius
                 )
-            }
+            }, toClip = {
+                RainbowShader.begin(
+                    rectRainbow,
+                    if (rainbowX == 0f) 0f else 1f / rainbowX,
+                    if (rainbowY == 0f) 0f else 1f / rainbowY,
+                    System.currentTimeMillis() % 10000 / 10000F
+                ).use {
+                    drawRect(
+                        x - if (borderValue) 0 else 1,
+                        y + itemY - 1,
+                        x + menuWidth - 2F,
+                        y + itemY + tabHeight - 1,
+                        color
+                    )
+                }
+            })
 
             glColor4f(1f, 1f, 1f, 1f)
 
diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
index 6609e0fe2d0..4013c658fa7 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
@@ -28,9 +28,7 @@ import net.ccbluex.liquidbounce.utils.render.shader.shaders.RainbowShader
 import net.minecraft.client.gui.GuiChat
 import net.minecraft.entity.Entity
 import net.minecraft.entity.EntityLivingBase
-import net.minecraft.entity.passive.EntityCow
-import net.minecraft.entity.passive.EntitySheep
-import net.minecraft.entity.passive.EntityVillager
+import net.minecraft.entity.player.EntityPlayer
 import org.lwjgl.opengl.GL11.*
 import java.awt.Color
 import kotlin.math.abs
@@ -96,8 +94,10 @@ class Target : Element("Target") {
         val smoothMode = animation == "Smooth"
         val fadeMode = animation == "Fade"
 
-        val shouldRender = KillAura.handleEvents() && KillAura.target != null || mc.currentScreen is GuiChat
-        val target = KillAura.target ?: if (delayCounter >= vanishDelay && !isRendered) {
+        val killAuraTarget = KillAura.target?.takeIf { it is EntityPlayer }
+
+        val shouldRender = KillAura.handleEvents() && killAuraTarget != null || mc.currentScreen is GuiChat
+        val target = killAuraTarget ?: if (delayCounter >= vanishDelay && !isRendered) {
             mc.thePlayer
         } else {
             lastTarget ?: mc.thePlayer
@@ -223,7 +223,7 @@ class Target : Element("Target") {
                             healthBarTop,
                             healthBarStart + currentWidth,
                             healthBarTop + healthBarHeight,
-                            Color.BLACK.rgb,
+                            0,
                             3F
                         )
                     }, toClip = {
@@ -236,7 +236,7 @@ class Target : Element("Target") {
                             healthBarColor2.rgb,
                             0f
                         )
-                    }, hide = true)
+                    })
 
                     val healthPercentage = (easingHealth / maxHealth * 100).toInt()
                     val percentageText = "$healthPercentage%"
@@ -266,38 +266,12 @@ class Target : Element("Target") {
                             glScalef(f1, f1, f1)
                             glTranslatef(-centerX1, -midY, 0f)
 
-                            val w = when (target) {
-                                is EntitySheep -> 7.5F to 7
-                                is EntityCow -> 6.5F to 7
-                                else -> 8F to 8
-                            }
-
-                            val h = when (target) {
-                                is EntitySheep -> 16F to 11
-                                is EntityVillager -> 9F to 9
-                                is EntityCow -> 15F to 12
-                                else -> 8F to 8
-                            }
-
                             if (entityTexture != null) {
                                 withClipping(main = {
-                                    drawRoundedRect(4f, 6f, 32f, 34f, Color.BLACK.rgb, roundedRectRadius)
+                                    drawRoundedRect(4f, 6f, 32f, 34f, 0, roundedRectRadius)
                                 }, toClip = {
-                                    drawHead(
-                                        entityTexture,
-                                        4,
-                                        6,
-                                        w.first,
-                                        h.first,
-                                        w.second,
-                                        h.second,
-                                        28,
-                                        28,
-                                        64F,
-                                        64F,
-                                        color
-                                    )
-                                }, hide = true)
+                                    drawHead(entityTexture, 4, 6, 8f, 8f, 8, 8, 28, 28, 64F, 64F, color)
+                                })
                             }
                             glPopMatrix()
                         }
diff --git a/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt b/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
index 69ab0e90716..6bf7d973532 100644
--- a/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
@@ -50,27 +50,21 @@ object RenderUtils : MinecraftInstance {
     /**
      * Useful for clipping any top-layered rectangle that falls outside a bottom-layered rectangle.
      */
-    inline fun withClipping(main: () -> Unit, toClip: () -> Unit, hide: Boolean = false) {
+    inline fun withClipping(main: () -> Unit, toClip: () -> Unit) {
         disableFastRender()
         OutlineUtils.checkSetupFBO()
         glPushMatrix()
 
+        glDisable(GL_ALPHA_TEST)
+
         glEnable(GL_STENCIL_TEST)
         glStencilFunc(GL_ALWAYS, 1, 1)
         glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE)
         glStencilMask(1)
         glClear(GL_STENCIL_BUFFER_BIT)
 
-        if (hide) {
-            glColorMask(false, false, false, false)
-        }
-
         main()
 
-        if (hide) {
-            glColorMask(true, true, true, true)
-        }
-
         glStencilFunc(GL_EQUAL, 1, 1)
         glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP)
         glStencilMask(0)
@@ -80,6 +74,8 @@ object RenderUtils : MinecraftInstance {
         glStencilMask(0xFF)
         glDisable(GL_STENCIL_TEST)
 
+        glEnable(GL_ALPHA_TEST)
+
         glPopMatrix()
     }
 

From d0b801ae6854d3c190a170b1fdb30e0a5c830339 Mon Sep 17 00:00:00 2001
From: mems01 <70612656+mems01@users.noreply.github.com>
Date: Mon, 17 Feb 2025 21:53:37 +0200
Subject: [PATCH 13/19] fixed scoreboardelement rect width borders

---
 .../hud/element/elements/ScoreboardElement.kt    | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/ScoreboardElement.kt b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/ScoreboardElement.kt
index 30c413d89f6..a848311d1e2 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/ScoreboardElement.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/ScoreboardElement.kt
@@ -103,7 +103,7 @@ class ScoreboardElement(
             }
 
             val maxHeight = scoreCollection.size * fontHeight
-            val l1 = -maxWidth - 3
+            val l1 = -maxWidth  - 3
 
             val inc = if (drawRectOnTitle) titleRectExtraHeight else 0
 
@@ -128,7 +128,15 @@ class ScoreboardElement(
                     RenderUtils.RoundedCorners.ALL
                 }
 
-                drawRoundedRectInt(minX, -(4 + inc), maxX, maxHeight + fontHeight + 2, backColor, roundedRectRadius, corners)
+                drawRoundedRectInt(
+                    minX,
+                    -(4 + inc),
+                    maxX,
+                    maxHeight + fontHeight + 2,
+                    backColor,
+                    roundedRectRadius,
+                    corners
+                )
             }, toClip = {
                 scoreCollection.filterNotNull().forEachIndexed { index, score ->
                     val team = scoreboard.getPlayersTeam(score.playerName)
@@ -236,7 +244,7 @@ class ScoreboardElement(
                             }
 
                             drawRoundedRect(
-                                (if (side.horizontal != Side.Horizontal.LEFT) maxX + 5 else minX - 5).toFloat(),
+                                (if (side.horizontal != Side.Horizontal.LEFT) maxX + 4 else minX - 4).toFloat(),
                                 (if (index == scoreCollection.size - 1) -2F else height) - inc - 2F,
                                 (if (side.horizontal != Side.Horizontal.LEFT) maxX else minX).toFloat(),
                                 (if (index == 0) fontHeight.toFloat() else height + fontHeight * 2F) + 2F,
@@ -255,7 +263,7 @@ class ScoreboardElement(
 
             indexRects.removeEach { it(); true }
 
-            return Border(minX.toFloat(), -4F - inc, maxX.toFloat(), maxHeight + fontHeight + 2F)
+            return Border(minX.toFloat() - if (rect && side.horizontal == Side.Horizontal.LEFT) 5 else 0, -4F - inc, maxX.toFloat() + if (rect && side.horizontal != Side.Horizontal.LEFT) 5 else 0, maxHeight + fontHeight + 2F)
         }
 
         return null

From f1df7390cd1fa755cbacfa3169555906e968cfe1 Mon Sep 17 00:00:00 2001
From: mems01 <70612656+mems01@users.noreply.github.com>
Date: Mon, 17 Feb 2025 22:26:50 +0200
Subject: [PATCH 14/19] default x

---
 .../ui/client/hud/element/elements/ScoreboardElement.kt         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/ScoreboardElement.kt b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/ScoreboardElement.kt
index a848311d1e2..3f63a65e68b 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/ScoreboardElement.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/ScoreboardElement.kt
@@ -38,7 +38,7 @@ import kotlin.math.abs
  */
 @ElementInfo(name = "Scoreboard")
 class ScoreboardElement(
-    x: Double = 7.0, y: Double = 100.0, scale: Float = 1F, side: Side = Side(Side.Horizontal.LEFT, Side.Vertical.MIDDLE)
+    x: Double = 11.0, y: Double = 100.0, scale: Float = 1F, side: Side = Side(Side.Horizontal.LEFT, Side.Vertical.MIDDLE)
 ) : Element("Scoreboard", x, y, scale, side) {
     private val textColor by color("TextColor", Color.WHITE)
     private val backgroundColor by color("BackgroundColor", Color.BLACK.withAlpha(128))

From fb83ae6741c95a4acb091843d0273ff6bddb99e0 Mon Sep 17 00:00:00 2001
From: mems01 <70612656+mems01@users.noreply.github.com>
Date: Tue, 18 Feb 2025 03:30:10 +0200
Subject: [PATCH 15/19] upside down height range

---
 .../java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt b/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
index 6bf7d973532..53c1ee62bac 100644
--- a/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
@@ -270,7 +270,7 @@ object RenderUtils : MinecraftInstance {
         val entityHeight = (entity.hitBox.maxY - entity.hitBox.minY).toFloat()
 
         val width = (mc.renderManager.getEntityRenderObject<Entity>(entity)?.shadowSize ?: 0.5F) + size
-        val animatedHeight = (0F..entityHeight).lerpWith(height.lerpWith(breathingT))
+        val animatedHeight = (0F..entityHeight).lerpWith((height.endInclusive..height.start).lerpWith(breathingT))
         val animatedCircleY = (0F..entityHeight).lerpWith(circleY?.lerpWith(breathingT) ?: 0F)
 
         val tessellator = Tessellator.getInstance()

From 4a531daf0f7a2beeb7db1b387ace17929b02cc79 Mon Sep 17 00:00:00 2001
From: mems01 <70612656+mems01@users.noreply.github.com>
Date: Tue, 18 Feb 2025 04:54:07 +0200
Subject: [PATCH 16/19] make use of depth test on circle

---
 .../liquidbounce/utils/render/RenderUtils.kt  | 40 ++++++++++++++-----
 1 file changed, 30 insertions(+), 10 deletions(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt b/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
index 53c1ee62bac..b726b7b4f1a 100644
--- a/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/utils/render/RenderUtils.kt
@@ -252,6 +252,7 @@ object RenderUtils : MinecraftInstance {
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
         glDisable(GL_CULL_FACE)
         glEnable(GL_ALPHA_TEST)
+        glDepthMask(false)
         glAlphaFunc(GL_GREATER, 0.0f)
         mc.entityRenderer.disableLightmap()
 
@@ -317,6 +318,7 @@ object RenderUtils : MinecraftInstance {
         glDisable(GL_ALPHA_TEST)
         glDisable(GL_BLEND)
         glEnable(GL_CULL_FACE)
+        glDepthMask(true)
         glEnable(GL_TEXTURE_2D)
         glPopMatrix()
         glPopAttrib()
@@ -1047,16 +1049,34 @@ object RenderUtils : MinecraftInstance {
     }
 
     enum class RoundedCorners(val corners: Set<Corner>, val displayName: String) {
-        NONE(emptySet(), "None"),
-        TOP_LEFT_ONLY(setOf(Corner.TOP_LEFT), "Top-Left-Only"),
-        TOP_RIGHT_ONLY(setOf(Corner.TOP_RIGHT), "Top-Right-Only"),
-        BOTTOM_LEFT_ONLY(setOf(Corner.BOTTOM_LEFT), "Bottom-Left-Only"),
-        BOTTOM_RIGHT_ONLY(setOf(Corner.BOTTOM_RIGHT), "Bottom-Right-Only"),
-        TOP_ONLY(setOf(Corner.TOP_LEFT, Corner.TOP_RIGHT), "Top-Only"),
-        BOTTOM_ONLY(setOf(Corner.BOTTOM_LEFT, Corner.BOTTOM_RIGHT), "Bottom-Only"),
-        LEFT_ONLY(setOf(Corner.TOP_LEFT, Corner.BOTTOM_LEFT), "Left-Only"),
-        RIGHT_ONLY(setOf(Corner.TOP_RIGHT, Corner.BOTTOM_RIGHT), "Right-Only"),
-        ALL(setOf(Corner.TOP_LEFT, Corner.TOP_RIGHT, Corner.BOTTOM_LEFT, Corner.BOTTOM_RIGHT), "All")
+        NONE(emptySet(), "None"), TOP_LEFT_ONLY(
+            setOf(Corner.TOP_LEFT),
+            "Top-Left-Only"
+        ),
+        TOP_RIGHT_ONLY(setOf(Corner.TOP_RIGHT), "Top-Right-Only"), BOTTOM_LEFT_ONLY(
+            setOf(Corner.BOTTOM_LEFT),
+            "Bottom-Left-Only"
+        ),
+        BOTTOM_RIGHT_ONLY(setOf(Corner.BOTTOM_RIGHT), "Bottom-Right-Only"), TOP_ONLY(
+            setOf(
+                Corner.TOP_LEFT,
+                Corner.TOP_RIGHT
+            ), "Top-Only"
+        ),
+        BOTTOM_ONLY(setOf(Corner.BOTTOM_LEFT, Corner.BOTTOM_RIGHT), "Bottom-Only"), LEFT_ONLY(
+            setOf(
+                Corner.TOP_LEFT,
+                Corner.BOTTOM_LEFT
+            ), "Left-Only"
+        ),
+        RIGHT_ONLY(setOf(Corner.TOP_RIGHT, Corner.BOTTOM_RIGHT), "Right-Only"), ALL(
+            setOf(
+                Corner.TOP_LEFT,
+                Corner.TOP_RIGHT,
+                Corner.BOTTOM_LEFT,
+                Corner.BOTTOM_RIGHT
+            ), "All"
+        )
     }
 
     private fun drawRoundedRectangle(

From dbf9bed7675d073860c50e4ec7ffa2c177af1dbf Mon Sep 17 00:00:00 2001
From: RtxOP <137506596+RtxOP@users.noreply.github.com>
Date: Tue, 18 Feb 2025 16:36:24 +0000
Subject: [PATCH 17/19] fixes

---
 .../ui/client/hud/element/elements/Target.kt  | 62 +++++++++++++------
 1 file changed, 44 insertions(+), 18 deletions(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
index 4013c658fa7..ab5a7903a6c 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
@@ -28,7 +28,9 @@ import net.ccbluex.liquidbounce.utils.render.shader.shaders.RainbowShader
 import net.minecraft.client.gui.GuiChat
 import net.minecraft.entity.Entity
 import net.minecraft.entity.EntityLivingBase
-import net.minecraft.entity.player.EntityPlayer
+import net.minecraft.entity.passive.EntityCow
+import net.minecraft.entity.passive.EntitySheep
+import net.minecraft.entity.passive.EntityVillager
 import org.lwjgl.opengl.GL11.*
 import java.awt.Color
 import kotlin.math.abs
@@ -94,10 +96,8 @@ class Target : Element("Target") {
         val smoothMode = animation == "Smooth"
         val fadeMode = animation == "Fade"
 
-        val killAuraTarget = KillAura.target?.takeIf { it is EntityPlayer }
-
-        val shouldRender = KillAura.handleEvents() && killAuraTarget != null || mc.currentScreen is GuiChat
-        val target = killAuraTarget ?: if (delayCounter >= vanishDelay && !isRendered) {
+        val shouldRender = KillAura.handleEvents() && KillAura.target != null || mc.currentScreen is GuiChat
+        val target = KillAura.target ?: if (delayCounter >= vanishDelay && !isRendered) {
             mc.thePlayer
         } else {
             lastTarget ?: mc.thePlayer
@@ -118,8 +118,8 @@ class Target : Element("Target") {
 
                 easingHealth += (targetHealth - easingHealth) / 2f.pow(10f - fadeSpeed) * deltaTime
                 easingHealth = easingHealth.coerceIn(0f, maxHealth)
-
-                easingHurtTime = (easingHurtTime..target.hurtTime.toFloat()).lerpWith(RenderUtils.deltaTimeNormalized())
+                val targetHurtTime = if (target.isEntityAlive()) target.hurtTime.toFloat() else 0F
+                easingHurtTime = (easingHurtTime..targetHurtTime).lerpWith(RenderUtils.deltaTimeNormalized())
 
                 if (target != lastTarget || abs(easingHealth - targetHealth) < 0.01) {
                     easingHealth = targetHealth
@@ -202,8 +202,8 @@ class Target : Element("Target") {
 
                     val healthBarTop = 26F
                     val healthBarHeight = 8F
-                    val healthBarStart = 36F
-                    val healthBarTotal = (width - 39F).coerceAtLeast(0F)
+                    val healthBarStart = 38F
+                    val healthBarTotal = (width - 41F).coerceAtLeast(0F)
                     val currentWidth = (easingHealth / maxHealth).coerceIn(0F, 1F) * healthBarTotal
 
                     // background bar
@@ -213,7 +213,7 @@ class Target : Element("Target") {
                         healthBarStart + healthBarTotal,
                         healthBarTop + healthBarHeight,
                         Color.BLACK.rgb,
-                        3F,
+                        6F,
                     )
 
                     // main bar
@@ -223,8 +223,8 @@ class Target : Element("Target") {
                             healthBarTop,
                             healthBarStart + currentWidth,
                             healthBarTop + healthBarHeight,
-                            0,
-                            3F
+                            Color.BLACK.rgb,
+                            6F
                         )
                     }, toClip = {
                         drawGradientRect(
@@ -236,14 +236,14 @@ class Target : Element("Target") {
                             healthBarColor2.rgb,
                             0f
                         )
-                    })
+                    }, hide = true)
 
                     val healthPercentage = (easingHealth / maxHealth * 100).toInt()
                     val percentageText = "$healthPercentage%"
                     val textWidth = healthFont.getStringWidth(percentageText)
                     val calcX = healthBarStart + currentWidth - textWidth
                     val textX = max(healthBarStart, calcX)
-                    val textY = healthBarTop - Fonts.fontRegular30.fontHeight / 2 - 4F
+                    val textY = healthBarTop - Fonts.fontRegular30.fontHeight / 2 - 2F
                     healthFont.drawString(percentageText, textX, textY, textCustomColor, textShadow)
 
                     val shouldRenderBody =
@@ -266,18 +266,44 @@ class Target : Element("Target") {
                             glScalef(f1, f1, f1)
                             glTranslatef(-centerX1, -midY, 0f)
 
+                            val w = when (target) {
+                                is EntitySheep -> 7.5F to 7
+                                is EntityCow -> 6.5F to 7
+                                else -> 8F to 8
+                            }
+
+                            val h = when (target) {
+                                is EntitySheep -> 16F to 11
+                                is EntityVillager -> 9F to 9
+                                is EntityCow -> 15F to 12
+                                else -> 8F to 8
+                            }
+
                             if (entityTexture != null) {
                                 withClipping(main = {
-                                    drawRoundedRect(4f, 6f, 32f, 34f, 0, roundedRectRadius)
+                                    drawRoundedRect(6f, 6f, 34f, 34f, Color.BLACK.rgb, roundedRectRadius)
                                 }, toClip = {
-                                    drawHead(entityTexture, 4, 6, 8f, 8f, 8, 8, 28, 28, 64F, 64F, color)
-                                })
+                                    drawHead(
+                                        entityTexture,
+                                        6,
+                                        6,
+                                        w.first,
+                                        h.first,
+                                        w.second,
+                                        h.second,
+                                        28,
+                                        28,
+                                        64F,
+                                        64F,
+                                        color
+                                    )
+                                }, hide = true)
                             }
                             glPopMatrix()
                         }
 
                         target.name?.let {
-                            titleFont.drawString(it, 36F, 8F, textCustomColor, textShadow)
+                            titleFont.drawString(it, healthBarStart, 8F, textCustomColor, textShadow)
                         }
                     }
                 }

From 6f432e3def236743a8f2f0eeae996056e9a43f4f Mon Sep 17 00:00:00 2001
From: mems01 <70612656+mems01@users.noreply.github.com>
Date: Wed, 19 Feb 2025 01:15:38 +0200
Subject: [PATCH 18/19] fixed errors

---
 .../ui/client/hud/element/elements/Target.kt  | 36 ++++++-------------
 1 file changed, 10 insertions(+), 26 deletions(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
index ab5a7903a6c..c2e006edf89 100644
--- a/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/ui/client/hud/element/elements/Target.kt
@@ -28,9 +28,7 @@ import net.ccbluex.liquidbounce.utils.render.shader.shaders.RainbowShader
 import net.minecraft.client.gui.GuiChat
 import net.minecraft.entity.Entity
 import net.minecraft.entity.EntityLivingBase
-import net.minecraft.entity.passive.EntityCow
-import net.minecraft.entity.passive.EntitySheep
-import net.minecraft.entity.passive.EntityVillager
+import net.minecraft.entity.player.EntityPlayer
 import org.lwjgl.opengl.GL11.*
 import java.awt.Color
 import kotlin.math.abs
@@ -96,8 +94,10 @@ class Target : Element("Target") {
         val smoothMode = animation == "Smooth"
         val fadeMode = animation == "Fade"
 
-        val shouldRender = KillAura.handleEvents() && KillAura.target != null || mc.currentScreen is GuiChat
-        val target = KillAura.target ?: if (delayCounter >= vanishDelay && !isRendered) {
+        val killAuraTarget = KillAura.target.takeIf { it is EntityPlayer }
+
+        val shouldRender = KillAura.handleEvents() && killAuraTarget != null || mc.currentScreen is GuiChat
+        val target = killAuraTarget ?: if (delayCounter >= vanishDelay && !isRendered) {
             mc.thePlayer
         } else {
             lastTarget ?: mc.thePlayer
@@ -223,7 +223,7 @@ class Target : Element("Target") {
                             healthBarTop,
                             healthBarStart + currentWidth,
                             healthBarTop + healthBarHeight,
-                            Color.BLACK.rgb,
+                            0,
                             6F
                         )
                     }, toClip = {
@@ -236,7 +236,7 @@ class Target : Element("Target") {
                             healthBarColor2.rgb,
                             0f
                         )
-                    }, hide = true)
+                    })
 
                     val healthPercentage = (easingHealth / maxHealth * 100).toInt()
                     val percentageText = "$healthPercentage%"
@@ -266,38 +266,22 @@ class Target : Element("Target") {
                             glScalef(f1, f1, f1)
                             glTranslatef(-centerX1, -midY, 0f)
 
-                            val w = when (target) {
-                                is EntitySheep -> 7.5F to 7
-                                is EntityCow -> 6.5F to 7
-                                else -> 8F to 8
-                            }
-
-                            val h = when (target) {
-                                is EntitySheep -> 16F to 11
-                                is EntityVillager -> 9F to 9
-                                is EntityCow -> 15F to 12
-                                else -> 8F to 8
-                            }
-
                             if (entityTexture != null) {
                                 withClipping(main = {
-                                    drawRoundedRect(6f, 6f, 34f, 34f, Color.BLACK.rgb, roundedRectRadius)
+                                    drawRoundedRect(6f, 6f, 34f, 34f, 0, roundedRectRadius)
                                 }, toClip = {
                                     drawHead(
                                         entityTexture,
                                         6,
                                         6,
-                                        w.first,
-                                        h.first,
-                                        w.second,
-                                        h.second,
+                                        8f, 8f, 8, 8,
                                         28,
                                         28,
                                         64F,
                                         64F,
                                         color
                                     )
-                                }, hide = true)
+                                })
                             }
                             glPopMatrix()
                         }

From e573d5902d400a61019e867312f649090427be43 Mon Sep 17 00:00:00 2001
From: mems01 <70612656+mems01@users.noreply.github.com>
Date: Wed, 19 Feb 2025 04:30:16 +0200
Subject: [PATCH 19/19] even smoother aim point for killaura

---
 .../features/module/modules/combat/KillAura.kt      | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/main/java/net/ccbluex/liquidbounce/features/module/modules/combat/KillAura.kt b/src/main/java/net/ccbluex/liquidbounce/features/module/modules/combat/KillAura.kt
index e34f8d7be85..7e865a59477 100644
--- a/src/main/java/net/ccbluex/liquidbounce/features/module/modules/combat/KillAura.kt
+++ b/src/main/java/net/ccbluex/liquidbounce/features/module/modules/combat/KillAura.kt
@@ -9,6 +9,7 @@ import net.ccbluex.liquidbounce.LiquidBounce
 import net.ccbluex.liquidbounce.event.*
 import net.ccbluex.liquidbounce.features.module.Category
 import net.ccbluex.liquidbounce.features.module.Module
+import net.ccbluex.liquidbounce.features.module.modules.combat.Backtrack.runWithSimulatedPosition
 import net.ccbluex.liquidbounce.features.module.modules.player.Blink
 import net.ccbluex.liquidbounce.features.module.modules.world.Fucker
 import net.ccbluex.liquidbounce.features.module.modules.world.Nuker
@@ -1229,13 +1230,15 @@ object KillAura : Module("KillAura", Category.COMBAT, Keyboard.KEY_R) {
 
         val renderManager = mc.renderManager
 
-        val rotationVec = player.interpolatedPosition(player.prevPos, player.eyeHeight) + getVectorForRotation(
-            serverRotation.lerpWith(currentRotation ?: player.rotation, mc.timer.renderPartialTicks)
-        ) * player.getDistanceToEntityBox(target).coerceAtMost(range.toDouble())
+        runWithSimulatedPosition(player, player.interpolatedPosition(player.prevPos)) {
+            val rotationVec = player.eyes + getVectorForRotation(
+                serverRotation.lerpWith(currentRotation ?: player.rotation, mc.timer.renderPartialTicks)
+            ) * player.getDistanceToEntityBox(target).coerceAtMost(range.toDouble())
 
-        val offSetBox = box.offset(rotationVec - renderManager.renderPos)
+            val offSetBox = box.offset(rotationVec - renderManager.renderPos)
 
-        RenderUtils.drawAxisAlignedBB(offSetBox, aimPointBoxColor)
+            RenderUtils.drawAxisAlignedBB(offSetBox, aimPointBoxColor)
+        }
     }
 
     /**