local UILib =

loadstring(game:HttpGet('https://raw.githubusercontent.com/StepBroFurious/Script/
main/HydraHubUi.lua'))()
local Window = UILib.new("Gayware V2", game.Players.LocalPlayer.UserId, "Cool
Person")
local Category1 = Window:Category("Main", "http://www.roblox.com/asset/?
id=8395621517")
local Category2 = Window:Category("Esp", "http://www.roblox.com/asset/?
id=8395621517")
local SubButton1 = Category1:Button("Combat", "http://www.roblox.com/asset/?
id=8395747586")
local SubButton2 = Category2:Button("Esp", "http://www.roblox.com/asset/?
id=8395747586")
local Section1 = SubButton1:Section("Section", "Left")
local Section2 = SubButton2:Section("Section", "Left")

Section1:Toggle({
Title = "Camlock",
Description = "Optional Description here",
Default = false
}, function(value)
---@diagnostic disable: unused-function, undefined-global, need-check-nil,
undefined-field

local ContextActionService = game:GetService("ContextActionService")

local UserInputService = game:GetService("UserInputService")
local Players = game:GetService("Players")
local Debris = game:GetService("Debris")

local Camera = workspace.CurrentCamera

local Player = Players.LocalPlayer
local Mouse = Player:GetMouse()
local Thread = nil

local Keybind = Enum.KeyCode.Q

local Prediction = 0.05
local HitPart = "Head"

local function Main()

local function Noti(Text)
local Sound = Instance.new("Sound")
Sound.SoundId = "rbxassetid://1"
Sound.Parent = game:GetService("SoundService")
Sound:Play()
Debris:AddItem(Sound,Sound.TimeLength+1)

game:GetService("StarterGui"):SetCore("SendNotification", {
Title = "Random Aimlock!",
Text = Text,
})
end

Noti("Aimlock Loaded!")

local function AimAt(Character)

local Thread = task.spawn(function()
while task.wait() do
local HumanoidRootPart:Part = Character:FindFirstChild(HitPart) or
Character.PrimaryPart
 local Humanoid = Character:FindFirstChildWhichIsA('Humanoid') or
nil

if HumanoidRootPart then
local Lookat = (HumanoidRootPart.CFrame.Position +
Humanoid.MoveDirection*Prediction)
local Velocity = HumanoidRootPart.AssemblyLinearVelocity

if Velocity.Magnitude > 1 then

Lookat = Lookat + Velocity/10
end

Camera.CFrame = CFrame.new(
Camera.CFrame.Position,
Lookat
)
end
end
end)

return {
Stop = function()
task.cancel(Thread)
end
}
end

local function FindNearest()

local Character = nil
local Lowest = math.huge

for i, v in pairs(Players:GetChildren()) do
if v.Name == Player.Name then continue end
if not v.Character then continue end

local EHumanoidRootPart = v.Character:FindFirstChild(HitPart) or

v.Character.PrimaryPart
local Distance = (EHumanoidRootPart.CFrame.Position -
Mouse.Hit.Position).Magnitude or 0

if EHumanoidRootPart and Distance < Lowest then

Character = v.Character
Lowest = Distance
end
end

return Character
end

local function LockOntoNearest()

if Thread ~= nil then
Thread.Stop()
Thread = nil
Noti(`Unlocked`)
return
end

local Nearest = FindNearest()

 if Nearest then
Noti(`Locked Onto {Nearest.Name}`)
Thread = AimAt(Nearest)
end
end

if UserInputService.TouchEnabled then
ContextActionService:BindAction("Lock", LockOntoNearest, true, Keybind)
end

UserInputService.InputBegan:Connect(function(Input, Gpe)
if Gpe then
return
end

if Input.KeyCode == Keybind then

LockOntoNearest()
end
end)
end

if getgenv().AimlockLoaded ~= true then

getgenv().AimlockLoaded = true
task.defer(Main)
end
end)
Section2:Toggle({
Title = "Esp",
ButtonName = "esp",
Description = "gives u wall hacks",
}, function(value)
--[[ how esp works:

layout:
┌─────────┐
│ Name │ <- name/info
│ [100HP] │ <- health text
├──┐ ┌──┤ <- box corners
│ │ │ │
│ └──┘ │
║ │ │ <- health bar (left/right)
└───║────┘
║ <- tracer line
▼
[origin] <- bottom/mouse/center/top

box types:
corners: full: 3d:
┌─┐ ┌─┐ ┌──────┐ ┌──────┐╗
│ │ │ │ │ │ │ │║
│ │ │ │ │ │ │ │║
└─┘ └─┘ └──────┘ └──────┘║
╚═══════╝

esp creation process:

Player -> Character -> HumanoidRootPart
│
├─> Box ESP (3 styles)
│ ├─> Corner: 8 lines for corners
 │ ├─> Full: 4 lines for box
│ └─> 3D: 12 lines + connectors
│
├─> Skeleton ESP
│ ├─> Joint Connections
│ │ ├─> Head -> Torso
│ │ ├─> Torso -> Arms
│ │ ├─> Torso -> Legs
│ │ └─> Arms/Legs Segments
│ ├─> Dynamic Updates
│ └─> Color + Thickness
│
├─> Chams
│ ├─> Character Highlight
│ ├─> Fill Color + Transparency
│ ├─> Outline Color + Thickness
│ └─> Occluded Color (through walls)
│
├─> Tracer
│ └─> line from origin (4 positions)
│
├─> Health Bar
│ ├─> outline (background)
│ ├─> fill (dynamic color)
│ └─> text (HP/percentage)
│
└─> Info
└─> name text

technical implementation:
┌─ Camera Calculations ─────────────────┐
│ 1. Get Character CFrame & Size │
│ 2. WorldToViewportPoint for corners │
│ 3. Convert 3D -> 2D positions │
│ 4. Check if on screen │
│ 5. Calculate screen dimensions │
└─────────────────────────────────────┘

┌─ Drawing Creation ──────────────────┐

│ Line: From/To positions │
│ Square: Position + Size │
│ Text: Position + String │
│ All: Color/Transparency/Visible │
└────────────────────────────────────┘

┌─ Math & Checks ───────────────────────┐

│ Distance = (Player - Camera).Magnitude │
│ OnScreen = Z > 0 && in ViewportSize │
│ BoxSize = WorldToScreen(Extents) │
│ Scaling = 1000/Position.Z │
└─────────────────────────────────────┘

effects:
┌─ Rainbow Options ─┐
│ - All │
│ - Box Only │
│ - Tracers Only │
│ - Text Only │
└──────────────────┘
 colors:
┌─ Team Colors ────┐ ┌─ Health Colors ─┐
│ Enemy: Red │ │ Full: Green │
│ Ally: Green │ │ Low: Red │
│ Rainbow: HSV │ │ Mid: Yellow │
└────────────────┘ └────────────────┘

performance:
┌─ Settings ───────┐
│ Refresh: 144fps │
│ Distance: 5000 │
│ Cleanup: Auto │
└──────────────────┘

update cycle:
RenderStepped -> Check Settings -> Get Positions -> Update Drawings
│ │
└────────────────── 144fps ─────────────────────────┘
]]

local Fluent =
loadstring(game:HttpGet("https://github.com/dawid-scripts/Fluent/releases/latest/
download/main.lua"))()
local SaveManager =
loadstring(game:HttpGet("https://raw.githubusercontent.com/dawid-scripts/Fluent/
master/Addons/SaveManager.lua"))()
local InterfaceManager =
loadstring(game:HttpGet("https://raw.githubusercontent.com/dawid-scripts/Fluent/
master/Addons/InterfaceManager.lua"))()

local Players = game:GetService("Players")

local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local Camera = workspace.CurrentCamera
local LocalPlayer = Players.LocalPlayer

local Drawings = {
ESP = {},
Tracers = {},
Boxes = {},
Healthbars = {},
Names = {},
Distances = {},
Snaplines = {},
Skeleton = {}
}

local Colors = {
Enemy = Color3.fromRGB(255, 25, 25),
Ally = Color3.fromRGB(25, 255, 25),
Neutral = Color3.fromRGB(255, 255, 255),
Selected = Color3.fromRGB(255, 210, 0),
Health = Color3.fromRGB(0, 255, 0),
Distance = Color3.fromRGB(200, 200, 200),
Rainbow = nil
}

local Highlights = {}
local Settings = {
Enabled = false,
TeamCheck = false,
ShowTeam = false,
VisibilityCheck = true,
BoxESP = false,
BoxStyle = "Corner",
BoxOutline = true,
BoxFilled = false,
BoxFillTransparency = 0.5,
BoxThickness = 1,
TracerESP = false,
TracerOrigin = "Bottom",
TracerStyle = "Line",
TracerThickness = 1,
HealthESP = false,
HealthStyle = "Bar",
HealthBarSide = "Left",
HealthTextSuffix = "HP",
NameESP = false,
NameMode = "DisplayName",
ShowDistance = true,
DistanceUnit = "studs",
TextSize = 14,
TextFont = 2,
RainbowSpeed = 1,
MaxDistance = 1000,
RefreshRate = 1/144,
Snaplines = false,
SnaplineStyle = "Straight",
RainbowEnabled = false,
RainbowBoxes = false,
RainbowTracers = false,
RainbowText = false,
ChamsEnabled = false,
ChamsOutlineColor = Color3.fromRGB(255, 255, 255),
ChamsFillColor = Color3.fromRGB(255, 0, 0),
ChamsOccludedColor = Color3.fromRGB(150, 0, 0),
ChamsTransparency = 0.5,
ChamsOutlineTransparency = 0,
ChamsOutlineThickness = 0.1,
SkeletonESP = false,
SkeletonColor = Color3.fromRGB(255, 255, 255),
SkeletonThickness = 1.5,
SkeletonTransparency = 1
}

local function CreateESP(player)

if player == LocalPlayer then return end

local box = {
TopLeft = Drawing.new("Line"),
TopRight = Drawing.new("Line"),
BottomLeft = Drawing.new("Line"),
BottomRight = Drawing.new("Line"),
Left = Drawing.new("Line"),
Right = Drawing.new("Line"),
Top = Drawing.new("Line"),
 Bottom = Drawing.new("Line")
}

for _, line in pairs(box) do

line.Visible = false
line.Color = Colors.Enemy
line.Thickness = Settings.BoxThickness
if line == box.Fill then
line.Filled = true
line.Transparency = Settings.BoxFillTransparency
end
end

local tracer = Drawing.new("Line")

tracer.Visible = false
tracer.Color = Colors.Enemy
tracer.Thickness = Settings.TracerThickness

local healthBar = {
Outline = Drawing.new("Square"),
Fill = Drawing.new("Square"),
Text = Drawing.new("Text")
}

for _, obj in pairs(healthBar) do

obj.Visible = false
if obj == healthBar.Fill then
obj.Color = Colors.Health
obj.Filled = true
elseif obj == healthBar.Text then
obj.Center = true
obj.Size = Settings.TextSize
obj.Color = Colors.Health
obj.Font = Settings.TextFont
end
end

local info = {
Name = Drawing.new("Text"),
Distance = Drawing.new("Text")
}

for _, text in pairs(info) do

text.Visible = false
text.Center = true
text.Size = Settings.TextSize
text.Color = Colors.Enemy
text.Font = Settings.TextFont
text.Outline = true
end

local snapline = Drawing.new("Line")

snapline.Visible = false
snapline.Color = Colors.Enemy
snapline.Thickness = 1

local highlight = Instance.new("Highlight")

highlight.FillColor = Settings.ChamsFillColor
highlight.OutlineColor = Settings.ChamsOutlineColor
 highlight.FillTransparency = Settings.ChamsTransparency
highlight.OutlineTransparency = Settings.ChamsOutlineTransparency
highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
highlight.Enabled = Settings.ChamsEnabled

Highlights[player] = highlight

local skeleton = {
-- Spine & Head
Head = Drawing.new("Line"),
Neck = Drawing.new("Line"),
UpperSpine = Drawing.new("Line"),
LowerSpine = Drawing.new("Line"),

-- Left Arm
LeftShoulder = Drawing.new("Line"),
LeftUpperArm = Drawing.new("Line"),
LeftLowerArm = Drawing.new("Line"),
LeftHand = Drawing.new("Line"),

-- Right Arm
RightShoulder = Drawing.new("Line"),
RightUpperArm = Drawing.new("Line"),
RightLowerArm = Drawing.new("Line"),
RightHand = Drawing.new("Line"),

-- Left Leg
LeftHip = Drawing.new("Line"),
LeftUpperLeg = Drawing.new("Line"),
LeftLowerLeg = Drawing.new("Line"),
LeftFoot = Drawing.new("Line"),

-- Right Leg
RightHip = Drawing.new("Line"),
RightUpperLeg = Drawing.new("Line"),
RightLowerLeg = Drawing.new("Line"),
RightFoot = Drawing.new("Line")
}

for _, line in pairs(skeleton) do

line.Visible = false
line.Color = Settings.SkeletonColor
line.Thickness = Settings.SkeletonThickness
line.Transparency = Settings.SkeletonTransparency
end

Drawings.Skeleton[player] = skeleton

Drawings.ESP[player] = {
Box = box,
Tracer = tracer,
HealthBar = healthBar,
Info = info,
Snapline = snapline
}
end

local function RemoveESP(player)

local esp = Drawings.ESP[player]
 if esp then
for _, obj in pairs(esp.Box) do obj:Remove() end
esp.Tracer:Remove()
for _, obj in pairs(esp.HealthBar) do obj:Remove() end
for _, obj in pairs(esp.Info) do obj:Remove() end
esp.Snapline:Remove()
Drawings.ESP[player] = nil
end

local highlight = Highlights[player]

if highlight then
highlight:Destroy()
Highlights[player] = nil
end

local skeleton = Drawings.Skeleton[player]

if skeleton then
for _, line in pairs(skeleton) do
line:Remove()
end
Drawings.Skeleton[player] = nil
end
end

local function GetPlayerColor(player)

if Settings.RainbowEnabled then
if Settings.RainbowBoxes and Settings.BoxESP then return Colors.Rainbow end
if Settings.RainbowTracers and Settings.TracerESP then return
Colors.Rainbow end
if Settings.RainbowText and (Settings.NameESP or Settings.HealthESP) then
return Colors.Rainbow end
end
return player.Team == LocalPlayer.Team and Colors.Ally or Colors.Enemy
end

local function GetBoxCorners(cf, size)

local corners = {
Vector3.new(-size.X/2, -size.Y/2, -size.Z/2),
Vector3.new(-size.X/2, -size.Y/2, size.Z/2),
Vector3.new(-size.X/2, size.Y/2, -size.Z/2),
Vector3.new(-size.X/2, size.Y/2, size.Z/2),
Vector3.new(size.X/2, -size.Y/2, -size.Z/2),
Vector3.new(size.X/2, -size.Y/2, size.Z/2),
Vector3.new(size.X/2, size.Y/2, -size.Z/2),
Vector3.new(size.X/2, size.Y/2, size.Z/2)
}

for i, corner in ipairs(corners) do

corners[i] = cf:PointToWorldSpace(corner)
end

return corners
end

local function GetTracerOrigin()

local origin = Settings.TracerOrigin
if origin == "Bottom" then
return Vector2.new(Camera.ViewportSize.X/2, Camera.ViewportSize.Y)
elseif origin == "Top" then
 return Vector2.new(Camera.ViewportSize.X/2, 0)
elseif origin == "Mouse" then
return UserInputService:GetMouseLocation()
else
return Vector2.new(Camera.ViewportSize.X/2, Camera.ViewportSize.Y/2)
end
end

local function UpdateESP(player)

if not Settings.Enabled then return end

local esp = Drawings.ESP[player]

if not esp then return end

local character = player.Character

if not character then
-- Hide all drawings if character doesn't exist
for _, obj in pairs(esp.Box) do obj.Visible = false end
esp.Tracer.Visible = false
for _, obj in pairs(esp.HealthBar) do obj.Visible = false end
for _, obj in pairs(esp.Info) do obj.Visible = false end
esp.Snapline.Visible = false

local skeleton = Drawings.Skeleton[player]

if skeleton then
for _, line in pairs(skeleton) do
line.Visible = false
end
end
return
end

local rootPart = character:FindFirstChild("HumanoidRootPart")

if not rootPart then
-- Hide all drawings if rootPart doesn't exist
for _, obj in pairs(esp.Box) do obj.Visible = false end
esp.Tracer.Visible = false
for _, obj in pairs(esp.HealthBar) do obj.Visible = false end
for _, obj in pairs(esp.Info) do obj.Visible = false end
esp.Snapline.Visible = false

local skeleton = Drawings.Skeleton[player]

if skeleton then
for _, line in pairs(skeleton) do
line.Visible = false
end
end
return
end

-- Early screen check to hide all drawings if player is off screen

local _, isOnScreen = Camera:WorldToViewportPoint(rootPart.Position)
if not isOnScreen then
for _, obj in pairs(esp.Box) do obj.Visible = false end
esp.Tracer.Visible = false
for _, obj in pairs(esp.HealthBar) do obj.Visible = false end
for _, obj in pairs(esp.Info) do obj.Visible = false end
esp.Snapline.Visible = false
 local skeleton = Drawings.Skeleton[player]
if skeleton then
for _, line in pairs(skeleton) do
line.Visible = false
end
end
return
end

local humanoid = character:FindFirstChild("Humanoid")

if not humanoid or humanoid.Health <= 0 then
for _, obj in pairs(esp.Box) do obj.Visible = false end
esp.Tracer.Visible = false
for _, obj in pairs(esp.HealthBar) do obj.Visible = false end
for _, obj in pairs(esp.Info) do obj.Visible = false end
esp.Snapline.Visible = false

local skeleton = Drawings.Skeleton[player]

if skeleton then
for _, line in pairs(skeleton) do
line.Visible = false
end
end
return
end

local pos, onScreen = Camera:WorldToViewportPoint(rootPart.Position)

local distance = (rootPart.Position - Camera.CFrame.Position).Magnitude

if not onScreen or distance > Settings.MaxDistance then

for _, obj in pairs(esp.Box) do obj.Visible = false end
esp.Tracer.Visible = false
for _, obj in pairs(esp.HealthBar) do obj.Visible = false end
for _, obj in pairs(esp.Info) do obj.Visible = false end
esp.Snapline.Visible = false
return
end

if Settings.TeamCheck and player.Team == LocalPlayer.Team and not

Settings.ShowTeam then
for _, obj in pairs(esp.Box) do obj.Visible = false end
esp.Tracer.Visible = false
for _, obj in pairs(esp.HealthBar) do obj.Visible = false end
for _, obj in pairs(esp.Info) do obj.Visible = false end
esp.Snapline.Visible = false
return
end

local color = GetPlayerColor(player)

local size = character:GetExtentsSize()
local cf = rootPart.CFrame

local top, top_onscreen = Camera:WorldToViewportPoint(cf * CFrame.new(0,

size.Y/2, 0).Position)
local bottom, bottom_onscreen = Camera:WorldToViewportPoint(cf * CFrame.new(0,
-size.Y/2, 0).Position)

if not top_onscreen or not bottom_onscreen then

for _, obj in pairs(esp.Box) do obj.Visible = false end
 return
end

local screenSize = bottom.Y - top.Y

local boxWidth = screenSize * 0.65
local boxPosition = Vector2.new(top.X - boxWidth/2, top.Y)
local boxSize = Vector2.new(boxWidth, screenSize)

-- Hide all box parts by default

for _, obj in pairs(esp.Box) do
obj.Visible = false
end

if Settings.BoxESP then
if Settings.BoxStyle == "ThreeD" then
local front = {
TL = Camera:WorldToViewportPoint((cf * CFrame.new(-size.X/2,
size.Y/2, -size.Z/2)).Position),
TR = Camera:WorldToViewportPoint((cf * CFrame.new(size.X/2,
size.Y/2, -size.Z/2)).Position),
BL = Camera:WorldToViewportPoint((cf * CFrame.new(-size.X/2, -
size.Y/2, -size.Z/2)).Position),
BR = Camera:WorldToViewportPoint((cf * CFrame.new(size.X/2, -
size.Y/2, -size.Z/2)).Position)
}

local back = {
TL = Camera:WorldToViewportPoint((cf * CFrame.new(-size.X/2,
size.Y/2, size.Z/2)).Position),
TR = Camera:WorldToViewportPoint((cf * CFrame.new(size.X/2,
size.Y/2, size.Z/2)).Position),
BL = Camera:WorldToViewportPoint((cf * CFrame.new(-size.X/2, -
size.Y/2, size.Z/2)).Position),
BR = Camera:WorldToViewportPoint((cf * CFrame.new(size.X/2, -
size.Y/2, size.Z/2)).Position)
}

if not (front.TL.Z > 0 and front.TR.Z > 0 and front.BL.Z > 0 and
front.BR.Z > 0 and
back.TL.Z > 0 and back.TR.Z > 0 and back.BL.Z > 0 and back.BR.Z
> 0) then
for _, obj in pairs(esp.Box) do obj.Visible = false end
return
end

-- Convert to Vector2
local function toVector2(v3) return Vector2.new(v3.X, v3.Y) end
front.TL, front.TR = toVector2(front.TL), toVector2(front.TR)
front.BL, front.BR = toVector2(front.BL), toVector2(front.BR)
back.TL, back.TR = toVector2(back.TL), toVector2(back.TR)
back.BL, back.BR = toVector2(back.BL), toVector2(back.BR)

-- Front face
esp.Box.TopLeft.From = front.TL
esp.Box.TopLeft.To = front.TR
esp.Box.TopLeft.Visible = true

esp.Box.TopRight.From = front.TR
esp.Box.TopRight.To = front.BR
 esp.Box.TopRight.Visible = true

esp.Box.BottomLeft.From = front.BL
esp.Box.BottomLeft.To = front.BR
esp.Box.BottomLeft.Visible = true

esp.Box.BottomRight.From = front.TL
esp.Box.BottomRight.To = front.BL
esp.Box.BottomRight.Visible = true

-- Back face
esp.Box.Left.From = back.TL
esp.Box.Left.To = back.TR
esp.Box.Left.Visible = true

esp.Box.Right.From = back.TR
esp.Box.Right.To = back.BR
esp.Box.Right.Visible = true

esp.Box.Top.From = back.BL
esp.Box.Top.To = back.BR
esp.Box.Top.Visible = true

esp.Box.Bottom.From = back.TL
esp.Box.Bottom.To = back.BL
esp.Box.Bottom.Visible = true

-- Connecting lines
local function drawConnectingLine(from, to, visible)
local line = Drawing.new("Line")
line.Visible = visible
line.Color = color
line.Thickness = Settings.BoxThickness
line.From = from
line.To = to
return line
end

-- Connect front to back

local connectors = {
drawConnectingLine(front.TL, back.TL, true),
drawConnectingLine(front.TR, back.TR, true),
drawConnectingLine(front.BL, back.BL, true),
drawConnectingLine(front.BR, back.BR, true)
}

-- Clean up connecting lines after frame

task.spawn(function()
task.wait()
for _, line in ipairs(connectors) do
line:Remove()
end
end)

elseif Settings.BoxStyle == "Corner" then

local cornerSize = boxWidth * 0.2

esp.Box.TopLeft.From = boxPosition
esp.Box.TopLeft.To = boxPosition + Vector2.new(cornerSize, 0)
 esp.Box.TopLeft.Visible = true

esp.Box.TopRight.From = boxPosition + Vector2.new(boxSize.X, 0)

esp.Box.TopRight.To = boxPosition + Vector2.new(boxSize.X - cornerSize,
0)
esp.Box.TopRight.Visible = true

esp.Box.BottomLeft.From = boxPosition + Vector2.new(0, boxSize.Y)

esp.Box.BottomLeft.To = boxPosition + Vector2.new(cornerSize,
boxSize.Y)
esp.Box.BottomLeft.Visible = true

esp.Box.BottomRight.From = boxPosition + Vector2.new(boxSize.X,

boxSize.Y)
esp.Box.BottomRight.To = boxPosition + Vector2.new(boxSize.X -
cornerSize, boxSize.Y)
esp.Box.BottomRight.Visible = true

esp.Box.Left.From = boxPosition
esp.Box.Left.To = boxPosition + Vector2.new(0, cornerSize)
esp.Box.Left.Visible = true

esp.Box.Right.From = boxPosition + Vector2.new(boxSize.X, 0)

esp.Box.Right.To = boxPosition + Vector2.new(boxSize.X, cornerSize)
esp.Box.Right.Visible = true

esp.Box.Top.From = boxPosition + Vector2.new(0, boxSize.Y)

esp.Box.Top.To = boxPosition + Vector2.new(0, boxSize.Y - cornerSize)
esp.Box.Top.Visible = true

esp.Box.Bottom.From = boxPosition + Vector2.new(boxSize.X, boxSize.Y)

esp.Box.Bottom.To = boxPosition + Vector2.new(boxSize.X, boxSize.Y -
cornerSize)
esp.Box.Bottom.Visible = true

else -- Full box

esp.Box.Left.From = boxPosition
esp.Box.Left.To = boxPosition + Vector2.new(0, boxSize.Y)
esp.Box.Left.Visible = true

esp.Box.Right.From = boxPosition + Vector2.new(boxSize.X, 0)

esp.Box.Right.To = boxPosition + Vector2.new(boxSize.X, boxSize.Y)
esp.Box.Right.Visible = true

esp.Box.Top.From = boxPosition
esp.Box.Top.To = boxPosition + Vector2.new(boxSize.X, 0)
esp.Box.Top.Visible = true

esp.Box.Bottom.From = boxPosition + Vector2.new(0, boxSize.Y)

esp.Box.Bottom.To = boxPosition + Vector2.new(boxSize.X, boxSize.Y)
esp.Box.Bottom.Visible = true

esp.Box.TopLeft.Visible = false
esp.Box.TopRight.Visible = false
esp.Box.BottomLeft.Visible = false
esp.Box.BottomRight.Visible = false
end

for _, obj in pairs(esp.Box) do

 if obj.Visible then
obj.Color = color
obj.Thickness = Settings.BoxThickness
end
end
end

if Settings.TracerESP then
esp.Tracer.From = GetTracerOrigin()
esp.Tracer.To = Vector2.new(pos.X, pos.Y)
esp.Tracer.Color = color
esp.Tracer.Visible = true
else
esp.Tracer.Visible = false
end

if Settings.HealthESP then
local health = humanoid.Health
local maxHealth = humanoid.MaxHealth
local healthPercent = health/maxHealth

local barHeight = screenSize * 0.8

local barWidth = 4
local barPos = Vector2.new(
boxPosition.X - barWidth - 2,
boxPosition.Y + (screenSize - barHeight)/2
)

esp.HealthBar.Outline.Size = Vector2.new(barWidth, barHeight)

esp.HealthBar.Outline.Position = barPos
esp.HealthBar.Outline.Visible = true

esp.HealthBar.Fill.Size = Vector2.new(barWidth - 2, barHeight *

healthPercent)
esp.HealthBar.Fill.Position = Vector2.new(barPos.X + 1, barPos.Y +
barHeight * (1-healthPercent))
esp.HealthBar.Fill.Color = Color3.fromRGB(255 - (255 * healthPercent), 255
* healthPercent, 0)
esp.HealthBar.Fill.Visible = true

if Settings.HealthStyle == "Both" or Settings.HealthStyle == "Text" then

esp.HealthBar.Text.Text = math.floor(health) ..
Settings.HealthTextSuffix
esp.HealthBar.Text.Position = Vector2.new(barPos.X + barWidth + 2,
barPos.Y + barHeight/2)
esp.HealthBar.Text.Visible = true
else
esp.HealthBar.Text.Visible = false
end
else
for _, obj in pairs(esp.HealthBar) do
obj.Visible = false
end
end

if Settings.NameESP then
esp.Info.Name.Text = player.DisplayName
esp.Info.Name.Position = Vector2.new(
boxPosition.X + boxWidth/2,
 boxPosition.Y - 20
)
esp.Info.Name.Color = color
esp.Info.Name.Visible = true
else
esp.Info.Name.Visible = false
end

if Settings.Snaplines then
esp.Snapline.From = Vector2.new(Camera.ViewportSize.X/2,
Camera.ViewportSize.Y)
esp.Snapline.To = Vector2.new(pos.X, pos.Y)
esp.Snapline.Color = color
esp.Snapline.Visible = true
else
esp.Snapline.Visible = false
end

local highlight = Highlights[player]

if highlight then
if Settings.ChamsEnabled and character then
highlight.Parent = character
highlight.FillColor = Settings.ChamsFillColor
highlight.OutlineColor = Settings.ChamsOutlineColor
highlight.FillTransparency = Settings.ChamsTransparency
highlight.OutlineTransparency = Settings.ChamsOutlineTransparency
highlight.Enabled = true
else
highlight.Enabled = false
end
end

if Settings.SkeletonESP then
local function getBonePositions(character)
if not character then return nil end

local bones = {
Head = character:FindFirstChild("Head"),
UpperTorso = character:FindFirstChild("UpperTorso") or
character:FindFirstChild("Torso"),
LowerTorso = character:FindFirstChild("LowerTorso") or
character:FindFirstChild("Torso"),
RootPart = character:FindFirstChild("HumanoidRootPart"),

-- Left Arm
LeftUpperArm = character:FindFirstChild("LeftUpperArm") or
character:FindFirstChild("Left Arm"),
LeftLowerArm = character:FindFirstChild("LeftLowerArm") or
character:FindFirstChild("Left Arm"),
LeftHand = character:FindFirstChild("LeftHand") or
character:FindFirstChild("Left Arm"),

-- Right Arm
RightUpperArm = character:FindFirstChild("RightUpperArm") or
character:FindFirstChild("Right Arm"),
RightLowerArm = character:FindFirstChild("RightLowerArm") or
character:FindFirstChild("Right Arm"),
RightHand = character:FindFirstChild("RightHand") or
character:FindFirstChild("Right Arm"),
 -- Left Leg
LeftUpperLeg = character:FindFirstChild("LeftUpperLeg") or
character:FindFirstChild("Left Leg"),
LeftLowerLeg = character:FindFirstChild("LeftLowerLeg") or
character:FindFirstChild("Left Leg"),
LeftFoot = character:FindFirstChild("LeftFoot") or
character:FindFirstChild("Left Leg"),

-- Right Leg
RightUpperLeg = character:FindFirstChild("RightUpperLeg") or
character:FindFirstChild("Right Leg"),
RightLowerLeg = character:FindFirstChild("RightLowerLeg") or
character:FindFirstChild("Right Leg"),
RightFoot = character:FindFirstChild("RightFoot") or
character:FindFirstChild("Right Leg")
}

-- Verify we have the minimum required bones

if not (bones.Head and bones.UpperTorso) then return nil end

return bones
end

local function drawBone(from, to, line)

if not from or not to then
line.Visible = false
return
end

-- Get center positions of the parts

local fromPos = (from.CFrame * CFrame.new(0, 0, 0)).Position
local toPos = (to.CFrame * CFrame.new(0, 0, 0)).Position

-- Convert to screen positions with proper depth check

local fromScreen, fromVisible = Camera:WorldToViewportPoint(fromPos)
local toScreen, toVisible = Camera:WorldToViewportPoint(toPos)

-- Only show if both points are visible and in front of camera

if not (fromVisible and toVisible) or fromScreen.Z < 0 or toScreen.Z <
0 then
line.Visible = false
return
end

-- Check if points are within screen bounds

local screenBounds = Camera.ViewportSize
if fromScreen.X < 0 or fromScreen.X > screenBounds.X or
fromScreen.Y < 0 or fromScreen.Y > screenBounds.Y or
toScreen.X < 0 or toScreen.X > screenBounds.X or
toScreen.Y < 0 or toScreen.Y > screenBounds.Y then
line.Visible = false
return
end

-- Update line with screen positions

line.From = Vector2.new(fromScreen.X, fromScreen.Y)
line.To = Vector2.new(toScreen.X, toScreen.Y)
line.Color = Settings.SkeletonColor
 line.Thickness = Settings.SkeletonThickness
line.Transparency = Settings.SkeletonTransparency
line.Visible = true
end

local bones = getBonePositions(character)

if bones then
local skeleton = Drawings.Skeleton[player]
if skeleton then
-- Spine & Head
drawBone(bones.Head, bones.UpperTorso, skeleton.Head)
drawBone(bones.UpperTorso, bones.LowerTorso, skeleton.UpperSpine)

-- Left Arm Chain

drawBone(bones.UpperTorso, bones.LeftUpperArm,
skeleton.LeftShoulder)
drawBone(bones.LeftUpperArm, bones.LeftLowerArm,
skeleton.LeftUpperArm)
drawBone(bones.LeftLowerArm, bones.LeftHand, skeleton.LeftLowerArm)

-- Right Arm Chain

drawBone(bones.UpperTorso, bones.RightUpperArm,
skeleton.RightShoulder)
drawBone(bones.RightUpperArm, bones.RightLowerArm,
skeleton.RightUpperArm)
drawBone(bones.RightLowerArm, bones.RightHand,
skeleton.RightLowerArm)

-- Left Leg Chain

drawBone(bones.LowerTorso, bones.LeftUpperLeg, skeleton.LeftHip)
drawBone(bones.LeftUpperLeg, bones.LeftLowerLeg,
skeleton.LeftUpperLeg)
drawBone(bones.LeftLowerLeg, bones.LeftFoot, skeleton.LeftLowerLeg)

-- Right Leg Chain

drawBone(bones.LowerTorso, bones.RightUpperLeg, skeleton.RightHip)
drawBone(bones.RightUpperLeg, bones.RightLowerLeg,
skeleton.RightUpperLeg)
drawBone(bones.RightLowerLeg, bones.RightFoot,
skeleton.RightLowerLeg)
end
end
else
local skeleton = Drawings.Skeleton[player]
if skeleton then
for _, line in pairs(skeleton) do
line.Visible = false
end
end
end
end

local function DisableESP()

for _, player in ipairs(Players:GetPlayers()) do
local esp = Drawings.ESP[player]
if esp then
for _, obj in pairs(esp.Box) do obj.Visible = false end
esp.Tracer.Visible = false
for _, obj in pairs(esp.HealthBar) do obj.Visible = false end
 for _, obj in pairs(esp.Info) do obj.Visible = false end
esp.Snapline.Visible = false
end

-- Also hide skeleton

local skeleton = Drawings.Skeleton[player]
if skeleton then
for _, line in pairs(skeleton) do
line.Visible = false
end
end
end
end

local function CleanupESP()

for _, player in ipairs(Players:GetPlayers()) do
RemoveESP(player)
end
Drawings.ESP = {}
Drawings.Skeleton = {}
Highlights = {}
end

local Window = Fluent:CreateWindow({

Title = "WA Universal ESP",
SubTitle = "by WA",
TabWidth = 160,
Size = UDim2.fromOffset(580, 460),
Acrylic = false,
Theme = "Dark",
MinimizeKey = Enum.KeyCode.LeftControl
})

local Tabs = {
ESP = Window:AddTab({ Title = "ESP", Icon = "eye" }),
Settings = Window:AddTab({ Title = "Settings", Icon = "settings" }),
Config = Window:AddTab({ Title = "Config", Icon = "save" })
}

do
local MainSection = Tabs.ESP:AddSection("Main ESP")

local EnabledToggle = MainSection:AddToggle("Enabled", {

Title = "Enable ESP",
Default = false
})
EnabledToggle:OnChanged(function()
Settings.Enabled = EnabledToggle.Value
if not Settings.Enabled then
CleanupESP()
else
for _, player in ipairs(Players:GetPlayers()) do
if player ~= LocalPlayer then
CreateESP(player)
end
end
end
end)
local TeamCheckToggle = MainSection:AddToggle("TeamCheck", {
Title = "Team Check",
Default = false
})
TeamCheckToggle:OnChanged(function()
Settings.TeamCheck = TeamCheckToggle.Value
end)

local ShowTeamToggle = MainSection:AddToggle("ShowTeam", {

Title = "Show Team",
Default = false
})
ShowTeamToggle:OnChanged(function()
Settings.ShowTeam = ShowTeamToggle.Value
end)

local BoxSection = Tabs.ESP:AddSection("Box ESP")

local BoxESPToggle = BoxSection:AddToggle("BoxESP", {

Title = "Box ESP",
Default = false
})
BoxESPToggle:OnChanged(function()
Settings.BoxESP = BoxESPToggle.Value
end)

local BoxStyleDropdown = BoxSection:AddDropdown("BoxStyle", {

Title = "Box Style",
Values = {"Corner", "Full", "ThreeD"},
Default = "Corner"
})
BoxStyleDropdown:OnChanged(function(Value)
Settings.BoxStyle = Value
end)

local TracerSection = Tabs.ESP:AddSection("Tracer ESP")

local TracerESPToggle = TracerSection:AddToggle("TracerESP", {

Title = "Tracer ESP",
Default = false
})
TracerESPToggle:OnChanged(function()
Settings.TracerESP = TracerESPToggle.Value
end)

local TracerOriginDropdown = TracerSection:AddDropdown("TracerOrigin", {

Title = "Tracer Origin",
Values = {"Bottom", "Top", "Mouse", "Center"},
Default = "Bottom"
})
TracerOriginDropdown:OnChanged(function(Value)
Settings.TracerOrigin = Value
end)

local ChamsSection = Tabs.ESP:AddSection("Chams")

local ChamsToggle = ChamsSection:AddToggle("ChamsEnabled", {

Title = "Enable Chams",
Default = false
 })
ChamsToggle:OnChanged(function()
Settings.ChamsEnabled = ChamsToggle.Value
end)

local ChamsFillColor = ChamsSection:AddColorpicker("ChamsFillColor", {

Title = "Fill Color",
Description = "Color for visible parts",
Default = Settings.ChamsFillColor
})
ChamsFillColor:OnChanged(function(Value)
Settings.ChamsFillColor = Value
end)

local ChamsOccludedColor = ChamsSection:AddColorpicker("ChamsOccludedColor", {

Title = "Occluded Color",
Description = "Color for parts behind walls",
Default = Settings.ChamsOccludedColor
})
ChamsOccludedColor:OnChanged(function(Value)
Settings.ChamsOccludedColor = Value
end)

local ChamsOutlineColor = ChamsSection:AddColorpicker("ChamsOutlineColor", {

Title = "Outline Color",
Description = "Color for character outline",
Default = Settings.ChamsOutlineColor
})
ChamsOutlineColor:OnChanged(function(Value)
Settings.ChamsOutlineColor = Value
end)

local ChamsTransparency = ChamsSection:AddSlider("ChamsTransparency", {

Title = "Fill Transparency",
Description = "Transparency of the fill color",
Default = 0.5,
Min = 0,
Max = 1,
Rounding = 2
})
ChamsTransparency:OnChanged(function(Value)
Settings.ChamsTransparency = Value
end)

local ChamsOutlineTransparency =
ChamsSection:AddSlider("ChamsOutlineTransparency", {
Title = "Outline Transparency",
Description = "Transparency of the outline",
Default = 0,
Min = 0,
Max = 1,
Rounding = 2
})
ChamsOutlineTransparency:OnChanged(function(Value)
Settings.ChamsOutlineTransparency = Value
end)

local ChamsOutlineThickness = ChamsSection:AddSlider("ChamsOutlineThickness", {

Title = "Outline Thickness",
 Description = "Thickness of the outline",
Default = 0.1,
Min = 0,
Max = 1,
Rounding = 2
})
ChamsOutlineThickness:OnChanged(function(Value)
Settings.ChamsOutlineThickness = Value
end)

local HealthSection = Tabs.ESP:AddSection("Health ESP")

local HealthESPToggle = HealthSection:AddToggle("HealthESP", {

Title = "Health Bar",
Default = false
})
HealthESPToggle:OnChanged(function()
Settings.HealthESP = HealthESPToggle.Value
end)

local HealthStyleDropdown = HealthSection:AddDropdown("HealthStyle", {

Title = "Health Style",
Values = {"Bar", "Text", "Both"},
Default = "Bar"
})
HealthStyleDropdown:OnChanged(function(Value)
Settings.HealthStyle = Value
end)
end

do
local ColorsSection = Tabs.Settings:AddSection("Colors")

local EnemyColor = ColorsSection:AddColorpicker("EnemyColor", {

Title = "Enemy Color",
Description = "Color for enemy players",
Default = Colors.Enemy
})
EnemyColor:OnChanged(function(Value)
Colors.Enemy = Value
end)

local AllyColor = ColorsSection:AddColorpicker("AllyColor", {

Title = "Ally Color",
Description = "Color for team members",
Default = Colors.Ally
})
AllyColor:OnChanged(function(Value)
Colors.Ally = Value
end)

local HealthColor = ColorsSection:AddColorpicker("HealthColor", {

Title = "Health Bar Color",
Description = "Color for full health",
Default = Colors.Health
})
HealthColor:OnChanged(function(Value)
Colors.Health = Value
end)
local BoxSection = Tabs.Settings:AddSection("Box Settings")

local BoxThickness = BoxSection:AddSlider("BoxThickness", {

Title = "Box Thickness",
Default = 1,
Min = 1,
Max = 5,
Rounding = 1
})
BoxThickness:OnChanged(function(Value)
Settings.BoxThickness = Value
end)

local BoxTransparency = BoxSection:AddSlider("BoxTransparency", {

Title = "Box Transparency",
Default = 1,
Min = 0,
Max = 1,
Rounding = 2
})
BoxTransparency:OnChanged(function(Value)
Settings.BoxFillTransparency = Value
end)

local ESPSection = Tabs.Settings:AddSection("ESP Settings")

local MaxDistance = ESPSection:AddSlider("MaxDistance", {

Title = "Max Distance",
Default = 1000,
Min = 100,
Max = 5000,
Rounding = 0
})
MaxDistance:OnChanged(function(Value)
Settings.MaxDistance = Value
end)

local TextSize = ESPSection:AddSlider("TextSize", {

Title = "Text Size",
Default = 14,
Min = 10,
Max = 24,
Rounding = 0
})
TextSize:OnChanged(function(Value)
Settings.TextSize = Value
end)

local HealthTextFormat = ESPSection:AddDropdown("HealthTextFormat", {

Title = "Health Format",
Values = {"Number", "Percentage", "Both"},
Default = "Number"
})
HealthTextFormat:OnChanged(function(Value)
Settings.HealthTextFormat = Value
end)

local EffectsSection = Tabs.Settings:AddSection("Effects")

 local RainbowToggle = EffectsSection:AddToggle("RainbowEnabled", {
Title = "Rainbow Mode",
Default = false
})
RainbowToggle:OnChanged(function()
Settings.RainbowEnabled = RainbowToggle.Value
end)

local RainbowSpeed = EffectsSection:AddSlider("RainbowSpeed", {

Title = "Rainbow Speed",
Default = 1,
Min = 0.1,
Max = 5,
Rounding = 1
})
RainbowSpeed:OnChanged(function(Value)
Settings.RainbowSpeed = Value
end)

local RainbowOptions = EffectsSection:AddDropdown("RainbowParts", {

Title = "Rainbow Parts",
Values = {"All", "Box Only", "Tracers Only", "Text Only"},
Default = "All",
Multi = false
})
RainbowOptions:OnChanged(function(Value)
if Value == "All" then
Settings.RainbowBoxes = true
Settings.RainbowTracers = true
Settings.RainbowText = true
elseif Value == "Box Only" then
Settings.RainbowBoxes = true
Settings.RainbowTracers = false
Settings.RainbowText = false
elseif Value == "Tracers Only" then
Settings.RainbowBoxes = false
Settings.RainbowTracers = true
Settings.RainbowText = false
elseif Value == "Text Only" then
Settings.RainbowBoxes = false
Settings.RainbowTracers = false
Settings.RainbowText = true
end
end)

local PerformanceSection = Tabs.Settings:AddSection("Performance")

local RefreshRate = PerformanceSection:AddSlider("RefreshRate", {

Title = "Refresh Rate",
Default = 144,
Min = 1,
Max = 144,
Rounding = 0
})
RefreshRate:OnChanged(function(Value)
Settings.RefreshRate = 1/Value
end)
end
do
SaveManager:SetLibrary(Fluent)
InterfaceManager:SetLibrary(Fluent)
SaveManager:IgnoreThemeSettings()
SaveManager:SetIgnoreIndexes({})
InterfaceManager:SetFolder("WAUniversalESP")
SaveManager:SetFolder("WAUniversalESP/configs")

InterfaceManager:BuildInterfaceSection(Tabs.Config)
SaveManager:BuildConfigSection(Tabs.Config)

local UnloadSection = Tabs.Config:AddSection("Unload")

local UnloadButton = UnloadSection:AddButton({

Title = "Unload ESP",
Description = "Completely remove the ESP",
Callback = function()
CleanupESP()
for _, connection in pairs(getconnections(RunService.RenderStepped)) do
connection:Disable()
end
Window:Destroy()
Drawings = nil
Settings = nil
for k, v in pairs(getfenv(1)) do
getfenv(1)[k] = nil
end
end
})
end

task.spawn(function()
while task.wait(0.1) do
Colors.Rainbow = Color3.fromHSV(tick() * Settings.RainbowSpeed % 1, 1, 1)
end
end)

local lastUpdate = 0
RunService.RenderStepped:Connect(function()
if not Settings.Enabled then
DisableESP()
return
end

local currentTime = tick()

if currentTime - lastUpdate >= Settings.RefreshRate then
for _, player in ipairs(Players:GetPlayers()) do
if player ~= LocalPlayer then
if not Drawings.ESP[player] then
CreateESP(player)
end
UpdateESP(player)
end
end
lastUpdate = currentTime
end
end)
Players.PlayerAdded:Connect(CreateESP)
Players.PlayerRemoving:Connect(RemoveESP)

for _, player in ipairs(Players:GetPlayers()) do

if player ~= LocalPlayer then
CreateESP(player)
end
end

Window:SelectTab(1)

Fluent:Notify({
Title = "WA Universal ESP",
Content = "Loaded successfully!",
Duration = 5
})

local SkeletonSection = Tabs.ESP:AddSection("Skeleton ESP")

local SkeletonESPToggle = SkeletonSection:AddToggle("SkeletonESP", {

Title = "Skeleton ESP",
Default = false
})
SkeletonESPToggle:OnChanged(function()
Settings.SkeletonESP = SkeletonESPToggle.Value
end)

local SkeletonColor = SkeletonSection:AddColorpicker("SkeletonColor", {

Title = "Skeleton Color",
Default = Settings.SkeletonColor
})
SkeletonColor:OnChanged(function(Value)
Settings.SkeletonColor = Value
for _, player in ipairs(Players:GetPlayers()) do
local skeleton = Drawings.Skeleton[player]
if skeleton then
for _, line in pairs(skeleton) do
line.Color = Value
end
end
end
end)

local SkeletonThickness = SkeletonSection:AddSlider("SkeletonThickness", {

Title = "Line Thickness",
Default = 1,
Min = 1,
Max = 3,
Rounding = 1
})
SkeletonThickness:OnChanged(function(Value)
Settings.SkeletonThickness = Value
for _, player in ipairs(Players:GetPlayers()) do
local skeleton = Drawings.Skeleton[player]
if skeleton then
for _, line in pairs(skeleton) do
line.Thickness = Value
end
end
 end
end)

local SkeletonTransparency = SkeletonSection:AddSlider("SkeletonTransparency", {

Title = "Transparency",
Default = 1,
Min = 0,
Max = 1,
Rounding = 2
})
SkeletonTransparency:OnChanged(function(Value)
Settings.SkeletonTransparency = Value
for _, player in ipairs(Players:GetPlayers()) do
local skeleton = Drawings.Skeleton[player]
if skeleton then
for _, line in pairs(skeleton) do
line.Transparency = Value
end
end
end
end)
end)