WARNING - This site is for adults only!
This web site contains sexually explicit material:
Roblox Name ESP (Extra Sensory Perception) script is a common visual modification used to reveal other players' names and locations through walls or at great distances. These scripts are developed in , Roblox's specialized version of Lua. How Name ESP Scripts Work
ESP scripts generally function by creating a visual layer over the game world to display real-time player data. Drawing API : High-quality PC scripts often use an external Drawing Library
(like those found in executors like Synapse X) to render text and boxes directly onto the screen without interacting with game instances, making them harder for standard in-game anti-cheats to detect. BillboardGuis : Basic scripts often insert a BillboardGui
directly into a player's character model, typically above the head. This is easier to implement but more visible to game security. Highlight Feature : Some modern scripts use Roblox’s built-in
instance to create an outline around players that remains visible even when they are behind solid objects. Platform Compatibility: PC vs. Mobile
While the core Luau code is largely the same, the method of "injection" or "execution" varies significantly between platforms. how to make your own roblox ESP (tutorial)
A Roblox Name ESP (Extra Sensory Perception) script is a specialized Lua tool that allows players to see others' names and locations through solid objects like walls or terrain. These scripts are increasingly designed as universal solutions, meaning they are optimized to function seamlessly on both Mobile (Android/iOS) and PC (Windows/macOS) platforms. Core Features of Name ESP Scripts
Player Highlighting: Uses a highlighting system (often called "Chams") or boxes to make players visible regardless of obstacles.
Nametag Display: Draws the player's name above their character, often including additional data like distance or health.
Universal Compatibility: Modern scripts are built to detect if a player is on PC or Mobile, adjusting the UI and control schemes accordingly.
Performance Optimization: High-quality scripts use caching and "throttling" to reduce lag, ensuring smooth gameplay even on lower-end mobile devices. How to Use Name ESP Scripts on Mobile and PC
To run these scripts, you must use a third-party script executor. Note that using executors violates Roblox's Terms of Service and can lead to account penalties. 1. Choose a Compatible Executor How To Script a Selection Of Mobile And PC UI
ESP (Extra Sensory Perception) scripts in Roblox are external modifications that allow players to see hidden information, such as player locations through walls, health bars, and names.
While many versions of these scripts claim to work on both mobile and PC, using them carries significant risks. Core Features
Wallhacks: Renders boxes or outlines around players that are visible through solid objects.
Player Information: Displays real-time data like the player's name, current health, and distance from you.
Cross-Platform Support: These scripts are often written in Luau and designed to function via mobile or PC executors.
Customization: Many scripts allow you to toggle features, change colors, or adjust the thickness of outlines. Critical Risks & Consequences
Using any ESP script is a violation of the Roblox Terms of Service and involves several dangers:
Account Bans: Roblox has a zero-tolerance policy for cheating. Getting caught can lead to temporary suspension or permanent account deletion.
Malware & Data Loss: Many free scripts or "executors" used to run them contain hidden malware, keyloggers, or backdoors that can steal your passwords and browser cookies.
Phishing Scams: Some sites offering these scripts are actually phishing setups designed to trick you into entering your login credentials.
Unfair Advantage: These tools disrupt the competitive balance and ruin the experience for other players. The Reality of "Undetected" Scripts This is why you should Stop Downloading Roblox Cheats!
I can’t help create or provide scripts for cheating, exploiting, or bypassing protections in games (including ESP/aimbot cheats for Roblox) or instructions to make such tools work on mobile/PC.
If you need a different kind of paper, I can help with alternatives such as:
Which alternative would you like?
The following essay explores the technical mechanics, implementation, and cross-platform utility of Roblox Name ESP (Extra Sensory Perception) scripts for both PC and Mobile environments. Understanding Name ESP in the Roblox Ecosystem
Extra Sensory Perception (ESP) scripts are visual modifications designed to reveal information to a player that would otherwise be hidden by the game’s standard environment. Among these, Name ESP is the most common variant; it renders a player's username or display name directly above their character, often remaining visible through solid walls, terrain, or other obstacles. Core Technical Mechanics
At its fundamental level, a Name ESP script works by parenting a UI element to a target player’s character model.
BillboardGui: This is the primary object used for Name ESP. Unlike standard ScreenGuis, a BillboardGui is attached to a 3D part (like a player’s "Head") and automatically scales or rotates to face the viewer.
AlwaysOnTop Property: By enabling this property, the script ensures the UI is rendered over all other 3D geometry, creating the "wallhack" effect.
Dynamic Updates: Advanced scripts use events like PlayerAdded to apply the ESP to new entrants and PlayerRemoving to clean up visual highlights, ensuring the game's performance remains stable. Cross-Platform Implementation: PC vs. Mobile
While the core Luau code for an ESP script is largely identical across platforms, the method of execution and user interaction differs significantly. how to make your own roblox ESP (tutorial)
Roblox Name ESP Script: A Comprehensive Guide for Mobile and PC
Roblox is a popular online gaming platform that allows users to create and play games. For those who want to enhance their gaming experience, ESP (Extra Sensory Perception) scripts can be a valuable tool. In this article, we'll explore the world of Roblox name ESP scripts, their benefits, and provide a step-by-step guide on how to use them on both mobile and PC.
What is an ESP Script?
An ESP script is a type of script that allows players to see the names of other players through walls and obstacles. This can be particularly useful in games that require strategy and teamwork, as it enables players to track the movements of their opponents or teammates.
Benefits of Using an ESP Script
The benefits of using an ESP script in Roblox include:
Roblox Name ESP Script: How to Use It
Using a Roblox name ESP script is relatively straightforward. Here's a step-by-step guide for both mobile and PC: Roblox Name Esp Script Work for Mobile and Pc
PC Instructions:
Mobile Instructions:
Popular Roblox Name ESP Scripts
Some popular Roblox name ESP scripts include:
Safety Precautions
When using an ESP script, it's essential to take some safety precautions:
Conclusion
Roblox name ESP scripts can enhance your gaming experience and provide a competitive edge. By following the steps outlined in this article, you can easily use an ESP script on both mobile and PC. Remember to take safety precautions and only use reputable scripts and script executors. Happy gaming!
The Ultimate Guide to Roblox Name ESP Script: Working Solutions for Mobile and PC
Roblox, a popular online gaming platform, offers a vast array of games and interactive experiences. With millions of users worldwide, it's no surprise that many players seek to enhance their gaming experience with scripts and exploits. One such script that has gained significant attention is the Roblox Name ESP script. In this article, we'll explore what this script does, how it works, and provide working solutions for both mobile and PC users.
What is Roblox Name ESP Script?
ESP stands for "Extra Sensory Perception," which, in the context of Roblox, refers to a script that allows players to see the names of other players through walls and obstacles. The Roblox Name ESP script is a type of exploit that uses the game's API to retrieve and display the names of nearby players, providing an unfair advantage in gameplay.
How Does Roblox Name ESP Script Work?
The script works by injecting a custom code into the game's memory, which then interacts with the game's API to retrieve player information. This information includes the names of nearby players, which are then displayed on the screen, usually using a radar or ESP-style display. The script uses the game's built-in functionality to fetch player data, making it difficult to detect and ban.
Benefits of Using Roblox Name ESP Script
The Roblox Name ESP script offers several benefits to players, including:
Working Solutions for Mobile and PC
Here are some working solutions for the Roblox Name ESP script on both mobile and PC:
Mobile Solutions
PC Solutions
How to Install and Use Roblox Name ESP Script
Installing and using the Roblox Name ESP script is relatively straightforward:
Risks and Precautions
While using the Roblox Name ESP script can be fun and exciting, there are risks involved:
Conclusion
The Roblox Name ESP script is a popular exploit that offers a range of benefits, including improved gameplay and enhanced situational awareness. With working solutions for both mobile and PC, players can enjoy an enhanced gaming experience. However, it's essential to be aware of the risks involved and take precautions to avoid account bans and malware. Happy gaming!
What is an ESP script? An ESP script is a type of script that allows players to see the names of other players through walls and obstacles.
Prerequisites:
Step 1: Create a new LocalScript
In Roblox Studio, create a new LocalScript by right-clicking in the Workspace and selecting "Insert Object" > "LocalScript".
Step 2: Get the necessary dependencies
In the LocalScript, add the following code to get the necessary dependencies:
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
Step 3: Create a function to draw ESP
Create a function that will draw the ESP labels:
local function drawESP(player)
local character = player.Character
if character then
local humanoid = character:FindFirstChild("Humanoid")
if humanoid then
local head = character:FindFirstChild("Head")
if head then
local name = player.Name
local distance = (head.Position - game.Players.LocalPlayer.Character.Head.Position).Magnitude
local label = Instance.new("BillboardGui")
label.Parent = head
label.AlwaysOnTop = true
label.Size = UDim2.new(1, 0, 1, 0)
local textLabel = Instance.new("TextLabel")
textLabel.Parent = label
textLabel.BackgroundTransparency = 1
textLabel.Text = name .. " (" .. math.floor(distance) .. "m)"
textLabel.TextSize = 20
textLabel.TextColor3 = Color3.new(1, 1, 1)
end
end
end
end
Step 4: Loop through players and draw ESP
Create a loop that will iterate through all players and draw the ESP labels:
while wait(1) do
for _, player in pairs(Players:GetPlayers()) do
if player ~= game.Players.LocalPlayer then
drawESP(player)
end
end
end
Step 5: Clean up
To prevent the ESP labels from piling up, add a simple clean-up function:
local function cleanUp()
for _, player in pairs(Players:GetPlayers()) do
local character = player.Character
if character then
local head = character:FindFirstChild("Head")
if head then
for _, child in pairs(head:GetChildren()) do
if child:IsA("BillboardGui") then
child:Destroy()
end
end
end
end
end
end
while wait(1) do
cleanUp()
end
Putting it all together
Here's the complete script:
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local function drawESP(player)
local character = player.Character
if character then
local humanoid = character:FindFirstChild("Humanoid")
if humanoid then
local head = character:FindFirstChild("Head")
if head then
local name = player.Name
local distance = (head.Position - game.Players.LocalPlayer.Character.Head.Position).Magnitude
local label = Instance.new("BillboardGui")
label.Parent = head
label.AlwaysOnTop = true
label.Size = UDim2.new(1, 0, 1, 0)
local textLabel = Instance.new("TextLabel")
textLabel.Parent = label
textLabel.BackgroundTransparency = 1
textLabel.Text = name .. " (" .. math.floor(distance) .. "m)"
textLabel.TextSize = 20
textLabel.TextColor3 = Color3.new(1, 1, 1)
end
end
end
end
local function cleanUp()
for _, player in pairs(Players:GetPlayers()) do
local character = player.Character
if character then
local head = character:FindFirstChild("Head")
if head then
for _, child in pairs(head:GetChildren()) do
if child:IsA("BillboardGui") then
child:Destroy()
end
end
end
end
end
end
while wait(1) do
cleanUp()
for _, player in pairs(Players:GetPlayers()) do
if player ~= game.Players.LocalPlayer then
drawESP(player)
end
end
end
Mobile and PC Compatibility
This script should work on both mobile and PC, as it uses the BillboardGui instance, which is compatible with all platforms.
Note
Again, I want to emphasize that creating and using ESP scripts may violate Roblox's terms of service and can potentially harm the game experience for others. Use this script at your own risk. Additionally, this script may not work as-is in all games, as some games may have modifications that prevent ESP scripts from working.
Name ESP (Extra Sensory Perception) scripts are popular tools used to display player names, health, and distance through walls. Because Roblox uses a uniform scripting engine, well-made scripts can function across Mobile (Android/iOS) , provided they use universal services like BillboardGui Top Universal Name ESP Scripts (2026)
If you are looking for reliable ESP scripts that work on both platforms, these are highly recommended for their stability and customization: Exunys Universal ESP Script
: A highly popular option that creates a label above players' heads.
: Displays name, distance, and health. Includes a "Team Check" to distinguish friends from foes. : Toggle on/off with (PC) or through an executor's GUI (Mobile). Compatibility : Undetected and works with any exploit supporting the Drawing API SynX2025 ESP Hub
: A 2026-ready universal script designed for high performance. : Automatically switches between Display Names Mobile Support : Optimized for mobile executors like Delta Executor , ensuring it doesn't cause lag on handheld devices. Universal Highlight & SelectionBox Script : A simple alternative available on that uses Roblox's built-in system to make players visible through parts. How to Use on Different Devices The method for running these scripts varies by platform: Execution Method Use a desktop executor (like Synapse Z or Solara).
Check for "KeyboardEnabled" scripts to ensure keybinds work. Use an APK/IPA executor (like Delta or Arceus X).
Look for "Keyless" or "GUI-based" scripts so you don't need a keyboard. Key Scripting Services Used
For those looking to create or modify their own cross-platform ESP, these services are essential: UserInputService
: Used to detect if a player is on mobile (touch) or PC (keyboard) to adjust UI elements. RunService
: Ensures the ESP updates every frame to track moving players accurately. BillboardGui : The standard way to attach a name tag to a player's so it stays visible regardless of distance. Universal Roblox ESP Script [2025] - Pastebin.com
Using a Roblox Name ESP script is one of the most effective ways to gain a competitive edge by revealing the locations of other players through walls and obstacles. These scripts function by creating visual indicators, often using BillboardGuis or Chams, that remain visible regardless of the distance or environmental barriers between you and your target. What is a Roblox Name ESP Script?
ESP (Extra Sensory Perception) in gaming refers to scripts that display hidden information about other players. A Name ESP specifically focuses on showing player usernames, though many versions also include: Box ESP: Draws a colored frame around the player character.
Distance Indicators: Shows exactly how many "studs" away a player is.
Health Bars: Displays the current HP of enemies or teammates.
Tracers: Draws lines from your position to other players for easy tracking. Multi-Platform Compatibility: Mobile and PC
Modern scripts are often designed to be Universal, meaning they work across various games and platforms. For PC Users
On PC, scripts are typically run through an executor like Solara or Synapse X. You can find various versions of Roblox Name ESP scripts on GitHub or dedicated script repositories. These executors inject the code directly into the Roblox client, allowing the ESP to render in real-time. For Mobile Users
Mobile execution requires a specific mobile-compatible executor (often an APK or IPA modification). These tools allow you to paste the same Lua script code used on PC. Users often look for scripts that include a Toggle GUI, making it easier to turn the ESP on and off using touch controls rather than keyboard hotkeys. How to Use the Script
Select an Executor: Choose a reliable tool for your platform.
Copy the Script: Use an open-source option like the Universal Name ESP script on rbxscript .
Inject and Execute: Open Roblox, run your executor, paste the script code, and click "Execute".
Configure Settings: Most scripts provide a menu to adjust colors, transparency, and the types of information displayed. Risks and Safety
While ESP scripts are popular, they carry significant risks:
As an oblivious person; what is an "esp"/what does "esp mean?
To create a cross-platform Name ESP (Extra Sensory Perception) feature for Roblox, you can use a combination of BillboardGuis for the UI and RunService for real-time updates. This method is effective because it works natively on both PC and Mobile without requiring complex exploit APIs like Drawing. Feature Overview
This feature creates a text label that floats above every player's head, showing their name through walls and objects. 1. The Core ESP Function
This function creates the visual "Name Tag" for a specific player. It uses a BillboardGui so the text always faces your camera.
local function createNameESP(player) -- Wait for the character to load local character = player.Character or player.CharacterAdded:Wait() local head = character:WaitForChild("Head", 5) if head then -- Create the BillboardGui local billboard = Instance.new("BillboardGui") billboard.Name = "NameESP" billboard.Size = UDim2.new(0, 200, 0, 50) billboard.Adornee = head billboard.AlwaysOnTop = true -- This makes it visible through walls billboard.ExtentsOffset = Vector3.new(0, 3, 0) -- Position it above the head -- Create the Name Label local label = Instance.new("TextLabel") label.Parent = billboard label.Size = UDim2.new(1, 0, 1, 0) label.BackgroundTransparency = 1 label.Text = player.Name label.TextColor3 = Color3.new(1, 1, 1) -- White text label.TextStrokeTransparency = 0 -- Outline for visibility label.TextSize = 14 billboard.Parent = character end end Use code with caution. Copied to clipboard 2. Cross-Platform Automation
To ensure this works for everyone who joins the game and updates when players respawn, use the PlayerAdded and CharacterAdded events.
local Players = game:GetService("Players") -- Run for existing players for _, player in pairs(Players:GetPlayers()) do if player ~= Players.LocalPlayer then createNameESP(player) player.CharacterAdded:Connect(function() createNameESP(player) end) end end -- Run for new players who join Players.PlayerAdded:Connect(function(player) player.CharacterAdded:Connect(function() createNameESP(player) end) end) Use code with caution. Copied to clipboard Key Compatibility Features
Mobile Support: Unlike many scripts that rely on keyboard shortcuts (like F1 or Q), this BillboardGui method is "always on" and does not require specific input types.
Visibility: Setting AlwaysOnTop = true ensures the names remain visible regardless of walls or buildings, which is the primary function of ESP.
Native Performance: Since it uses built-in Roblox UI objects, it is less likely to cause lag compared to custom frame-by-frame drawing scripts. How to make this script work on PC and MOBILE?
To make a solid story out of the subject "Roblox Name Esp Script Work for Mobile and Pc,"
we can explore a high-stakes digital thriller about a legendary game script, an underground hacking community, and the blurred lines between gaming and reality. Here is a gripping short story based on your subject. THE GHOST IN THE LOBBY The leaderboard was a wall of lies, and knew exactly how to break it. By day, he was a quiet high schooler. By night, he was
, a legendary script developer in the underground Roblox community. For months, he had been working on a masterpiece: a flawless, undetectable Universal Name ESP (Extra-Sensory Perception) script Roblox Name ESP (Extra Sensory Perception) script is
that bridged the ultimate divide—it worked flawlessly on both PC and Mobile
In the exploiting world, making a script work on PC was easy. Making it run on mobile without crashing the low-end hardware was considered impossible. Kaelen had cracked the code. The Midnight Launch
Kaelen sat in his dark room, the glow of his dual monitors reflecting in his glasses. On his desk lay his cracked Android phone. He executed the script on both devices simultaneously.
In Roblox, a Name ESP (Extra Sensory Perception) script is a type of visual modification that allows players to see information—such as player names, health, and distance—through solid objects and walls. These scripts are designed to work on both PC and Mobile by leveraging the game engine's built-in visual objects. How It Works (PC & Mobile)
The script essentially "highlights" other players by attaching specific graphical elements to their character models that are programmed to remain visible regardless of distance or obstacles.
BillboardGuis: This is the most common method for displaying names. The script creates a text label and parents it to the other player's head. By setting the AlwaysOnTop property to true, the name stays visible even if the player is behind a wall.
Highlighters & Boxes: Many modern ESP scripts use Highlight instances or BoxHandleAdornments to create a colored outline or glowing box around a character, making them easy to spot in dark or crowded areas.
Automated Tracking: To keep the visuals updated, these scripts use loops (often connected to the RunService) to constantly check the positions of all active players. They are programmed to remove these highlights immediately when a player leaves the game to prevent "ghost" labels. Universal Compatibility Exunys/ESP-Script: ROBLOX ESP Visuals Script - GitHub
A Roblox Name ESP (Extra Sensory Perception) script provides a visual advantage by displaying player names, distances, or health through walls, making it easier to track opponents or teammates
. In 2026, these scripts have evolved to be "universal," meaning they can work across many different games, provided the executor supports the necessary drawing API. These scripts work on both PC and Mobile
by leveraging popular script executors that allow custom Lua code injection. Top Working ESP Scripts (2026) Exunys Universal ESP
Highly popular, stable script that labels opponent heads and allows customization of color, thickness, and team checks. Unnamed ESP
A classic, reliable script that uses the built-in Drawing API. Rivals ESP/Aimbot
Specific scripts designed for competitive games, often featuring ESP alongside aimbot. How to Use Name ESP Scripts (PC & Mobile)
To use these scripts, you need a "script executor" (a tool that injects the code into Roblox). As of April 2026, keyless executors are popular. For PC (Windows) Download an Executor: Popular options include Delta Executor for PC Xeno Injector Run as Admin:
Install and open the executor, running it with administrator privileges to avoid injection issues.
Open Roblox, join a game, then click the "Inject" button on the executor.
Copy a universal ESP script (like the Exunys code) and paste it into the executor's script box, then click "Execute". For Mobile (Android/iOS) Download an Executor: Delta Executor APK Arceus X Neo are common choices for Android. Install & Set Up:
Install the APK (you may need to allow "Install from Unknown Sources" in settings). Run Roblox:
Launch the executor, then launch Roblox through the executor. Inject & Execute:
Paste the ESP script into the executor and execute it while in-game. Features of Modern ESP Scripts Player Names: Displays usernames or display names. Distance Tracking: Shows how far away a player is. Health Bars: Shows the health status of players. Boxes/Tracers:
Draws boxes around players or lines from your screen to them.
Often includes a toggle key (e.g., 'Q' or 'F1') to turn the ESP on/off. ⚠️ Important Security & Safety Information Anti-Cheat Detection:
While many scripts claim to be undetected, Roblox routinely updates its anti-cheat systems. Using scripts can lead to a ban. Use Alt Accounts:
Never use your main account. Always use a secondary ("alt") account to test scripts. Keyless vs. Keyed: Keyless executors (like
) are more convenient, but sometimes keyed executors are more stable. Safety Check:
Download executors only from trusted, widely recognized sources to avoid malware. Disclaimer:
This information is for educational purposes only. Modifying Roblox gameplay violates the Roblox Terms of Service , which may result in account termination. Exunys/ESP-Script: ROBLOX ESP Visuals Script - GitHub
Roblox Name ESP scripts can enhance gameplay by providing useful information. However, their use must comply with Roblox's policies. When developing or using such scripts, consider cross-platform compatibility to ensure a fair and enjoyable experience for players across different devices. Always refer to the latest Roblox documentation and community guidelines for best practices.
I understand you're looking for information about a "Name ESP" script for Roblox that works on both mobile and PC. However, I need to provide some important context:
Important Notes:
If you're still interested for educational purposes (testing on your own private Roblox server/game you own):
Recommended Alternatives (Safe & Legal):
Bottom line: There's no safe, reliable, and ToS-compliant Name ESP script that works across both mobile and PC for public Roblox games. Any claims otherwise are likely scams or malware.
Would you like resources for learning legitimate Roblox scripting instead?
It sounds like you’re looking for a name ESP script for Roblox that works on both mobile and PC.
Here’s a clear breakdown of what that means and the realistic options available:
Mobile is significantly harder. iOS sandboxes apps tightly, making injection nearly impossible without a jailbreak. Android is slightly more open. Mobile executors (like Arceus X or Hydrogen) have limited processing power. They struggle with standard Drawing libraries that PC uses. Therefore, a "Mobile-friendly" Name ESP script must use Native UI or legacy 2D libraries instead of complex 3D cameras.
Roblox has evolved far beyond a simple gaming platform; it is a sprawling universe of user-generated experiences. From intense PvP battlegrounds like Arsenal to mysterious horror games like The Mimic, knowing where your opponents or friends are can grant a massive advantage. This is where ESP (Extra Sensory Perception) scripts come into play.
Specifically, Name ESP is the most fundamental and sought-after cheat feature. It allows you to see player names, distances, and health bars through walls. But the biggest challenge has always been cross-compatibility: getting a script that works seamlessly on both Mobile (iOS/Android) and PC (Windows/Mac). A research paper on ethics and impacts of game cheats
In this comprehensive guide, we will break down what Name ESP is, how it works on different devices, where to find reliable scripts, and the risks involved.
-- This is a basic example and might need adjustments
local players = game:GetService("Players")
local RunService = game:GetService("RunService")
-- Function to draw ESP labels
local function drawESP(player)
-- Here you'd implement the drawing code
-- For simplicity, this example skips to the core concept
end
-- Example loop to continuously update ESP
RunService.RenderStepped:Connect(function()
for _, player in pairs(players:GetPlayers()) do
-- Implement drawing ESP for each player
end
end)
The oldest repository for Roblox scripts. Search for "Universal Name ESP Mobile + PC." Look for threads with "Arceus X" or "Krnl" tags. Mobile users should prioritize scripts labeled "Mobile Support."
-- Services
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local Camera = workspace.CurrentCamera
local LocalPlayer = Players.LocalPlayer
-- Configuration
local Settings =
Toggle = true, -- Turn ESP on/off
TeamCheck = false, -- If true, ESP will not show for teammates
MaxDistance = 1000, -- Only show players within this distance (helps mobile FPS)
TextSize = 14, -- Size of the name text
Color = Color3.fromRGB(255, 255, 255) -- Color of the text
-- Table to store ESP objects for each player
local ESP_Objects = {}
-- Function to create the ESP Drawing
local function CreateESP(player)
if ESP_Objects[player] then return end -- Prevent duplicates
local esp =
NameText = Drawing.new("Text"),
Connection = nil
esp.NameText.Size = Settings.TextSize
esp.NameText.Center = true
esp.NameText.Outline = true
esp.NameText.Color = Settings.Color
esp.NameText.Visible = false
ESP_Objects[player] = esp
-- Update loop for this specific player
esp.Connection = RunService.RenderStepped:Connect(function()
if not Settings.Toggle then
esp.NameText.Visible = false
return
end
-- Validation checks
if player and player.Character and player.Character:FindFirstChild("HumanoidRootPart") and player.Character:FindFirstChildOfClass("Humanoid") then
local humanoid = player.Character:FindFirstChildOfClass("Humanoid")
local rootPart = player.Character.HumanoidRootPart
-- Team Check Logic
if Settings.TeamCheck and player.Team and LocalPlayer.Team and player.Team == LocalPlayer.Team then
esp.NameText.Visible = false
return
end
-- Health Check (Don't show dead players)
if humanoid.Health <= 0 then
esp.NameText.Visible = false
return
end
-- Calculate Distance
local distance = (LocalPlayer.Character.HumanoidRootPart.Position - rootPart.Position).Magnitude
-- Distance Check (Optimization for Mobile)
if distance > Settings.MaxDistance then
esp.NameText.Visible = false
return
end
-- World to Screen Conversion
local screenPos, onScreen = Camera:WorldToViewportPoint(rootPart.Position)
if onScreen then
-- Position text above head
local headPos = Camera:WorldToViewportPoint(rootPart.Position + Vector3.new(0, 3, 0))
esp.NameText.Position = Vector2.new(headPos.X, headPos.Y)
esp.NameText.Text = string.format("%s [%d]", player.Name, math.floor(distance))
esp.NameText.Visible = true
else
esp.NameText.Visible = false
end
else
esp.NameText.Visible = false
end
end)
end
-- Function to remove ESP
local function RemoveESP(player)
if ESP_Objects[player] then
if ESP_Objects[player].Connection then
ESP_Objects[player].Connection:Disconnect()
end
if ESP_Objects[player].NameText then
ESP_Objects[player].NameText:Remove()
end
ESP_Objects[player] = nil
end
end
-- Handle existing players
for _, player in ipairs(Players:GetPlayers()) do
if player ~= LocalPlayer then
CreateESP(player)
end
end
-- Handle new players joining
Players.PlayerAdded:Connect(function(player)
CreateESP(player)
end)
-- Handle players leaving
Players.PlayerRemoving:Connect(function(player)
RemoveESP(player)
end)