-- Variables

local FillColor = Color3.fromRGB(0, 138, 142)

local DepthMode = "AlwaysOnTop"
local FillTransparency = 0.5
local OutlineColor = Color3.fromRGB(255, 255, 255)
local OutlineTransparency = 0
local CoreGui = game:FindService("CoreGui")
local Players = game:FindService("Players")
local connections = {}

local Storage = Instance.new("Folder")

Storage.Parent = CoreGui
Storage.Name = "Highlight_Storage"

local players = cloneref(game:GetService("Players"))

local client = players.LocalPlayer
local camera = workspace.CurrentCamera

getgenv().global = getgenv()

function global.declare(self, index, value, check)

if self[index] == nil then
self[index] = value
elseif check then
local methods = { "remove", "Disconnect" }

for _, method in methods do

pcall(function()
value[method](value)
end)
end
end

return self[index]
end

declare(global, "services", {})

function global.get(service)
return services[service]
end

declare(declare(services, "loop", {}), "cache", {})

get("loop").new = function(self, index, func, disabled)

if disabled == nil and (func == nil or typeof(func) == "boolean") then
disabled = func func = index
end

self.cache[index] = {
["enabled"] = (not disabled),
["func"] = func,
["toggle"] = function(self, boolean)
if boolean == nil then
self.enabled = not self.enabled
else
self.enabled = boolean
end
end,
 ["remove"] = function()
self.cache[index] = nil
end
}

return self.cache[index]
end

declare(get("loop"), "connection",
cloneref(game:GetService("RunService")).RenderStepped:Connect(function(delta)
for _, loop in get("loop").cache do
if loop.enabled then
local success, result = pcall(function()
loop.func(delta)
end)

if not success then

warn(result)
end
end
end
end), true)

declare(services, "new", {})

get("new").drawing = function(class, properties)

local drawing = Drawing.new(class)
for property, value in properties do
pcall(function()
drawing[property] = value
end)
end
return drawing
end

declare(declare(services, "player", {}), "cache", {})

get("player").find = function(self, player)

for character, data in self.cache do
if data.player == player then
return character
end
end
end

get("player").check = function(self, player)

local success, check = pcall(function()
local character = player:IsA("Player") and player.Character or player
local children =
{character.WorldCharacter:WaitForChild('HumanoidRootPart')}

return children and character.Parent ~= nil

end)

return success and check

end

get("player").new = function(self, player)

-- Prevent applying ESP to local player
 if player == client then return end

local function cache(character)

print("caching", character)
self.cache[character] = {
["player"] = player,
["drawings"] = {
["box"] = get("new").drawing("Square", { Visible = false }),
["boxFilled"] = get("new").drawing("Square", { Visible = false,
Filled = true }),
["boxOutline"] = get("new").drawing("Square", { Visible = false }),
["name"] = get("new").drawing("Text", { Visible = false, Center =
true}),
["distance"] = get("new").drawing("Text", { Visible = false, Center
= true}),
},
["highlight"] = nil
}

local Highlight = Instance.new("Highlight")

Highlight.Name = player.Name
Highlight.FillColor = FillColor
Highlight.DepthMode = DepthMode
Highlight.FillTransparency = FillTransparency
Highlight.OutlineColor = OutlineColor
Highlight.OutlineTransparency = OutlineTransparency
Highlight.Parent = Storage
if character then
Highlight.Adornee = character
end
self.cache[character].highlight = Highlight
connections[player] = player.CharacterAdded:Connect(function(char)
Highlight.Adornee = char
end)
end

local function check(character)

if self:check(character) then
cache(character)
else
local listener
listener = character.ChildAdded:Connect(function()
if self:check(character) then
cache(character) listener:Disconnect()
end
end)
end
end

if player.Character then check(player.Character) end

player.CharacterAdded:Connect(check)
end

get("player").remove = function(self, player)

if player:IsA("Player") then
local character = self:find(player)
if character then
self:remove(character)
end
 else
local data = self.cache[player]
local drawings = data.drawings
local highlight = data.highlight

self.cache[player] = nil

for _, drawing in drawings do

drawing:Remove()
end

if highlight then
highlight:Destroy()
end

if connections[player] then
connections[player]:Disconnect()
end
end
end

get("player").update = function(self, character, data)

if not self:check(character) then
self:remove(character)
end

local player = data.player

local root = character.WorldCharacter:WaitForChild('HumanoidRootPart')
local drawings = data.drawings

if self:check(client) then
data.distance =
(client.Character.WorldCharacter.HumanoidRootPart.CFrame.Position -
root.CFrame.Position).Magnitude
end

task.spawn(function()
local position, visible = camera:WorldToViewportPoint(root.CFrame.Position)

local visuals = features.visuals

local function check()

local team
if visuals.teamCheck then team = player.Team ~= client.Team else team =
true end
return visuals.enabled and data.distance and data.distance <=
visuals.renderDistance and team
end

local function color(color)

if visuals.teamColor then
color = player.TeamColor.Color
end
return color
end

if visible and check() then

local scale = 1 / (position.Z * math.tan(math.rad(camera.FieldOfView *
0.5)) * 2) * 1000
 local width, height = math.floor(4.5 * scale), math.floor(6 * scale)
local x, y = math.floor(position.X), math.floor(position.Y)
local xPosition, yPosition = math.floor(x - width * 0.5), math.floor((y
- height * 0.5) + (0.5 * scale))

drawings.box.Size = Vector2.new(width, height)

drawings.box.Position = Vector2.new(xPosition, yPosition)
drawings.boxFilled.Size = drawings.box.Size
drawings.boxFilled.Position = drawings.box.Position
drawings.boxOutline.Size = drawings.box.Size
drawings.boxOutline.Position = drawings.box.Position

drawings.box.Color = color(visuals.boxes.color)
drawings.box.Thickness = 1
drawings.boxFilled.Color = color(visuals.boxes.filled.color)
drawings.boxFilled.Transparency = visuals.boxes.filled.transparency
drawings.boxOutline.Color = visuals.boxes.outline.color
drawings.boxOutline.Thickness = 3

drawings.boxOutline.ZIndex = drawings.box.ZIndex - 1
drawings.boxFilled.ZIndex = drawings.boxOutline.ZIndex - 1

drawings.name.Text = `[ {player.Name} ]`
drawings.name.Size = math.max(math.min(math.abs(12.5 * scale), 12.5),
10)
drawings.name.Position = Vector2.new(x, (yPosition -
drawings.name.TextBounds.Y) - 2)
drawings.name.Color = color(visuals.names.color)
drawings.name.Outline = visuals.names.outline.enabled
drawings.name.OutlineColor = visuals.names.outline.color

drawings.name.ZIndex = drawings.box.ZIndex + 1

drawings.distance.Text = `[ {math.floor(data.distance)} ]`
drawings.distance.Size = math.max(math.min(math.abs(11 * scale), 11),
10)
drawings.distance.Position = Vector2.new(x, (yPosition + height) +
(drawings.distance.TextBounds.Y * 0.25))
drawings.distance.Color = color(visuals.distance.color)
drawings.distance.Outline = visuals.distance.outline.enabled
drawings.distance.OutlineColor = visuals.distance.outline.color
end

drawings.box.Visible = (check() and visible and visuals.boxes.enabled)

drawings.boxFilled.Visible = (check() and drawings.box.Visible and
visuals.boxes.filled.enabled)
drawings.boxOutline.Visible = (check() and drawings.box.Visible and
visuals.boxes.outline.enabled)
drawings.name.Visible = (check() and visible and visuals.names.enabled)
drawings.distance.Visible = (check() and visible and
visuals.distance.enabled)
end)
end

declare(get("player"), "loop", get("loop"):new(function ()

for character, data in get("player").cache do
get("player"):update(character, data)
end
end), true)
declare(global, "features", {})

features.toggle = function(self, feature, boolean)

if self[feature] then
if boolean == nil then
self[feature].enabled = not self[feature].enabled
else
self[feature].enabled = boolean
end

if self[feature].toggle then
task.spawn(function()
self[feature]:toggle()
end)
end
end
end

declare(features, "visuals", {
["enabled"] = true,
["teamCheck"] = false,
["teamColor"] = true,
["renderDistance"] = 4000,

["boxes"] = {
["enabled"] = true,
["color"] = Color3.fromRGB(255, 255, 255),
["outline"] = {
["enabled"] = true,
["color"] = Color3.fromRGB(0, 0, 0),
},
["filled"] = {
["enabled"] = false,
["color"] = Color3.fromRGB(255, 255, 255),
["transparency"] = 0.25
},
},
["names"] = {
["enabled"] = true,
["color"] = Color3.fromRGB(255, 255, 255),
["outline"] = {
["enabled"] = true,
["color"] = Color3.fromRGB(0, 0, 0),
},
},
["distance"] = {
["enabled"] = true,
["color"] = Color3.fromRGB(255, 255, 255),
["outline"] = {
["enabled"] = true,
["color"] = Color3.fromRGB(0, 0, 0),
},
},
})

for _, player in players:GetPlayers() do

if player ~= client and not get("player"):find(player) then
get("player"):new(player)
 end
end

declare(get('player'), 'added', workspace.ChildAdded:Connect(function(player)

if players:FindFirstChild(player.Name) then
if not get("player"):find(players[player.Name]) then
get("player"):new(players[player.Name])
end
end
end), true)

declare(get('player'), 'removing', workspace.ChildRemoved:Connect(function(player)

if players:FindFirstChild(player.Name) then
get("player"):remove(players[player.Name])
end
end), true)