BILLBOARD ESP Opened source

WindUI = loadstring(game:HttpGet("https://github.com/Footagesus/WindUI/releases/latest/download/main.lua"))()
Window = WindUI:CreateWindow({
    Title = "",
    Icon = "",
    Author = "",
    Size = UDim2.fromOffset(580, 490),
    Theme = "Dark",
    HidePanelBackground = false,
    HideSearchBar = true,
    SideBarWidth = 200
})
Tabs = {
    ESP = Window:Tab({ 
        Title = "", 
        Icon = "" 
    })  
}
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local Workspace = game:GetService("Workspace")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local UserInputService = game:GetService("UserInputService")
local LocalPlayer = Players.LocalPlayer

playerEspElements = {}
nextbotEspElements = {}
downedEspElements = {}
ticketEspElements = {}
vehicleEspElements = {}

playerBoxesEnabled = false
playerNamesEnabled = false
playerDistanceEnabled = false
playerHighlightsEnabled = false
playerBoxType = "2D"

nextbotBoxesEnabled = false
nextbotNamesEnabled = false
nextbotDistanceEnabled = false
nextbotHighlightsEnabled = false
nextbotBoxType = "2D"

downedBoxesEnabled = false
downedNamesEnabled = false
downedDistanceEnabled = false
downedHighlightsEnabled = false
downedBoxType = "2D"

ticketBoxesEnabled = false
ticketNamesEnabled = false
ticketDistanceEnabled = false
ticketHighlightsEnabled = false
ticketBoxType = "2D"

vehicleBoxesEnabled = false
vehicleNamesEnabled = false
vehicleDistanceEnabled = false
vehicleHighlightsEnabled = false
vehicleBoxType = "2D"

innocentBots = {"Turkey", "Lupen"}
isRendering = true
windowFocused = true

function isInnocentBot(modelName)
for _, name in ipairs(innocentBots) do
if modelName == name then
return true
end
end
return false
end

nextBotNames = {}
if ReplicatedStorage:FindFirstChild("NPCs") then
for _, npc in ipairs(ReplicatedStorage.NPCs:GetChildren()) do
table.insert(nextBotNames, npc.Name)
end
end

function isNextbotModel(model)
if not model or not model.Name then return false end
for _, name in ipairs(nextBotNames) do
if model.Name == name then return true end
end
return false
end

function isPlayerNextbot(player)
if not player or not player.Character then return false end
local team = player.Character:GetAttribute("Team")
if team == "Nextbot" then
return true
end
return false
end

function getDistanceFromCamera(targetPosition)
local camera = workspace.CurrentCamera
if not camera then return 0 end
return (targetPosition - camera.CFrame.Position).Magnitude
end

function calculateBoxScale(distance)
if distance <= 17 then
return 1
else
local scale = 17 / distance
return math.max(scale, 0.3)
end
end

function getPlayerTeam(player)
local character = player.Character
if character then
local team = character:GetAttribute("Team")
if team then
return team
end
end
return nil
end

function getAttachPoint(character)
local rootPart = character:FindFirstChild("HumanoidRootPart")
if rootPart then
return rootPart
end
return character
end

function create3DBox(character, color, size)
local rootPart = character:FindFirstChild("HumanoidRootPart")
if not rootPart then return nil end

local folderName = "ESP_3DBox"
local folder = character:FindFirstChild(folderName)
if folder then
folder:Destroy()
end

folder = Instance.new("Folder")
folder.Name = folderName
folder.Parent = character

size = size or Vector3.new(4, 5, 3)
local offsetX = size.X / 2
local offsetY = size.Y / 2
local offsetZ = size.Z / 2

local edges = {
{Vector3.new(0, offsetY, offsetZ), Vector3.new(size.X, 0.1, 0.1), "TopFront"},
{Vector3.new(0, offsetY, -offsetZ), Vector3.new(size.X, 0.1, 0.1), "TopBack"},
{Vector3.new(-offsetX, offsetY, 0), Vector3.new(0.1, 0.1, size.Z), "TopLeft"},
{Vector3.new(offsetX, offsetY, 0), Vector3.new(0.1, 0.1, size.Z), "TopRight"},
{Vector3.new(0, -offsetY, offsetZ), Vector3.new(size.X, 0.1, 0.1), "BottomFront"},
{Vector3.new(0, -offsetY, -offsetZ), Vector3.new(size.X, 0.1, 0.1), "BottomBack"},
{Vector3.new(-offsetX, -offsetY, 0), Vector3.new(0.1, 0.1, size.Z), "BottomLeft"},
{Vector3.new(offsetX, -offsetY, 0), Vector3.new(0.1, 0.1, size.Z), "BottomRight"},
{Vector3.new(-offsetX, 0, offsetZ), Vector3.new(0.1, size.Y, 0.1), "FrontLeft"},
{Vector3.new(offsetX, 0, offsetZ), Vector3.new(0.1, size.Y, 0.1), "FrontRight"},
{Vector3.new(-offsetX, 0, -offsetZ), Vector3.new(0.1, size.Y, 0.1), "BackLeft"},
{Vector3.new(offsetX, 0, -offsetZ), Vector3.new(0.1, size.Y, 0.1), "BackRight"}
}

for _, edge in ipairs(edges) do
local position = edge[1]
local boxSize = edge[2]
local name = edge[3]

local adornment = Instance.new("BoxHandleAdornment")
adornment.Name = name
adornment.Adornee = rootPart
adornment.Size = boxSize
adornment.CFrame = CFrame.new(position)
adornment.Color3 = color
adornment.Transparency = 0.2
adornment.ZIndex = 10
adornment.AlwaysOnTop = true
adornment.Visible = true
adornment.Parent = folder
end

return folder
end

function update3DBoxColor(character, color)
local folder = character:FindFirstChild("ESP_3DBox")
if folder then
for _, adornment in ipairs(folder:GetChildren()) do
if adornment:IsA("BoxHandleAdornment") then
adornment.Color3 = color
end
end
end
end

function remove3DBox(character)
local folder = character:FindFirstChild("ESP_3DBox")
if folder then
folder:Destroy()
end
end

function createBillboard(character, name, color, useModelParent)
local existing = character:FindFirstChild("ESP_Billboard")
if existing then
existing:Destroy()
end

local billboard = Instance.new("BillboardGui")
billboard.Name = "ESP_Billboard"

if useModelParent then
billboard.Adornee = character
billboard.Parent = character
else
local rootPart = character:FindFirstChild("HumanoidRootPart")
if rootPart then
billboard.Adornee = rootPart
billboard.Parent = rootPart
else
billboard.Adornee = character
billboard.Parent = character
end
end

billboard.AlwaysOnTop = true
billboard.Size = UDim2.new(0, 200, 0, 50)
billboard.StudsOffset = Vector3.new(0, 3, 0)
billboard.ClipsDescendants = false
billboard.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
billboard.Active = true

local mainFrame = Instance.new("Frame")
mainFrame.Name = "MainFrame"
mainFrame.Size = UDim2.new(1, 0, 1, 0)
mainFrame.BackgroundTransparency = 1
mainFrame.Parent = billboard

local nameLabel = Instance.new("TextLabel")
nameLabel.Name = "NameLabel"
nameLabel.Size = UDim2.new(1, 0, 0, 20)
nameLabel.Position = UDim2.new(0, 0, 0, 0)
nameLabel.BackgroundTransparency = 1
nameLabel.Text = name
nameLabel.TextColor3 = color
nameLabel.TextSize = 14
nameLabel.Font = Enum.Font.GothamSemibold
nameLabel.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
nameLabel.TextStrokeTransparency = 0.3
nameLabel.TextXAlignment = Enum.TextXAlignment.Center
nameLabel.TextYAlignment = Enum.TextYAlignment.Bottom
nameLabel.Parent = mainFrame

local distanceLabel = Instance.new("TextLabel")
distanceLabel.Name = "DistanceLabel"
distanceLabel.Size = UDim2.new(1, 0, 0, 16)
distanceLabel.Position = UDim2.new(0, 0, 0, 20)
distanceLabel.BackgroundTransparency = 1
distanceLabel.Text = ""
distanceLabel.TextColor3 = color
distanceLabel.TextSize = 12
distanceLabel.Font = Enum.Font.Gotham
distanceLabel.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
distanceLabel.TextStrokeTransparency = 0.3
distanceLabel.TextXAlignment = Enum.TextXAlignment.Center
distanceLabel.TextYAlignment = Enum.TextYAlignment.Top
distanceLabel.Parent = mainFrame

return {
billboard = billboard,
nameLabel = nameLabel,
distanceLabel = distanceLabel
}
end

function updateBillboard(billboardData, name, distance, color)
if not billboardData then return end

if name then
billboardData.nameLabel.Text = name
billboardData.nameLabel.TextColor3 = color
end

if distance then
billboardData.distanceLabel.Text = string.format("%.1f studs", distance)
billboardData.distanceLabel.TextColor3 = color
end

billboardData.nameLabel.Visible = name ~= nil
billboardData.distanceLabel.Visible = distance ~= nil
end

function create2DBox(character, color, scale, useModelParent)
local existing = character:FindFirstChild("ESP_2DBox")
if existing then
existing:Destroy()
end

local billboard = Instance.new("BillboardGui")
billboard.Name = "ESP_2DBox"

if useModelParent then
billboard.Adornee = character
billboard.Parent = character
else
local rootPart = character:FindFirstChild("HumanoidRootPart")
if rootPart then
billboard.Adornee = rootPart
billboard.Parent = rootPart
else
billboard.Adornee = character
billboard.Parent = character
end
end

billboard.AlwaysOnTop = true
billboard.Size = UDim2.new(0, 80 * scale, 0, 100 * scale)
billboard.StudsOffset = Vector3.new(0, 0, 0)
billboard.ClipsDescendants = false

local boxFrame = Instance.new("Frame")
boxFrame.Name = "BoxFrame"
boxFrame.Size = UDim2.new(1, 0, 1, 0)
boxFrame.BackgroundTransparency = 1
boxFrame.BorderSizePixel = 0
boxFrame.Parent = billboard

local uiStroke = Instance.new("UIStroke")
uiStroke.Thickness = math.max(1.5 * scale, 1)
uiStroke.Transparency = 0
uiStroke.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
uiStroke.Color = color
uiStroke.Parent = boxFrame

return {
billboard = billboard,
boxFrame = boxFrame,
stroke = uiStroke,
scale = scale
}
end

function update2DBox(boxData, color, scale)
if boxData then
if boxData.stroke then
boxData.stroke.Color = color
end
if boxData.billboard then
boxData.billboard.Size = UDim2.new(0, 80 * scale, 0, 100 * scale)
end
if boxData.stroke then
boxData.stroke.Thickness = math.max(1.5 * scale, 1)
end
boxData.scale = scale
end
end

function remove2DBox(character)
local box = character:FindFirstChild("ESP_2DBox")
if box then
box:Destroy()
end
local rootPart = character:FindFirstChild("HumanoidRootPart")
if rootPart then
local boxInRoot = rootPart:FindFirstChild("ESP_2DBox")
if boxInRoot then
boxInRoot:Destroy()
end
end
end

function createHighlight(character, color)
local existing = character:FindFirstChild("ESP_Highlight")
if existing then
existing:Destroy()
end

local highlight = Instance.new("Highlight")
highlight.Name = "ESP_Highlight"
highlight.Adornee = character
highlight.FillColor = color
highlight.OutlineColor = color
highlight.FillTransparency = 0.5
highlight.OutlineTransparency = 0.3
highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
highlight.Parent = character

return highlight
end

function updateHighlight(highlight, color)
if highlight then
highlight.FillColor = color
highlight.OutlineColor = color
end
end

function removeHighlight(character)
local highlight = character:FindFirstChild("ESP_Highlight")
if highlight then
highlight:Destroy()
end
end

function getPlayerColor(player)
if isInnocentBot(player.Name) then
return Color3.fromRGB(255, 255, 255)
end

if isPlayerNextbot(player) then
return Color3.fromRGB(255, 0, 0)
end

local team = getPlayerTeam(player)
if team == "Nextbot" then
return Color3.fromRGB(255, 0, 0)
end

return Color3.fromRGB(0, 255, 0)
end

function getNextbotColor(model)
if isInnocentBot(model.Name) then
return Color3.fromRGB(255, 255, 255)
end
return Color3.fromRGB(255, 0, 0)
end

function getDownedColor()
return Color3.fromRGB(255, 165, 0)
end

function getTicketColor()
return Color3.fromRGB(156, 39, 176)
end

function getVehicleColor(vehicle)
return Color3.fromRGB(0, 255, 255)
end

function cleanupPlayerESP()
for character, esp in pairs(playerEspElements) do
if esp.box2D then
local box = character:FindFirstChild("ESP_2DBox")
if box then box:Destroy() end
local rootPart = character:FindFirstChild("HumanoidRootPart")
if rootPart then
local boxInRoot = rootPart:FindFirstChild("ESP_2DBox")
if boxInRoot then boxInRoot:Destroy() end
end
end
if esp.box3D then remove3DBox(character) end
if esp.highlight then removeHighlight(character) end
if esp.billboard then
local bill = character:FindFirstChild("ESP_Billboard")
if bill then bill:Destroy() end
local rootPart = character:FindFirstChild("HumanoidRootPart")
if rootPart then
local billInRoot = rootPart:FindFirstChild("ESP_Billboard")
if billInRoot then billInRoot:Destroy() end
end
end
end
playerEspElements = {}
end

function cleanupNextbotESP()
for model, esp in pairs(nextbotEspElements) do
if esp.box2D then
local box = model:FindFirstChild("ESP_2DBox")
if box then box:Destroy() end
end
if esp.box3D then remove3DBox(model) end
if esp.highlight then removeHighlight(model) end
if esp.billboard then
local bill = model:FindFirstChild("ESP_Billboard")
if bill then bill:Destroy() end
end
end
nextbotEspElements = {}
end

function cleanupDownedESP()
for char, esp in pairs(downedEspElements) do
if esp.box2D then
local box = char:FindFirstChild("ESP_2DBox")
if box then box:Destroy() end
local rootPart = char:FindFirstChild("HumanoidRootPart")
if rootPart then
local boxInRoot = rootPart:FindFirstChild("ESP_2DBox")
if boxInRoot then boxInRoot:Destroy() end
end
end
if esp.box3D then remove3DBox(char) end
if esp.highlight then removeHighlight(char) end
if esp.billboard then
local bill = char:FindFirstChild("ESP_Billboard")
if bill then bill:Destroy() end
local rootPart = char:FindFirstChild("HumanoidRootPart")
if rootPart then
local billInRoot = rootPart:FindFirstChild("ESP_Billboard")
if billInRoot then billInRoot:Destroy() end
end
end
end
downedEspElements = {}
end

function cleanupTicketESP()
for ticket, esp in pairs(ticketEspElements) do
if esp.box2D then
local box = ticket:FindFirstChild("ESP_2DBox")
if box then box:Destroy() end
local rootPart = ticket:FindFirstChild("HumanoidRootPart")
if rootPart then
local boxInRoot = rootPart:FindFirstChild("ESP_2DBox")
if boxInRoot then boxInRoot:Destroy() end
end
end
if esp.box3D then remove3DBox(ticket) end
if esp.highlight then removeHighlight(ticket) end
if esp.billboard then
local bill = ticket:FindFirstChild("ESP_Billboard")
if bill then bill:Destroy() end
local rootPart = ticket:FindFirstChild("HumanoidRootPart")
if rootPart then
local billInRoot = rootPart:FindFirstChild("ESP_Billboard")
if billInRoot then billInRoot:Destroy() end
end
end
end
ticketEspElements = {}
end

function cleanupVehicleESP()
for vehicle, esp in pairs(vehicleEspElements) do
if esp.box2D then
local box = vehicle:FindFirstChild("ESP_2DBox")
if box then box:Destroy() end
local rootPart = vehicle:FindFirstChild("HumanoidRootPart")
if rootPart then
local boxInRoot = rootPart:FindFirstChild("ESP_2DBox")
if boxInRoot then boxInRoot:Destroy() end
end
end
if esp.box3D then remove3DBox(vehicle) end
if esp.highlight then removeHighlight(vehicle) end
if esp.billboard then
local bill = vehicle:FindFirstChild("ESP_Billboard")
if bill then bill:Destroy() end
local rootPart = vehicle:FindFirstChild("HumanoidRootPart")
if rootPart then
local billInRoot = rootPart:FindFirstChild("ESP_Billboard")
if billInRoot then billInRoot:Destroy() end
end
end
end
vehicleEspElements = {}
end

function updatePlayerESP()
if not isRendering or not windowFocused then return end
if not workspace.CurrentCamera then return end

local currentTargets = {}

for _, otherPlayer in ipairs(Players:GetPlayers()) do
if otherPlayer ~= LocalPlayer then
local character = otherPlayer.Character
if character and character:FindFirstChild("HumanoidRootPart") then
local humanoid = character:FindFirstChild("Humanoid")
if humanoid and humanoid.Health > 0 then
currentTargets[character] = true

if not playerEspElements[character] then
playerEspElements[character] = {}
end

local esp = playerEspElements[character]
local distance = getDistanceFromCamera(character.HumanoidRootPart.Position)
local scale = calculateBoxScale(distance)
local boxColor = getPlayerColor(otherPlayer)
local isNextbotPlayer = isPlayerNextbot(otherPlayer)

if playerBoxesEnabled then
if playerBoxType == "2D" then
if not esp.box2D then
esp.box2D = create2DBox(character, boxColor, scale, isNextbotPlayer)
end
update2DBox(esp.box2D, boxColor, scale)
if esp.box3D then
remove3DBox(character)
esp.box3D = nil
end
else
local boxSize = Vector3.new(4, 5, 3)
if humanoid then
boxSize = Vector3.new(2, humanoid.HipHeight + 5, 2)
end
if not esp.box3D then
esp.box3D = create3DBox(character, boxColor, boxSize)
end
update3DBoxColor(character, boxColor)
if esp.box2D then
remove2DBox(character)
esp.box2D = nil
end
end
else
if esp.box2D then
remove2DBox(character)
esp.box2D = nil
end
if esp.box3D then
remove3DBox(character)
esp.box3D = nil
end
end

if playerHighlightsEnabled then
if not esp.highlight then
esp.highlight = createHighlight(character, boxColor)
end
updateHighlight(esp.highlight, boxColor)
else
if esp.highlight then
removeHighlight(character)
esp.highlight = nil
end
end

if playerNamesEnabled or playerDistanceEnabled then
if not esp.billboard then
esp.billboard = createBillboard(character, otherPlayer.Name, boxColor, isNextbotPlayer)
end
local displayDistance = playerDistanceEnabled and distance or nil
updateBillboard(esp.billboard, playerNamesEnabled and otherPlayer.Name or nil, displayDistance, boxColor)
else
if esp.billboard then
local bill = character:FindFirstChild("ESP_Billboard")
if bill then bill:Destroy() end
local rootPart = character:FindFirstChild("HumanoidRootPart")
if rootPart then
local billInRoot = rootPart:FindFirstChild("ESP_Billboard")
if billInRoot then billInRoot:Destroy() end
end
esp.billboard = nil
end
end
end
end
end
end

for character, esp in pairs(playerEspElements) do
if not currentTargets[character] then
if esp.box2D then remove2DBox(character) end
if esp.box3D then remove3DBox(character) end
if esp.highlight then removeHighlight(character) end
if esp.billboard then
local bill = character:FindFirstChild("ESP_Billboard")
if bill then bill:Destroy() end
local rootPart = character:FindFirstChild("HumanoidRootPart")
if rootPart then
local billInRoot = rootPart:FindFirstChild("ESP_Billboard")
if billInRoot then billInRoot:Destroy() end
end
end
playerEspElements[character] = nil
end
end
end

function updateNextbotESP()
if not isRendering or not windowFocused then return end
if not workspace.CurrentCamera then return end

local currentTargets = {}

local function processModel(model)
if not model or not model:IsA("Model") or not model:FindFirstChild("HumanoidRootPart") then return end
if not isNextbotModel(model) then return end

currentTargets[model] = true

if not nextbotEspElements[model] then
nextbotEspElements[model] = {}
end

local esp = nextbotEspElements[model]
local distance = getDistanceFromCamera(model.HumanoidRootPart.Position)
local scale = calculateBoxScale(distance)
local boxColor = getNextbotColor(model)

if nextbotBoxesEnabled then
if nextbotBoxType == "2D" then
if not esp.box2D then
esp.box2D = create2DBox(model, boxColor, scale, true)
end
update2DBox(esp.box2D, boxColor, scale)
if esp.box3D then
remove3DBox(model)
esp.box3D = nil
end
else
local humanoid = model:FindFirstChild("Humanoid")
local boxSize = Vector3.new(4, 5, 3)
if humanoid then
boxSize = Vector3.new(2, humanoid.HipHeight + 5, 2)
end
if not esp.box3D then
esp.box3D = create3DBox(model, boxColor, boxSize)
end
update3DBoxColor(model, boxColor)
if esp.box2D then
remove2DBox(model)
esp.box2D = nil
end
end
else
if esp.box2D then remove2DBox(model) end
if esp.box3D then remove3DBox(model) end
end

if nextbotHighlightsEnabled then
if not esp.highlight then
esp.highlight = createHighlight(model, boxColor)
end
updateHighlight(esp.highlight, boxColor)
else
if esp.highlight then
removeHighlight(model)
esp.highlight = nil
end
end

if nextbotNamesEnabled or nextbotDistanceEnabled then
if not esp.billboard then
esp.billboard = createBillboard(model, model.Name, boxColor, true)
end
local displayDistance = nextbotDistanceEnabled and distance or nil
updateBillboard(esp.billboard, nextbotNamesEnabled and model.Name or nil, displayDistance, boxColor)
else
if esp.billboard then
local bill = model:FindFirstChild("ESP_Billboard")
if bill then bill:Destroy() end
esp.billboard = nil
end
end
end

if workspace:FindFirstChild("Game") and workspace.Game:FindFirstChild("Players") then
for _, model in pairs(workspace.Game.Players:GetChildren()) do
processModel(model)
end
end
if workspace:FindFirstChild("NPCs") then
for _, model in pairs(workspace.NPCs:GetChildren()) do
processModel(model)
end
end

for model, esp in pairs(nextbotEspElements) do
if not currentTargets[model] then
if esp.box2D then remove2DBox(model) end
if esp.box3D then remove3DBox(model) end
if esp.highlight then removeHighlight(model) end
if esp.billboard then
local bill = model:FindFirstChild("ESP_Billboard")
if bill then bill:Destroy() end
end
nextbotEspElements[model] = nil
end
end
end

function updateDownedESP()
if not isRendering or not windowFocused then return end
if not workspace.CurrentCamera then return end

local currentTargets = {}
local folder = workspace:FindFirstChild("Game") and workspace.Game:FindFirstChild("Players")

if folder then
for _, char in ipairs(folder:GetChildren()) do
if char:IsA("Model") then
local team = char:GetAttribute("Team")
local downed = char:GetAttribute("Downed")
if team ~= "Nextbot" and char.Name ~= LocalPlayer.Name and downed == true then
local hrp = char:FindFirstChild("HumanoidRootPart")
if hrp then
currentTargets[char] = true

if not downedEspElements[char] then
downedEspElements[char] = {}
end

local esp = downedEspElements[char]
local distance = getDistanceFromCamera(hrp.Position)
local scale = calculateBoxScale(distance)
local color = getDownedColor()
local isNextbotPlayer = isPlayerNextbot(Players:GetPlayerFromCharacter(char))

if downedBoxesEnabled then
if downedBoxType == "2D" then
if not esp.box2D then
esp.box2D = create2DBox(char, color, scale, isNextbotPlayer)
end
update2DBox(esp.box2D, color, scale)
if esp.box3D then
remove3DBox(char)
esp.box3D = nil
end
else
if not esp.box3D then
esp.box3D = create3DBox(char, color, Vector3.new(3, 5, 2))
end
update3DBoxColor(char, color)
if esp.box2D then
remove2DBox(char)
esp.box2D = nil
end
end
else
if esp.box2D then remove2DBox(char) end
if esp.box3D then remove3DBox(char) end
end

if downedHighlightsEnabled then
if not esp.highlight then
esp.highlight = createHighlight(char, color)
end
updateHighlight(esp.highlight, color)
else
if esp.highlight then
removeHighlight(char)
esp.highlight = nil
end
end

if downedNamesEnabled or downedDistanceEnabled then
if not esp.billboard then
esp.billboard = createBillboard(char, char.Name, color, isNextbotPlayer)
end
local displayDistance = downedDistanceEnabled and distance or nil
updateBillboard(esp.billboard, downedNamesEnabled and char.Name or nil, displayDistance, color)
else
if esp.billboard then
local bill = char:FindFirstChild("ESP_Billboard")
if bill then bill:Destroy() end
local rootPart = char:FindFirstChild("HumanoidRootPart")
if rootPart then
local billInRoot = rootPart:FindFirstChild("ESP_Billboard")
if billInRoot then billInRoot:Destroy() end
end
esp.billboard = nil
end
end
end
end
end
end
end

for char, esp in pairs(downedEspElements) do
if not currentTargets[char] then
if esp.box2D then remove2DBox(char) end
if esp.box3D then remove3DBox(char) end
if esp.highlight then removeHighlight(char) end
if esp.billboard then
local bill = char:FindFirstChild("ESP_Billboard")
if bill then bill:Destroy() end
local rootPart = char:FindFirstChild("HumanoidRootPart")
if rootPart then
local billInRoot = rootPart:FindFirstChild("ESP_Billboard")
if billInRoot then billInRoot:Destroy() end
end
end
downedEspElements[char] = nil
end
end
end

function updateTicketESP()
if not isRendering or not windowFocused then return end
if not workspace.CurrentCamera then return end

local currentTargets = {}
local tickets = workspace:FindFirstChild("Game") and workspace.Game:FindFirstChild("Effects") and workspace.Game.Effects:FindFirstChild("Tickets")
local brightPurple = getTicketColor()

if tickets then
for _, ticket in ipairs(tickets:GetChildren()) do
if ticket:IsA("Model") and ticket:FindFirstChild("HumanoidRootPart") then
currentTargets[ticket] = true

if not ticketEspElements[ticket] then
ticketEspElements[ticket] = {}
end

local esp = ticketEspElements[ticket]
local distance = getDistanceFromCamera(ticket.HumanoidRootPart.Position)
local scale = calculateBoxScale(distance)

if ticketBoxesEnabled then
if ticketBoxType == "2D" then
if not esp.box2D then
esp.box2D = create2DBox(ticket, brightPurple, scale, false)
end
update2DBox(esp.box2D, brightPurple, scale)
if esp.box3D then
remove3DBox(ticket)
esp.box3D = nil
end
else
if not esp.box3D then
esp.box3D = create3DBox(ticket, brightPurple, Vector3.new(4, 4, 4))
end
update3DBoxColor(ticket, brightPurple)
if esp.box2D then
remove2DBox(ticket)
esp.box2D = nil
end
end
else
if esp.box2D then remove2DBox(ticket) end
if esp.box3D then remove3DBox(ticket) end
end

if ticketHighlightsEnabled then
if not esp.highlight then
esp.highlight = createHighlight(ticket, brightPurple)
end
updateHighlight(esp.highlight, brightPurple)
else
if esp.highlight then
removeHighlight(ticket)
esp.highlight = nil
end
end

if ticketNamesEnabled or ticketDistanceEnabled then
if not esp.billboard then
esp.billboard = createBillboard(ticket, "Ticket", brightPurple, false)
end
local displayDistance = ticketDistanceEnabled and distance or nil
updateBillboard(esp.billboard, ticketNamesEnabled and "Ticket" or nil, displayDistance, brightPurple)
else
if esp.billboard then
local bill = ticket:FindFirstChild("ESP_Billboard")
if bill then bill:Destroy() end
local rootPart = ticket:FindFirstChild("HumanoidRootPart")
if rootPart then
local billInRoot = rootPart:FindFirstChild("ESP_Billboard")
if billInRoot then billInRoot:Destroy() end
end
esp.billboard = nil
end
end
end
end
end

for ticket, esp in pairs(ticketEspElements) do
if not currentTargets[ticket] then
if esp.box2D then remove2DBox(ticket) end
if esp.box3D then remove3DBox(ticket) end
if esp.highlight then removeHighlight(ticket) end
if esp.billboard then
local bill = ticket:FindFirstChild("ESP_Billboard")
if bill then bill:Destroy() end
local rootPart = ticket:FindFirstChild("HumanoidRootPart")
if rootPart then
local billInRoot = rootPart:FindFirstChild("ESP_Billboard")
if billInRoot then billInRoot:Destroy() end
end
end
ticketEspElements[ticket] = nil
end
end
end

function updateVehicleESP()
if not isRendering or not windowFocused then return end
if not workspace.CurrentCamera then return end

local currentTargets = {}
local vehicles = workspace:FindFirstChild("Game") and workspace.Game:FindFirstChild("Vehicles")

if vehicles then
for _, vehicle in ipairs(vehicles:GetChildren()) do
if vehicle:IsA("Model") and vehicle:FindFirstChild("HumanoidRootPart") then
currentTargets[vehicle] = true

if not vehicleEspElements[vehicle] then
vehicleEspElements[vehicle] = {}
end

local esp = vehicleEspElements[vehicle]
local distance = getDistanceFromCamera(vehicle.HumanoidRootPart.Position)
local scale = calculateBoxScale(distance)
local vehicleColor = getVehicleColor(vehicle)
local vehicleName = vehicle.Name or "Vehicle"

if vehicleBoxesEnabled then
if vehicleBoxType == "2D" then
if not esp.box2D then
esp.box2D = create2DBox(vehicle, vehicleColor, scale, false)
end
update2DBox(esp.box2D, vehicleColor, scale)
if esp.box3D then
remove3DBox(vehicle)
esp.box3D = nil
end
else
local boxSize = Vector3.new(8, 4, 12)
local vehicleSize = vehicle:FindFirstChild("Size")
if vehicleSize then
boxSize = vehicleSize.Value
end
if not esp.box3D then
esp.box3D = create3DBox(vehicle, vehicleColor, boxSize)
end
update3DBoxColor(vehicle, vehicleColor)
if esp.box2D then
remove2DBox(vehicle)
esp.box2D = nil
end
end
else
if esp.box2D then remove2DBox(vehicle) end
if esp.box3D then remove3DBox(vehicle) end
end

if vehicleHighlightsEnabled then
if not esp.highlight then
esp.highlight = createHighlight(vehicle, vehicleColor)
end
updateHighlight(esp.highlight, vehicleColor)
else
if esp.highlight then
removeHighlight(vehicle)
esp.highlight = nil
end
end

if vehicleNamesEnabled or vehicleDistanceEnabled then
if not esp.billboard then
esp.billboard = createBillboard(vehicle, vehicleName, vehicleColor, false)
end
local displayDistance = vehicleDistanceEnabled and distance or nil
updateBillboard(esp.billboard, vehicleNamesEnabled and vehicleName or nil, displayDistance, vehicleColor)
else
if esp.billboard then
local bill = vehicle:FindFirstChild("ESP_Billboard")
if bill then bill:Destroy() end
local rootPart = vehicle:FindFirstChild("HumanoidRootPart")
if rootPart then
local billInRoot = rootPart:FindFirstChild("ESP_Billboard")
if billInRoot then billInRoot:Destroy() end
end
esp.billboard = nil
end
end
end
end
end

for vehicle, esp in pairs(vehicleEspElements) do
if not currentTargets[vehicle] then
if esp.box2D then remove2DBox(vehicle) end
if esp.box3D then remove3DBox(vehicle) end
if esp.highlight then removeHighlight(vehicle) end
if esp.billboard then
local bill = vehicle:FindFirstChild("ESP_Billboard")
if bill then bill:Destroy() end
local rootPart = vehicle:FindFirstChild("HumanoidRootPart")
if rootPart then
local billInRoot = rootPart:FindFirstChild("ESP_Billboard")
if billInRoot then billInRoot:Destroy() end
end
end
vehicleEspElements[vehicle] = nil
end
end
end

renderConnection = nil
lastRenderTime = tick()
renderCheckConnection = nil
attributeConnections = {}

function onAttributeChanged(player, attribute)
if attribute == "Team" then
updatePlayerESP()
end
end

function setupAttributeWatchers()
for _, otherPlayer in ipairs(Players:GetPlayers()) do
if otherPlayer ~= LocalPlayer and otherPlayer.Character then
if not attributeConnections[otherPlayer] then
attributeConnections[otherPlayer] = otherPlayer.Character:GetAttributeChangedSignal("Team"):Connect(function()
updatePlayerESP()
end)
end
end
end
end

function onRenderStepped()
lastRenderTime = tick()
isRendering = true

if playerBoxesEnabled or playerNamesEnabled or playerDistanceEnabled or playerHighlightsEnabled then
updatePlayerESP()
else
cleanupPlayerESP()
end

if nextbotBoxesEnabled or nextbotNamesEnabled or nextbotDistanceEnabled or nextbotHighlightsEnabled then
updateNextbotESP()
else
cleanupNextbotESP()
end

if downedBoxesEnabled or downedNamesEnabled or downedDistanceEnabled or downedHighlightsEnabled then
updateDownedESP()
else
cleanupDownedESP()
end

if ticketBoxesEnabled or ticketNamesEnabled or ticketDistanceEnabled or ticketHighlightsEnabled then
updateTicketESP()
else
cleanupTicketESP()
end

if vehicleBoxesEnabled or vehicleNamesEnabled or vehicleDistanceEnabled or vehicleHighlightsEnabled then
updateVehicleESP()
else
cleanupVehicleESP()
end

setupAttributeWatchers()
end

function startRenderLoop()
if renderConnection then return end
renderConnection = RunService.RenderStepped:Connect(onRenderStepped)
end

function stopRenderLoop()
if renderConnection then
renderConnection:Disconnect()
renderConnection = nil
end
end

function setupNextbotDetection()
local function onNextbotAdded(model)
if model:IsA("Model") and isNextbotModel(model) then
task.wait(0.5)
updateNextbotESP()
end
end

if workspace:FindFirstChild("Game") and workspace.Game:FindFirstChild("Players") then
workspace.Game.Players.ChildAdded:Connect(onNextbotAdded)
end
if workspace:FindFirstChild("NPCs") then
workspace.NPCs.ChildAdded:Connect(onNextbotAdded)
end
end

function cleanupAllESP()
cleanupPlayerESP()
cleanupNextbotESP()
cleanupDownedESP()
cleanupTicketESP()
cleanupVehicleESP()

for _, connection in pairs(attributeConnections) do
connection:Disconnect()
end
attributeConnections = {}
end

RunService.RenderStepped:Connect(function()
lastRenderTime = tick()
isRendering = true
end)

renderCheckConnection = RunService.Heartbeat:Connect(function()
local currentTime = tick()
if currentTime - lastRenderTime > 1 then
isRendering = false
cleanupAllESP()
end
end)

UserInputService.WindowFocusReleased:Connect(function()
windowFocused = false
isRendering = false
cleanupAllESP()
end)

UserInputService.WindowFocused:Connect(function()
windowFocused = true
isRendering = true
end)

game:GetService("GuiService"):GetPropertyChangedSignal("MenuIsOpen"):Connect(function()
if game:GetService("GuiService").MenuIsOpen then
isRendering = false
cleanupAllESP()
else
isRendering = true
end
end)

Players.PlayerRemoving:Connect(function(leavingPlayer)
if leavingPlayer == LocalPlayer then
cleanupAllESP()
stopRenderLoop()
end
end)

startRenderLoop()
setupNextbotDetection()

Tabs.ESP:Section({ Title = "Player ESP", TextSize = 20 })
Tabs.ESP:Divider()

Tabs.ESP:Toggle({
Title = "Player Boxes",
Value = false,
Callback = function(state) playerBoxesEnabled = state end
})

Tabs.ESP:Dropdown({
Title = "Player Box Type",
Values = {"2D", "3D"},
Value = "2D",
Callback = function(value) playerBoxType = value end
})

Tabs.ESP:Toggle({
Title = "Player Names",
Value = false,
Callback = function(state) playerNamesEnabled = state end
})

Tabs.ESP:Toggle({
Title = "Player Distance",
Value = false,
Callback = function(state) playerDistanceEnabled = state end
})

Tabs.ESP:Toggle({
Title = "Player Highlights",
Value = false,
Callback = function(state) playerHighlightsEnabled = state end
})

Tabs.ESP:Divider()
Tabs.ESP:Section({ Title = "Nextbot ESP", TextSize = 20 })
Tabs.ESP:Divider()

Tabs.ESP:Toggle({
Title = "Nextbot Boxes",
Value = false,
Callback = function(state) nextbotBoxesEnabled = state end
})

Tabs.ESP:Dropdown({
Title = "Nextbot Box Type",
Values = {"2D", "3D"},
Value = "2D",
Callback = function(value) nextbotBoxType = value end
})

Tabs.ESP:Toggle({
Title = "Nextbot Names",
Value = false,
Callback = function(state) 
nextbotNamesEnabled = state
if state then setupNextbotDetection() end
end
})

Tabs.ESP:Toggle({
Title = "Nextbot Distance",
Value = false,
Callback = function(state) nextbotDistanceEnabled = state end
})

Tabs.ESP:Toggle({
Title = "Nextbot Highlights",
Value = false,
Callback = function(state) nextbotHighlightsEnabled = state end
})

Tabs.ESP:Divider()
Tabs.ESP:Section({ Title = "Downed Player ESP", TextSize = 20 })
Tabs.ESP:Divider()

Tabs.ESP:Toggle({
Title = "Downed Boxes",
Value = false,
Callback = function(state) downedBoxesEnabled = state end
})

Tabs.ESP:Dropdown({
Title = "Downed Box Type",
Values = {"2D", "3D"},
Value = "2D",
Callback = function(value) downedBoxType = value end
})

Tabs.ESP:Toggle({
Title = "Downed Names",
Value = false,
Callback = function(state) downedNamesEnabled = state end
})

Tabs.ESP:Toggle({
Title = "Downed Distance",
Value = false,
Callback = function(state) downedDistanceEnabled = state end
})

Tabs.ESP:Toggle({
Title = "Downed Highlights",
Value = false,
Callback = function(state) downedHighlightsEnabled = state end
})

Tabs.ESP:Divider()
Tabs.ESP:Section({ Title = "Ticket ESP", TextSize = 20 })
Tabs.ESP:Divider()

Tabs.ESP:Toggle({
Title = "Ticket Boxes",
Value = false,
Callback = function(state) ticketBoxesEnabled = state end
})

Tabs.ESP:Dropdown({
Title = "Ticket Box Type",
Values = {"2D", "3D"},
Value = "2D",
Callback = function(value) ticketBoxType = value end
})

Tabs.ESP:Toggle({
Title = "Ticket Names",
Value = false,
Callback = function(state) ticketNamesEnabled = state end
})

Tabs.ESP:Toggle({
Title = "Ticket Distance",
Value = false,
Callback = function(state) ticketDistanceEnabled = state end
})

Tabs.ESP:Toggle({
Title = "Ticket Highlights",
Value = false,
Callback = function(state) ticketHighlightsEnabled = state end
})

Tabs.ESP:Divider()
Tabs.ESP:Section({ Title = "Vehicle ESP", TextSize = 20 })
Tabs.ESP:Divider()

Tabs.ESP:Toggle({
Title = "Vehicle Boxes",
Value = false,
Callback = function(state) vehicleBoxesEnabled = state end
})

Tabs.ESP:Dropdown({
Title = "Vehicle Box Type",
Values = {"2D", "3D"},
Value = "2D",
Callback = function(value) vehicleBoxType = value end
})

Tabs.ESP:Toggle({
Title = "Vehicle Names",
Value = false,
Callback = function(state) vehicleNamesEnabled = state end
})

Tabs.ESP:Toggle({
Title = "Vehicle Distance",
Value = false,
Callback = function(state) vehicleDistanceEnabled = state end
})

Tabs.ESP:Toggle({
Title = "Vehicle Highlights",
Value = false,
Callback = function(state) vehicleHighlightsEnabled = state end
})