-- Anti-Detection/Obfuscation Setup

local type_custom = typeof

if not LPH_OBFUSCATED then
LPH_JIT = function(...)
return ...;
end;
LPH_JIT_MAX = function(...)
return ...;
end;
LPH_NO_VIRTUALIZE = function(...)
return ...;
end;
LPH_NO_UPVALUES = function(f)
return (function(...)
return f(...);
end);
end;
LPH_ENCSTR = function(...)
return ...;
end;
LPH_ENCNUM = function(...)
return ...;
end;
LPH_ENCFUNC = function(func, key1, key2)
if key1 ~= key2 then return print("LPH_ENCFUNC mismatch") end
return func
end;
LPH_CRASH = function()
return print([Link]());
end;
SWG_DiscordUser = "kristo"
SWG_DiscordID = 1337
SWG_Private = true
SWG_Dev = false
SWG_Version = "free"
SWG_Title = 'zzz'
SWG_ShortName = "free"
SWG_FullName = "ts"
SWG_FFA = false
end;

-- Key System Implementation

local keySystemGui = [Link]("ScreenGui")
[Link] = "KeySystem"
[Link] = false
[Link] =
game:GetService("Players").LocalPlayer:WaitForChild("PlayerGui")

local keyFrame = [Link]("Frame")

[Link] = [Link](0, 300, 0, 180)
[Link] = [Link](0.5, -150, 0.5, -90)
keyFrame.BackgroundColor3 = [Link](30, 30, 30)
[Link] = 1
keyFrame.BorderColor3 = [Link](255, 255, 255)
[Link] = true
[Link] = true
[Link] = keySystemGui

-- Title bar for dragging

local titleBar = [Link]("Frame")
[Link] = [Link](1, 0, 0, 30)
[Link] = [Link](0, 0, 0, 0)
titleBar.BackgroundColor3 = [Link](20, 20, 20)
[Link] = 0
[Link] = keyFrame

local keyTitle = [Link]("TextLabel")

[Link] = [Link](1, 0, 1, 0)
[Link] = 1
[Link] = "DarkHook Key System"
keyTitle.TextColor3 = [Link](1, 1, 1)
[Link] = [Link]
[Link] = 16
[Link] = titleBar

-- Close button
local closeButton = [Link]("TextButton")
[Link] = [Link](0, 25, 0, 25)
[Link] = [Link](1, -25, 0, 0)
closeButton.BackgroundColor3 = [Link](50, 50, 50)
[Link] = "X"
closeButton.TextColor3 = [Link](1, 1, 1)
[Link] = [Link]
[Link] = 14
[Link] = titleBar

local keyInput = [Link]("TextBox")

[Link] = [Link](0, 250, 0, 30)
[Link] = [Link](0.5, -125, 0, 60)
keyInput.BackgroundColor3 = [Link](50, 50, 50)
[Link] = ""
keyInput.TextColor3 = [Link](1, 1, 1)
[Link] = "Enter key here..."
[Link] = keyFrame

local keySubmit = [Link]("TextButton")

[Link] = [Link](0, 100, 0, 30)
[Link] = [Link](0.5, -50, 0, 100)
keySubmit.BackgroundColor3 = [Link](0, 120, 215)
[Link] = "Submit"
keySubmit.TextColor3 = [Link](1, 1, 1)
[Link] = [Link]
[Link] = keyFrame

local keyStatus = [Link]("TextLabel")

[Link] = [Link](1, 0, 0, 20)
[Link] = [Link](0, 0, 1, -20)
[Link] = 1
[Link] = ""
keyStatus.TextColor3 = [Link](1, 0, 0)
[Link] = [Link]
[Link] = 14
[Link] = keyFrame

local infoText = [Link]("TextLabel")

[Link] = [Link](1, 0, 0, 15)
[Link] = [Link](0, 0, 0, 140)
[Link] = 1
[Link] = "Press RightShift to toggle this window"
infoText.TextColor3 = [Link](0.8, 0.8, 0.8)
[Link] = [Link]
[Link] = 12
[Link] = keyFrame

local correctKey = "DarkHook67"

local keyValid = false
local keyGuiVisible = true

-- Function to validate key

local function validateKey()
if [Link] == correctKey then
keyValid = true
keySystemGui:Destroy()
else
[Link] = "Invalid key! Try again."
[Link] = ""
end
end

-- Connect submit button

keySubmit.MouseButton1Click:Connect(validateKey)

-- Allow Enter key to submit

[Link]:Connect(function(enterPressed)
if enterPressed then
validateKey()
end
end)

-- Close button functionality

closeButton.MouseButton1Click:Connect(function()
keyGuiVisible = false
[Link] = false
end)

-- Toggle key UI with RightShift

game:GetService("UserInputService").InputBegan:Connect(function(input, processed)
if not processed and [Link] == [Link] and not keyValid then
keyGuiVisible = not keyGuiVisible
[Link] = keyGuiVisible
end
end)

-- Wait for key validation before continuing

while not keyValid do
wait(0.1)
end

-- DarkHook Tabbed UI with Toggles + Hitbox Expander (Head) with sliders

local Players = game:GetService("Players")
local Lighting = game:GetService("Lighting")
local RunService = game:GetService("RunService")
local UIS = game:GetService("UserInputService")
local Workspace = game:GetService("Workspace")
local HttpService = game:GetService("HttpService")
local LocalPlayer = [Link]
local Camera = [Link]
-- UI Setup
local screenGui = [Link]("ScreenGui")
[Link] = "DarkHook(PAID)"
[Link] = false
[Link] = LocalPlayer:WaitForChild("PlayerGui")
[Link] = true

-- Main Frame
local frame = [Link]("Frame", screenGui)
[Link] = [Link](0, 500, 0, 500)
[Link] = [Link](0.5, -250, 0.5, -250)
frame.BackgroundColor3 = [Link](25, 25, 25)
frame.BorderColor3 = [Link](255, 255, 255)
[Link] = 1
[Link] = true
[Link] = true

-- Title
local title = [Link]("TextLabel", frame)
[Link] = [Link](1, 0, 0, 30)
title.BackgroundColor3 = [Link](15, 15, 15)
[Link] = 0
[Link] = "DarkHook(PAID)"
[Link] = [Link]
[Link] = 22
title.TextColor3 = [Link](255, 255, 255)

-- Tab Bar
local tabBar = [Link]("Frame", frame)
[Link] = [Link](1, 0, 0, 30)
[Link] = [Link](0,0,0,30)
[Link] = 1
local tabLayout = [Link]("UIListLayout", tabBar)
[Link] = [Link]
[Link] = [Link]

local tabs = {}
local pages = {}

local function createTab(name)

local button = [Link]("TextButton", tabBar)
[Link] = [Link](0, 90, 1, 0)
[Link] = name
button.BackgroundColor3 = [Link](35,35,35)
button.TextColor3 = [Link](1,1,1)
[Link] = 0
[Link] = [Link]

local page = [Link]("ScrollingFrame", frame)

[Link] = [Link](1, -20, 1, -70)
[Link] = [Link](0, 10, 0, 70)
[Link] = 1
[Link] = false
[Link] = 8
page.ScrollBarImageColor3 = [Link](100, 100, 100)
[Link] = [Link](0, 0, 0, 0)

local list = [Link]("UIListLayout", page)

[Link] = [Link](0, 10)
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
list:GetPropertyChangedSignal("AbsoluteContentSize"):Connect(function()
[Link] = [Link](0, 0, 0, [Link].Y)
end)

pages[name] = page
[Link](tabs, {button, page})

button.MouseButton1Click:Connect(function()
for _, v in ipairs(tabs) do
v[2].Visible = false
end
[Link] = true
end)
end

createTab("Combat")
createTab("Visuals")
createTab("Misc")
createTab("Exploits")
createTab("ESP")
pages["Combat"].Visible = true

------------------------------------------------------
-- Widgets ------------------------------------------------------
local function createCheckbox(parent, text, callback)
local frame = [Link]("Frame", parent)
[Link] = [Link](1, -20, 0, 25)
[Link] = 1

local box = [Link]("TextButton", frame)

[Link] = [Link](0, 20, 0, 20)
[Link] = [Link](0,0,0.5,-10)
box.BackgroundColor3 = [Link](60,60,60)
[Link] = ""

local label = [Link]("TextLabel", frame)

[Link] = [Link](0, 30, 0, 0)
[Link] = [Link](1, -30, 1, 0)
[Link] = 1
[Link] = text
label.TextColor3 = [Link](1,1,1)
[Link] = [Link]

local toggled = false

box.MouseButton1Click:Connect(function()
toggled = not toggled
box.BackgroundColor3 = toggled and [Link](0,170,0) or
[Link](60,60,60)
callback(toggled)
end)

return {
box = box,
setChecked = function(state)
toggled = state
box.BackgroundColor3 = state and [Link](0,170,0) or
[Link](60,60,60)
callback(state)
end,
isChecked = function() return toggled end
}
end

local function createSlider(parent, text, min, max, default, rounding, callback)

local container = [Link]("Frame", parent)
[Link] = [Link](1, -20, 0, 40)
[Link] = 1

local label = [Link]("TextLabel", container)

[Link] = [Link](1, 0, 0, 18)
[Link] = 1
[Link] = [Link]("%s: %s", text, tostring(default))
label.TextColor3 = [Link](1,1,1)
[Link] = [Link]

local bar = [Link]("Frame", container)

[Link] = [Link](1, 0, 0, 12)
[Link] = [Link](0, 0, 0, 22)
bar.BackgroundColor3 = [Link](50,50,50)
[Link] = 0

local knob = [Link]("Frame", bar)

[Link] = [Link](0, 8, 1, 0)
knob.BackgroundColor3 = [Link](200,200,200)
[Link] = 0

local value = default

local function setFromX(x)

local rel = [Link]((x - [Link].X) / [Link].X, 0, 1)
local raw = min + (max - min) * rel
local factor = 10^rounding
value = [Link](raw * factor + 0.5) / factor
[Link] = [Link]((value - min) / (max - min), -4, 0, 0)
[Link] = [Link]("%s: %s", text, tostring(value))
callback(value)
end

[Link]:Connect(function(input)
if [Link] == [Link].MouseButton1 then
setFromX([Link].X)
end
end)

[Link]:Connect(function(input)
if [Link] == [Link] and
UIS:IsMouseButtonPressed([Link].MouseButton1) then
setFromX([Link].X)
end
end)

-- init knob position

[Link] = [Link]((default - min) / (max - min), -4, 0, 0)
callback(default)
end

-- Combined Checkbox and Keybind Widget

local function createCheckboxWithKeybind(parent, text, defaultKey, callback)
local container = [Link]("Frame", parent)
[Link] = [Link](1, -20, 0, 25)
[Link] = 1

-- Checkbox
local box = [Link]("TextButton", container)
[Link] = [Link](0, 20, 0, 20)
[Link] = [Link](0,0,0.5,-10)
box.BackgroundColor3 = [Link](60,60,60)
[Link] = ""

-- Label
local label = [Link]("TextLabel", container)
[Link] = [Link](0, 30, 0, 0)
[Link] = [Link](0, 120, 1, 0)
[Link] = 1
[Link] = text
label.TextColor3 = [Link](1,1,1)
[Link] = [Link]

-- Keybind Button
local keybindButton = [Link]("TextButton", container)
[Link] = [Link](0, 80, 1, 0)
[Link] = [Link](1, -80, 0, 0)
keybindButton.BackgroundColor3 = [Link](50,50,50)
[Link] = [Link]
keybindButton.TextColor3 = [Link](1,1,1)
[Link] = 0
[Link] = [Link]
[Link] = 14

local toggled = false

local currentKey = defaultKey
local waitingForInput = false

-- Checkbox click
box.MouseButton1Click:Connect(function()
toggled = not toggled
box.BackgroundColor3 = toggled and [Link](0,170,0) or
[Link](60,60,60)
callback(toggled)
end)

-- Keybind button click

keybindButton.MouseButton1Click:Connect(function()
if waitingForInput then return end
waitingForInput = true
[Link] = "Press a key..."

local inputConn
inputConn = [Link]:Connect(function(input, processed)
if processed then return end
if [Link] == [Link] then
currentKey = [Link]
[Link] = [Link]
waitingForInput = false
inputConn:Disconnect()
end
end)

-- Cancel if they click elsewhere

local mouseConn
mouseConn = [Link]:Connect(function(input, processed)
if processed then return end
if [Link] == [Link].MouseButton1 then
waitingForInput = false
[Link] = [Link]
inputConn:Disconnect()
mouseConn:Disconnect()
end
end)
end)

return {
box = box,
keybindButton = keybindButton,
setChecked = function(state)
toggled = state
box.BackgroundColor3 = state and [Link](0,170,0) or
[Link](60,60,60)
callback(state)
end,
isChecked = function() return toggled end,
getKey = function() return currentKey end
}
end

------------------------------------------------------
-- Features ------------------------------------------------------
-- Low Graphics Toggle - FIXED to preserve arrows
local lowGraphicsConnections = {}
local lowGraphicsEnabled = false
local function applyLowGraphicsToObject(obj)
-- Check if this is an arrow-related object and skip it
if [Link]:lower():find("arrow") or [Link]:lower():find("projectile") or
[Link]:lower():find("bolt") or [Link]:lower():find("ammo") then
return
end

-- Check if this is a trail attached to a weapon or projectile

if obj:IsA("Trail") then
local parent = [Link]
if parent and ([Link]:lower():find("arrow") or
[Link]:lower():find("projectile") or [Link]:lower():find("bolt") or
[Link]:lower():find("ammo")) then
return
end
end

-- Check if this is a particle emitter for fire or smoke effects

if obj:IsA("ParticleEmitter") then
-- Preserve fire and smoke effects
if [Link]:lower():find("fire") or [Link]:lower():find("smoke") or
[Link]:lower():find("flame") then
return
end
end

-- Apply low graphics to other objects

if obj:IsA("ParticleEmitter") or obj:IsA("Trail") then
[Link] = false
elseif obj:IsA("Decal") then
[Link] = 1
elseif obj:IsA("SurfaceAppearance") then
obj:Destroy()
elseif obj:IsA("Grass") or [Link]:lower():find("leaf") or
[Link]:lower():find("leaves") then
obj:Destroy()
end
end
local function applyLowGraphicsToWorkspace()
-- Apply to all existing descendants
for _, v in ipairs(Workspace:GetDescendants()) do
applyLowGraphicsToObject(v)
end

-- Apply to terrain
local terrain = Workspace:FindFirstChildOfClass("Terrain")
if terrain then
[Link] = 0
[Link] = 0
[Link] = 0
[Link] = 1
end

-- Apply to lighting
[Link] = false
[Link] = 1000000
[Link] = 2

-- Apply to lighting effects

for _, effect in ipairs(Lighting:GetChildren()) do
if effect:IsA("BlurEffect") or effect:IsA("SunRaysEffect") or
effect:IsA("ColorCorrectionEffect") or effect:IsA("DepthOfFieldEffect") then
[Link] = false
end
end
end
local function restoreGraphicsForObject(obj)
if obj:IsA("ParticleEmitter") or obj:IsA("Trail") then
[Link] = true
elseif obj:IsA("Decal") then
[Link] = 0
end
end
local function restoreGraphics()
-- Restore all existing descendants
for _, v in ipairs(Workspace:GetDescendants()) do
restoreGraphicsForObject(v)
end

-- Restore terrain
local terrain = Workspace:FindFirstChildOfClass("Terrain")
if terrain then
[Link] = 1
[Link] = 1
[Link] = 0.25
[Link] = 0
end

-- Restore lighting
[Link] = true
[Link] = 1000
[Link] = 1

-- Restore lighting effects

for _, effect in ipairs(Lighting:GetChildren()) do
if effect:IsA("BlurEffect") or effect:IsA("SunRaysEffect") or
effect:IsA("ColorCorrectionEffect") or effect:IsA("DepthOfFieldEffect") then
[Link] = true
end
end
end
local function setLowGraphics(enabled)
lowGraphicsEnabled = enabled

-- Clear existing connections

for _, conn in pairs(lowGraphicsConnections) do
conn:Disconnect()
end
lowGraphicsConnections = {}

if enabled then
-- Apply low graphics to existing objects
applyLowGraphicsToWorkspace()

-- Set up connection to apply low graphics to new objects as they're added

[Link](lowGraphicsConnections,
[Link]:Connect(function(obj)
if lowGraphicsEnabled then
applyLowGraphicsToObject(obj)
end
end))

-- Also handle children added directly to Workspace

[Link](lowGraphicsConnections, [Link]:Connect(function(obj)
if lowGraphicsEnabled then
-- Apply to the object itself
applyLowGraphicsToObject(obj)

-- Apply to its descendants

for _, descendant in ipairs(obj:GetDescendants()) do
applyLowGraphicsToObject(descendant)
end
end
end))
else
-- Restore normal graphics
restoreGraphics()
end
end
-- Crosshair
local crosshairGui
local function setCrosshair(enabled)
if enabled then
crosshairGui = [Link]("ScreenGui", [Link])
[Link] = "CrosshairGui"
[Link] = false

local size = 6

local function createLine(sx, sy, px, py)

local line = [Link]("Frame", crosshairGui)
[Link] = [Link](0, sx, 0, sy)
[Link] = [Link](0.5, px, 0.47, py)
[Link] = [Link](0.5, 0.5)
line.BackgroundColor3 = [Link](1, 1, 1)
[Link] = 0
end

createLine(1, size, 0, -size)

createLine(1, size, 0, size)
createLine(size, 1, -size, 0)
createLine(size, 1, size, 0)
else
if crosshairGui then
crosshairGui:Destroy()
crosshairGui = nil
end
end
end

------------------------------------------------------
-- Hitbox Expander (Head) — Toggle + Sliders
------------------------------------------------------
local validCharacters = {}
local originalHeadSizes = {}
local hitboxEnabled = false
local hitboxConn
-- defaults
local hitboxHeadSizeX = 10
local hitboxHeadSizeY = 10
local hitboxHeadTransparency = 0.5
local function isCharacterModel(m)
return typeof(m) == "Instance" and m:IsA("Model") and (m:FindFirstChild("Head") or
m:FindFirstChild("LowerTorso") or m:FindFirstChild("UpperTorso"))
end
local function addToVC(obj)
if isCharacterModel(obj) then
validCharacters[obj] = true

-- cache original head size if available

local head = obj:FindFirstChild("Head")
if head and head:IsA("BasePart") and not originalHeadSizes[head] then
originalHeadSizes[head] = [Link]
end

-- watch for a head added later

[Link]:Connect(function(c)
if [Link] == "Head" and c:IsA("BasePart") then
if not originalHeadSizes[c] then
originalHeadSizes[c] = [Link]
end
end
end)
end
end
local function removeFromVC(obj)
if validCharacters[obj] then
validCharacters[obj] = nil
end
end
for _, v in ipairs(Workspace:GetChildren()) do
addToVC(v)
end
[Link]:Connect(addToVC)
[Link]:Connect(removeFromVC)
local function applyHitboxOnce()
local newSize = [Link](hitboxHeadSizeX, hitboxHeadSizeY, hitboxHeadSizeX)

for model,_ in pairs(validCharacters) do

local head = model and model:FindFirstChild("Head")
if head and head:IsA("BasePart") then
if not originalHeadSizes[head] then
originalHeadSizes[head] = [Link]
end

[Link] = newSize
[Link] = hitboxHeadTransparency
[Link] = false
end
end
end
local function restoreHitbox()
for head,orig in pairs(originalHeadSizes) do
if head and [Link] then
[Link] = orig
[Link] = 0
end
end
end
local function setHitboxEnabled(value)
hitboxEnabled = value

if hitboxConn then
hitboxConn:Disconnect()
hitboxConn = nil
end

if value then
hitboxConn = [Link]:Connect(function()
applyHitboxOnce()
end)
else
restoreHitbox()
end
end
------------------------------------------------------
-- Visuals Section ------------------------------------------------------
-- Time Changer Variables
local timeChangerEnabled = false
local currentTime = 12
local timeChangerConn
-- Time Changer Function
local function setTimeChangerEnabled(enabled)
timeChangerEnabled = enabled

if timeChangerConn then
timeChangerConn:Disconnect()
timeChangerConn = nil
end

if enabled then
timeChangerConn = [Link]:Connect(function()
[Link] = currentTime
end)
else
-- Reset to normal time when disabled
[Link] = 12
end
end
-- Fullbright Function
local fullbrightEnabled = false
local fullbrightConn
local function setFullbrightEnabled(enabled)
fullbrightEnabled = enabled

if fullbrightConn then
fullbrightConn:Disconnect()
fullbrightConn = nil
end

if enabled then
-- Store original lighting settings
local originalBrightness = [Link]
local originalAmbient = [Link]

fullbrightConn = [Link]:Connect(function()
[Link] = 2
[Link] = [Link](1, 1, 1)
[Link] = 100000
end)
else
-- Restore original settings
[Link] = 1
[Link] = [Link](128, 128, 128)
[Link] = 1000
end
end

------------------------------------------------------
-- Watermark Implementation ------------------------------------------------------
local watermarkEnabled = false
local watermarkRainbow = false
-- Watermark drawing objects
local canuseimages = pcall(function()
local a = [Link]("Image")
a:Remove()
end) and pcall(function()
local a = [Link]("Image")
rawget(a, "_frame").Image = ""
a:Remove()
end)
local watermarkText = [Link]("Text")
local watermarkGradR = [Link](canuseimages and "Image" or "Square")
local watermarkGradL = [Link](canuseimages and "Image" or "Square")
local watermarkGradBackground = [Link]("Square")
local watermarkTextBackground = [Link]("Square")
-- Initialize watermark properties
[Link] = 4
[Link] = 1
[Link] = true
[Link] = [Link]()
[Link] = [Link]
[Link] = 18
[Link] = [Link](1, 1, 1)
[Link] = 2
[Link] = 1
[Link] = 2
[Link] = 1
[Link] = 1
[Link] = 1
[Link] = true
[Link] = 3
[Link] = 0.337
[Link] = [Link](0,0,0)
[Link] = true
[Link] = 0
-- Set gradient images if supported
if canuseimages then
rawget(watermarkGradR, "_frame").Image = "rbxassetid://GRADIENT_IMAGE_ID_HERE"
rawget(watermarkGradL, "_frame").Image = "rbxassetid://GRADIENT_IMAGE_ID_HERE"
end
-- Watermark update function
local hue1, hue2, fpstimer, fps, finalfps = 0, 0.15, tick(), 0, 60
[Link]:Connect(function(delta)
fps = fps + 1
if fpstimer + 1 <= tick() then
fpstimer = tick()
finalfps = fps
fps = 0
end

hue1, hue2 = tick() % 1, tick() % 1 + 0.15

if hue1 >= 1 then hue1 = 0 end
if hue2 >= 1 then hue2 = 0 end

local rightcolor = watermarkRainbow and [Link](hue1, 1, 1) or

[Link](1,1,1)
local leftcolor = watermarkRainbow and [Link](hue2, 1, 1) or
[Link](1,1,1)

local watertext = ("DarkHook (PAID) | %s | %s fps"):format(

[Link]("%b %d %Y"),
tostring(finalfps)
)

[Link] = rightcolor
[Link] = leftcolor
[Link] = [Link]:Lerp([Link],
0.5)

[Link] = [Link]([Link].X + 9,
[Link].Y + 8)
[Link] = [Link](10, 10) + [Link](2, 2)

[Link] = [Link]([Link].X + 13,

[Link].Y + 12)
[Link] = [Link](10, 10)

[Link] = [Link](10, 10)

[Link] = [Link]([Link].X + 13,
[Link].Y + 12)

[Link] = [Link](10, 10)

[Link] = [Link]([Link].X + 13,
[Link].Y + 12)

[Link] = [Link](10, 10) + [Link](8, 7)

[Link] = watertext

[Link] = watermarkEnabled
[Link] = watermarkEnabled
[Link] = watermarkEnabled
[Link] = watermarkEnabled
[Link] = watermarkEnabled
end)

------------------------------------------------------
-- Exploits Features ------------------------------------------------------
-- Speed Hack Variables
local speedHackEnabled = false
local speedHackSpeed = 55
local niga, wtf = 55, 0
local middlePart = Workspace:FindFirstChild("Const") and
[Link]:FindFirstChild("Ignore") and
[Link]:FindFirstChild("LocalCharacter") and
[Link]:FindFirstChild("Middle")
-- Long Neck Variables
local longNeckEnabled = false
local topPart = Workspace:FindFirstChild("Const") and
[Link]:FindFirstChild("Ignore") and
[Link]:FindFirstChild("LocalCharacter") and
[Link]:FindFirstChild("Top")
local originalPrismCFrame = topPart and topPart:FindFirstChild("Prism1") and
[Link] or [Link]()
-- Free Cam Variables
local freeCamEnabled = false
local freeCamSpeed = 10
local freeCamOffset = [Link]
local originalCharacterCFrame = middlePart and [Link] or [Link]()
-- Fast Crouch Variables (renamed from Force Sprint)
local fastCrouchEnabled = false
-- Speed Hack Logic
[Link]:Connect(function(delta)
if speedHackEnabled and middlePart and UIS:IsKeyDown([Link].C) and
UIS:IsKeyDown([Link]) then
local cameralook = [Link]
cameralook = [Link](cameralook.X, 0, cameralook.Z)

local direction = [Link]

if UIS:IsKeyDown([Link].W) then direction = direction + cameralook end
if UIS:IsKeyDown([Link].S) then direction = direction - cameralook end
if UIS:IsKeyDown([Link].D) then direction = direction + [Link](-
cameralook.Z, 0, cameralook.X) end
if UIS:IsKeyDown([Link].A) then direction = direction +
[Link](cameralook.Z, 0, -cameralook.X) end

if direction ~= [Link] then

direction = [Link]
end

niga = [Link](niga - delta * 20, 17, speedHackSpeed)

if wtf == 0 then
[Link] = [Link] + [Link](0, 6.5, 0)
end

[Link] = [Link](
direction.X * niga,
wtf < 0.85 and 0 or -7,
direction.Z * niga
)

wtf = wtf + delta

else
niga = speedHackSpeed
wtf = 0
end
end)
-- Free Cam Logic
[Link]:Connect(function(delta)
if freeCamEnabled and middlePart then
[Link] = originalCharacterCFrame
[Link]:Wait()

if middlePart then
local cameralook = [Link]
local direction = [Link]

if UIS:IsKeyDown([Link].W) then direction = direction + cameralook end

if UIS:IsKeyDown([Link].S) then direction = direction - cameralook end
if UIS:IsKeyDown([Link].D) then direction = direction + [Link](-
cameralook.Z, 0, cameralook.X) end
if UIS:IsKeyDown([Link].A) then direction = direction +
[Link](cameralook.Z, 0, -cameralook.X) end

if direction ~= [Link] then

direction = [Link]
end

freeCamOffset = freeCamOffset + (direction * delta * freeCamSpeed)

[Link] = originalCharacterCFrame + freeCamOffset
[Link] = [Link]
end
elseif middlePart then
freeCamOffset = [Link]
originalCharacterCFrame = [Link]
end
end)
-- Fast Crouch Implementation (renamed from Force Sprint)
[Link]:Connect(function()
if fastCrouchEnabled and middlePart then
local cameralook = [Link]
cameralook = [Link](cameralook.X, 0, cameralook.Z)

local direction = [Link]

-- Calculate movement direction based on WASD keys

if UIS:IsKeyDown([Link].W) then direction = direction + cameralook end
if UIS:IsKeyDown([Link].S) then direction = direction - cameralook end
if UIS:IsKeyDown([Link].D) then direction = direction + [Link](-
cameralook.Z, 0, cameralook.X) end
if UIS:IsKeyDown([Link].A) then direction = direction +
[Link](cameralook.Z, 0, -cameralook.X) end

-- Normalize direction if moving

if direction ~= [Link] then
direction = [Link]
end

-- Apply constant crouching velocity at fixed speed of 19

[Link] = [Link](
direction.X * 19, -- Fixed speed of 19
[Link].Y, -- Preserve vertical velocity
direction.Z * 19 -- Fixed speed of 19
)
end
end)

------------------------------------------------------
-- ESP System - WITH FIXED 1000 STUD DISTANCE LIMIT AND STABLE BOX/SKELETON
------------------------------------------------------
local ESP = {
__loaded = false,
main_settings = {
textSize = 15,
textFont = [Link],
distancelimit = true, -- Always enabled
maxdistance = 1000, -- Fixed at 1000 studs
useteamcolor = false,
teamcheck = false,
sleepcheck = false,
simplecalc = true -- Use simple calculation for more stable ESP
},
settings = {
enemy = {
enabled = false,
box = false,
box_fill = false,
realname = false,
dist = false,
weapon = false,
skeleton = false,
box_outline = false,
realname_outline = false,
dist_outline = false,
weapon_outline = false,
box_color = { [Link](1, 1, 1), 1 },
box_fill_color = { [Link](1, 0, 0), 0.3 },
realname_color = { [Link](1, 1, 1), 1 },
dist_color = { [Link](1, 1, 1), 1 },
weapon_color = { [Link](1, 1, 1), 1 },
skeleton_color = { [Link](1, 1, 1), 1 },
box_outline_color = { [Link](), 1 },
realname_outline_color = [Link](),
dist_outline_color = [Link](),
weapon_outline_color = [Link](),
chams = false,
chams_visible_only = false,
chams_fill_color = { [Link](1, 1, 1), 0.5 },
chamsoutline_color = { [Link](1, 1, 1), 0 }
}
}
}

local workspace = game:GetService("Workspace")

local runService = game:GetService("RunService")
local camera = [Link]
local container = [Link]("Folder", game:GetService("CoreGui").RobloxGui)

-- Constants
local VERTICES = {
[Link](-1, -1, -1),
[Link](-1, 1, -1),
[Link](-1, 1, 1),
[Link](-1, -1, 1),
[Link](1, -1, -1),
[Link](1, 1, -1),
[Link](1, 1, 1),
[Link](1, -1, 1)
}

local skeleton_order = {
["LeftFoot"] = "LeftLowerLeg",
["LeftLowerLeg"] = "LeftUpperLeg",
["LeftUpperLeg"] = "LowerTorso",
["RightFoot"] = "RightLowerLeg",
["RightLowerLeg"] = "RightUpperLeg",
["RightUpperLeg"] = "LowerTorso",
["LeftHand"] = "LeftLowerArm",
["LeftLowerArm"] = "LeftUpperArm",
["LeftUpperArm"] = "Torso",
["RightHand"] = "RightLowerArm",
["RightLowerArm"] = "RightUpperArm",
["RightUpperArm"] = "Torso",
["LowerTorso"] = "Torso",
["Torso"] = "Head"
}

-- Helper functions
local function createDrawing(type, props)
local drawing = [Link](type)
for prop, value in pairs(props) do
drawing[prop] = value
end
return drawing
end

local function isBodyPart(name)

return name == "Head" or name:find("Torso") or name:find("Leg") or name:find("Arm")
end

-- Fixed getBoundingBox function for more stable ESP boxes

local function getBoundingBox(parts)
local min, max
for i = 1, #parts do
local part = parts[i]
local cframe, size = [Link], [Link]
min = (min or [Link]):Min((cframe - size * 0.5).Position)
max = (max or [Link]):Max((cframe + size * 0.5).Position)
end
local center = (min + max) * 0.5
local front = [Link](center.X, center.Y, max.Z)
return [Link](center, front), max - min
end

local function worldToScreen(world)

local screen, inBounds = camera:WorldToViewportPoint(world)
return [Link](screen.X, screen.Y), inBounds, screen.Z
end

-- Fixed calculateCorners function for more stable ESP boxes

local function calculateCorners(cframe, size)
local corners = {}
for i = 1, #VERTICES do
corners[i] = worldToScreen((cframe + size * 0.5 * VERTICES[i]).Position)
end
local min = [Link]([Link], [Link])
local max = [Link](-[Link], -[Link])
for _, corner in pairs(corners) do
min = [Link]([Link](min.X, corner.X), [Link](min.Y, corner.Y))
max = [Link]([Link](max.X, corner.X), [Link](max.Y, corner.Y))
end
return {
corners = corners,
topLeft = [Link]([Link](min.X), [Link](min.Y)),
topRight = [Link]([Link](max.X), [Link](min.Y)),
bottomLeft = [Link]([Link](min.X), [Link](max.Y)),
bottomRight = [Link]([Link](max.X), [Link](max.Y))
}
end

-- Fixed calculateCornersSimple function for more stable ESP boxes

local function calculateCornersSimple(head, hrp)
-- Use HumanoidRootPart if available, otherwise use the provided hrp (LowerTorso)
local humanoidRootPart = [Link]:FindFirstChild("HumanoidRootPart")
if humanoidRootPart then
hrp = humanoidRootPart
end
-- Use more stable positions for ESP box
local headPos = [Link] * [Link](0, [Link].Y/2, 0)
local feetPos = [Link] * [Link](0, -[Link].Y/2, 0)

local head_position = worldToScreen(headPos)

local leg_position = worldToScreen(feetPos)

if not head_position or not leg_position then return end

local headx, heady = head_position.X, head_position.Y

local legx, legy = leg_position.X, leg_position.Y
local height = legy - heady
local width = height / 3.6
return {
topLeft = [Link](headx - width, heady),
topRight = [Link](headx + width, heady),
bottomLeft = [Link](headx - width, legy),
bottomRight = [Link](headx + width, legy)
}
end

local function deepcopy(original)

local copy = {}
for key, value in pairs(original) do
copy[key] = type(value) == "table" and deepcopy(value) or value
end
return copy
end

-- ESP Implementation
local loaded_plrs = {}
local connections = {}

local function create_esp(model)

if model:FindFirstChild("Head") and model:FindFirstChild("LowerTorso") then
-- Player ESP
local settings = [Link]
loaded_plrs[model] = {
obj = {
box_fill = createDrawing("Square", { Filled = true, Visible = false }),
box_outline = createDrawing("Square", { Filled = false, Thickness = 3, Visible =
false, ZIndex = -1}),
box = createDrawing("Square", { Filled = false, Thickness = 1, Visible = false }),
realname = createDrawing("Text", { Center = true, Visible = false }),
dist = createDrawing("Text", { Center = true, Visible = false }),
weapon = createDrawing("Text", { Center = true, Visible = false }),
},
esp = {
current_gun = "",
corners = nil,
head = nil,
character = nil
},
chams_object = [Link]("Highlight", container),
}

-- Create skeleton lines

for required, _ in pairs(skeleton_order) do
loaded_plrs[model].obj["skeleton_" .. required] = createDrawing("Line", { Visible =
false })
end

local character = model

local head = character:FindFirstChild("Head")
local lowertorso = character:FindFirstChild("LowerTorso")
local plr = loaded_plrs[model]
local obj = [Link]
local cham = plr.chams_object
local box = [Link]
local box_outline = obj.box_outline
local box_fill = obj.box_fill
local realname = [Link]
local dist = [Link]
local weapon = [Link]
local main_settings = deepcopy(ESP.main_settings)
local settings = deepcopy([Link])
local setvis_cache = false

function plr:forceupdate()
main_settings = deepcopy(ESP.main_settings)
settings = deepcopy([Link])
[Link] = settings.chams_visible_only and [Link]
or [Link]
[Link] = settings.chams_fill_color[1]
[Link] = settings.chams_fill_color[2]
[Link] = settings.chamsoutline_color[1]
[Link] = settings.chamsoutline_color[2]
[Link] = settings.box_color[2]
[Link] = settings.box_color[1]
box_outline.Transparency = settings.box_outline_color[2]
box_outline.Color = settings.box_outline_color[1]
box_fill.Color = settings.box_fill_color[1]
box_fill.Transparency = settings.box_fill_color[2]
[Link] = main_settings.textSize
[Link] = main_settings.textFont
[Link] = settings.realname_color[1]
[Link] = settings.realname_outline
[Link] = settings.realname_outline_color
[Link] = settings.realname_color[2]
[Link] = main_settings.textSize
[Link] = main_settings.textFont
[Link] = settings.dist_color[1]
[Link] = settings.dist_outline
[Link] = settings.dist_outline_color
[Link] = settings.dist_color[2]
[Link] = main_settings.textSize
[Link] = main_settings.textFont
[Link] = settings.weapon_color[1]
[Link] = settings.weapon_outline
[Link] = settings.weapon_outline_color
[Link] = settings.weapon_color[2]

-- Update visibility based on current settings

[Link] = [Link] and [Link]
[Link] = [Link] and [Link]
box_outline.Visible = [Link] and settings.box_outline
box_fill.Visible = [Link] and settings.box_fill
[Link] = [Link] and [Link]
[Link] = [Link] and [Link]
[Link] = [Link] and [Link]

for required, _ in pairs(skeleton_order) do

local skeletonobj = obj["skeleton_" .. required]
if skeletonobj then
[Link] = settings.skeleton_color[1]
[Link] = settings.skeleton_color[2]
[Link] = [Link] and [Link]
end
end
end

function plr:togglevis(bool)
if setvis_cache ~= bool then
setvis_cache = bool
if not bool then
-- Hide all ESP elements
for _, v in pairs(obj) do [Link] = false end
[Link] = false
else
-- Show ESP elements based on current settings
plr:forceupdate()
end
end
end

-- ESP update function with fixed 1000 stud distance limit and stable box/skeleton
local function updateESP()
if not ([Link] and head and character) then
return plr:togglevis(false)
end

-- Calculate distance from camera to character

local distance = ([Link].p - [Link]).Magnitude

-- Check if distance exceeds fixed 1000 stud limit

if main_settings.distancelimit and distance > main_settings.maxdistance then
return plr:togglevis(false)
end

local _, onScreen = worldToScreen([Link])

if not onScreen then
return plr:togglevis(false)
end

local corners
if main_settings.simplecalc then
-- Use HumanoidRootPart if available, otherwise use LowerTorso
local hrp = character:FindFirstChild("HumanoidRootPart") or lowertorso
corners = calculateCornersSimple(head, hrp)
else
local cache = {}
local children = character:GetChildren()
for i = 1, #children do
local part = children[i]
if part:IsA("BasePart") and isBodyPart([Link]) then
cache[#cache + 1] = part
end
end
corners = calculateCorners(getBoundingBox(cache))
end

if not corners then

return plr:togglevis(false)
end

plr:togglevis(true)
[Link] = character

-- Update box
local pos = [Link]
local size = [Link] - [Link]
[Link] = pos
[Link] = size
box_outline.Position = pos + [Link]
box_outline.Size = size - [Link]
box_fill.Position = pos
box_fill.Size = size

-- Update name
[Link] = "Player"
[Link] = ([Link] + [Link]) * 0.5 - [Link] *
[Link].Y - [Link](0, 2)

-- Update distance and weapon

local bottom = ([Link] + [Link]) * 0.5
[Link] = tostring([Link](distance)) .. " studs"
[Link] = bottom
[Link] = "unknown"
[Link] = bottom + ([Link] and [Link] * [Link].Y -
[Link](0, 2) or [Link])

-- Update skeleton with stable positions

if [Link] then
for _, part in pairs(character:GetChildren()) do
local skeletonobj = obj["skeleton_" .. [Link]]
local parent_part = skeleton_order[[Link]] and
character:FindFirstChild(skeleton_order[[Link]])
if skeletonobj and parent_part then
-- Use CFrame positions for more stable skeleton
local part_position = camera:WorldToViewportPoint([Link])
local parent_part_position =
camera:WorldToViewportPoint(parent_part.[Link])
[Link] = [Link](part_position.X, part_position.Y)
[Link] = [Link](parent_part_position.X, parent_part_position.Y)
end
end
end
end

[Link] = updateESP
-- Use Heartbeat instead of RenderStepped for more stable updates
[Link] = [Link]:Connect(updateESP)
plr:forceupdate()
end
end
local function destroy_esp(model)
local plr_object = loaded_plrs[model]
if not plr_object then return end

if plr_object.connection then
plr_object.connection:Disconnect()
end
for _, v in pairs(plr_object.obj) do
v:Remove()
end
if plr_object.chams_object then
plr_object.chams_object:Destroy()
end
loaded_plrs[model] = nil
end

-- Scan workspace for character models

local function scanForCharacters()
for _, model in ipairs(workspace:GetChildren()) do
if model:IsA("Model") and model:FindFirstChild("Head") and
model:FindFirstChild("LowerTorso") then
if not loaded_plrs[model] then
create_esp(model)
end
end
end
end

-- Public functions
function [Link]()
if ESP.__loaded then return end

-- Scan for existing characters

scanForCharacters()

-- Connect to new models

[Link](connections, [Link]:Connect(function(model)
if model:IsA("Model") and model:FindFirstChild("Head") and
model:FindFirstChild("LowerTorso") then
create_esp(model)
end
end))

-- Connect to removed models

[Link](connections, [Link]:Connect(function(model)
if loaded_plrs[model] then
destroy_esp(model)
end
end))

ESP.__loaded = true
end

function [Link]()
if not ESP.__loaded then return end

-- Remove all ESP

for model, _ in pairs(loaded_plrs) do
destroy_esp(model)
end

-- Disconnect all connections

for _, conn in ipairs(connections) do
conn:Disconnect()
end
connections = {}

ESP.__loaded = false
end

function [Link]()
-- Unload first to clear everything
[Link]()

-- Then reload to start fresh

[Link]()

-- Force update all ESP elements

[Link]()
end

-- UpdateAll function to force immediate ESP update

function [Link]()
for _, v in pairs(loaded_plrs) do
v:forceupdate()
-- Force immediate ESP update
if [Link] then
[Link]()
end
end
end

-- Initialize ESP but keep it disabled

[Link]()

------------------------------------------------------
-- Object ESP System ------------------------------------------------------
local ObjectESP = {
loaded = false,
settings = {
textSize = 15,
objects = {
stone = {enabled = false, showName = false, showChams = false, color =
[Link](0, 0, 255)},
iron = {enabled = false, showName = false, showChams = false, color =
[Link](255, 0, 0)},
nitrate = {enabled = false, showName = false, showChams = false, color =
[Link](0, 255, 0)}
}
}
}
-- Create a container for ESP objects
local objectESPContainer = [Link]("Folder",
game:GetService("CoreGui").RobloxGui)
[Link] = "ObjectESP_Container"
-- Helper function to create drawing objects
local function createDrawing(type, properties)
local drawing = [Link](type)
for prop, value in pairs(properties) do
drawing[prop] = value
end
return drawing
end
-- Helper function to convert 3D position to 2D screen position
local function worldToScreenObject(position)
local screenPos, onScreen = [Link]:WorldToViewportPoint(position)
return [Link](screenPos.X, screenPos.Y), onScreen, screenPos.Z
end
-- Identify object type based on its properties
local function identifyObjectType(model)
if [Link] ~= "Model" then return nil end

local meshPart = model:FindFirstChildOfClass("MeshPart")

if not meshPart or [Link] ~= "rbxassetid://12939036056" then return nil
end

if #model:GetChildren() == 1 then
return "stone", meshPart
else
for _, part in ipairs(model:GetChildren()) do
if [Link] == [Link](248, 248, 248) then
return "nitrate", part
elseif [Link] == [Link](199, 172, 120) then
return "iron", part
end
end
end

return nil
end
-- Table to store active ESP objects
local activeObjectESP = {}
-- Create ESP for a specific object
local function createObjectESP(model)
local objType, mainPart = identifyObjectType(model)
if not objType or not mainPart then return end

-- Create ESP data structure

activeObjectESP[model] = {
type = objType,
mainPart = mainPart,
textLabel = createDrawing("Text", {
Text = objType,
Center = true,
Visible = false,
Size = [Link],
Font = [Link],
Color = [Link][objType].color
}),
highlight = [Link]("Highlight", objectESPContainer)
}

local espData = activeObjectESP[model]

[Link] = [Link][objType].color
[Link] = 0.5
[Link] = 1
[Link] = model

-- Update ESP visibility and position

local function updateESP()
local config = [Link][objType]
if not [Link] then
[Link] = false
[Link] = false
return
end

local screenPos, onScreen = worldToScreenObject([Link])

if not onScreen then
[Link] = false
[Link] = false
return
end

-- Update visibility
[Link] = [Link]
[Link] = [Link]

-- Update position
[Link] = screenPos
end

-- Connect update function to heartbeat

[Link] = [Link]:Connect(updateESP)
updateESP() -- Initial update
end
-- Remove ESP for a specific object
local function removeObjectESP(model)
local espData = activeObjectESP[model]
if not espData then return end

if [Link] then
[Link]:Disconnect()
end

if [Link] then
[Link]:Remove()
end

if [Link] then
[Link]:Destroy()
end

activeObjectESP[model] = nil
end
-- Initialize ESP system
local function initializeObjectESP()
if [Link] then return end

-- Add ESP to existing objects

for _, model in ipairs(Workspace:GetChildren()) do
createObjectESP(model)
end

-- Connect to new objects

[Link]:Connect(function(model)
createObjectESP(model)
end)

-- Clean up removed objects

[Link]:Connect(function(model)
removeObjectESP(model)
end)

[Link] = true
end
-- Shutdown ESP system
local function shutdownObjectESP()
if not [Link] then return end

-- Remove all ESP

for model, _ in pairs(activeObjectESP) do
removeObjectESP(model)
end

[Link] = false
end
-- Update all ESP elements
local function updateAllObjectESP()
for _, espData in pairs(activeObjectESP) do
if [Link] then
[Link]:Disconnect()
end

local objType = [Link]

local config = [Link][objType]

[Link] = [Link] and [Link]

[Link] = [Link] and [Link]
[Link] = [Link]
[Link] = [Link]

[Link] = [Link]:Connect(function()
local screenPos, onScreen = worldToScreenObject([Link])
[Link] = [Link] and [Link] and onScreen
[Link] = [Link] and [Link]
[Link] = screenPos
end)
end
end

------------------------------------------------------
-- BONUS FEATURES ------------------------------------------------------
-- FOV Changer - FIXED VERSION
local fovEnabled = false
local fovValue = 70
local originalFov = 70
local fovConnection = nil

-- FOV Changer Function - FIXED

local function setFov(enabled, value)
fovEnabled = enabled
fovValue = value
-- Disconnect any existing connection
if fovConnection then
fovConnection:Disconnect()
fovConnection = nil
end

if enabled then
-- Create a connection to continuously set the FOV
fovConnection = [Link]:Connect(function()
[Link] = fovValue
end)
else
-- Reset to original FOV
[Link] = originalFov
end
end

------------------------------------------------------
-- Populate UI ------------------------------------------------------
-- Combat Tab
createCheckbox(pages["Combat"], "Hitbox Expander (Head)", function(v)
setHitboxEnabled(v) end)
createSlider(pages["Combat"], "Hitbox Transparency", 0, 1, hitboxHeadTransparency,
1, function(val)
hitboxHeadTransparency = val
if hitboxEnabled then applyHitboxOnce() end
end)
createSlider(pages["Combat"], "Hitbox Size X", 1, 15, hitboxHeadSizeX, 0,
function(val)
hitboxHeadSizeX = val
if hitboxEnabled then applyHitboxOnce() end
end)
createSlider(pages["Combat"], "Hitbox Size Y", 1, 15, hitboxHeadSizeY, 0,
function(val)
hitboxHeadSizeY = val
if hitboxEnabled then applyHitboxOnce() end
end)

-- Visuals Tab (now includes all visual features)

createCheckbox(pages["Visuals"], "Time Changer", setTimeChangerEnabled)
createSlider(pages["Visuals"], "Time", 0, 24, currentTime, 0, function(value)
currentTime = value
if timeChangerEnabled then
[Link] = currentTime
end
end)
createCheckbox(pages["Visuals"], "Fullbright", setFullbrightEnabled)
createCheckbox(pages["Visuals"], "Low Graphics", setLowGraphics)
createCheckbox(pages["Visuals"], "Crosshair", setCrosshair)

-- BONUS: FOV Changer - FIXED VERSION

createCheckbox(pages["Visuals"], "FOV Changer", function(enabled)
setFov(enabled, fovValue)
end)

createSlider(pages["Visuals"], "FOV Value", 30, 120, fovValue, 0, function(value)

if fovEnabled then
setFov(true, value)
else
fovValue = value
end
end)

-- Object ESP Section

local objectESPHeader = [Link]("TextLabel", pages["Visuals"])
[Link] = [Link](1, -20, 0, 25)
[Link] = 1
[Link] = "Object ESP"
objectESPHeader.TextColor3 = [Link](1,1,1)
[Link] = [Link]
[Link] = [Link]
[Link] = 16

-- Function to create object ESP row

local function createObjectESPRow(parent, title, color, objType)
-- Create a container frame for the row
local container = [Link]("Frame", parent)
[Link] = [Link](1, -20, 0, 25)
[Link] = 1

-- Title label
local titleLabel = [Link]("TextLabel", container)
[Link] = [Link](0, 80, 1, 0)
[Link] = 1
[Link] = title
titleLabel.TextColor3 = color
[Link] = [Link]
[Link] = 16
[Link] = [Link]

-- ESP checkbox
local espBox = [Link]("TextButton", container)
[Link] = [Link](0, 20, 0, 20)
[Link] = [Link](0, 90, 0.5, -10)
espBox.BackgroundColor3 = [Link](60,60,60)
[Link] = ""

local espLabel = [Link]("TextLabel", container)

[Link] = [Link](0, 115, 0, 0)
[Link] = [Link](0, 50, 1, 0)
[Link] = 1
[Link] = "ESP"
espLabel.TextColor3 = color
[Link] = [Link]
[Link] = 14
[Link] = [Link]

-- Name checkbox
local nameBox = [Link]("TextButton", container)
[Link] = [Link](0, 20, 0, 20)
[Link] = [Link](0, 170, 0.5, -10)
nameBox.BackgroundColor3 = [Link](60,60,60)
[Link] = ""

local nameLabel = [Link]("TextLabel", container)

[Link] = [Link](0, 195, 0, 0)
[Link] = [Link](0, 50, 1, 0)
[Link] = 1
[Link] = "Name"
nameLabel.TextColor3 = color
[Link] = [Link]
[Link] = 14
[Link] = [Link]

-- Chams checkbox
local chamsBox = [Link]("TextButton", container)
[Link] = [Link](0, 20, 0, 20)
[Link] = [Link](0, 250, 0.5, -10)
chamsBox.BackgroundColor3 = [Link](60,60,60)
[Link] = ""

local chamsLabel = [Link]("TextLabel", container)

[Link] = [Link](0, 275, 0, 0)
[Link] = [Link](0, 50, 1, 0)
[Link] = 1
[Link] = "Chams"
chamsLabel.TextColor3 = color
[Link] = [Link]
[Link] = 14
[Link] = [Link]

-- Return the checkboxes so we can connect events later

return espBox, nameBox, chamsBox
end

-- Create Stone ESP row

local stoneESPBox, stoneESPNameBox, stoneESPChamsBox =
createObjectESPRow(pages["Visuals"], "STONE", [Link](0, 0, 255), "stone")

-- Create Iron ESP row

local ironESPBox, ironESPNameBox, ironESPChamsBox =
createObjectESPRow(pages["Visuals"], "IRON", [Link](255, 0, 0), "iron")

-- Create Nitrate ESP row

local nitrateESPBox, nitrateESPNameBox, nitrateESPChamsBox =
createObjectESPRow(pages["Visuals"], "NITRATE", [Link](0, 255, 0),
"nitrate")

-- Stone ESP connections

local stoneESPToggled = false
stoneESPBox.MouseButton1Click:Connect(function()
stoneESPToggled = not stoneESPToggled
stoneESPBox.BackgroundColor3 = stoneESPToggled and [Link](0,170,0) or
[Link](60,60,60)
[Link] = stoneESPToggled
updateAllObjectESP()
end)

local stoneESPNameToggled = false

stoneESPNameBox.MouseButton1Click:Connect(function()
stoneESPNameToggled = not stoneESPNameToggled
stoneESPNameBox.BackgroundColor3 = stoneESPNameToggled and [Link](0,170,0)
or [Link](60,60,60)
[Link] = stoneESPNameToggled
updateAllObjectESP()
end)
local stoneESPChamsToggled = false
stoneESPChamsBox.MouseButton1Click:Connect(function()
stoneESPChamsToggled = not stoneESPChamsToggled
stoneESPChamsBox.BackgroundColor3 = stoneESPChamsToggled and
[Link](0,170,0) or [Link](60,60,60)
[Link] = stoneESPChamsToggled
updateAllObjectESP()
end)

-- Iron ESP connections

local ironESPToggled = false
ironESPBox.MouseButton1Click:Connect(function()
ironESPToggled = not ironESPToggled
ironESPBox.BackgroundColor3 = ironESPToggled and [Link](0,170,0) or
[Link](60,60,60)
[Link] = ironESPToggled
updateAllObjectESP()
end)

local ironESPNameToggled = false

ironESPNameBox.MouseButton1Click:Connect(function()
ironESPNameToggled = not ironESPNameToggled
ironESPNameBox.BackgroundColor3 = ironESPNameToggled and [Link](0,170,0) or
[Link](60,60,60)
[Link] = ironESPNameToggled
updateAllObjectESP()
end)

local ironESPChamsToggled = false

ironESPChamsBox.MouseButton1Click:Connect(function()
ironESPChamsToggled = not ironESPChamsToggled
ironESPChamsBox.BackgroundColor3 = ironESPChamsToggled and [Link](0,170,0)
or [Link](60,60,60)
[Link] = ironESPChamsToggled
updateAllObjectESP()
end)

-- Nitrate ESP connections

local nitrateESPToggled = false
nitrateESPBox.MouseButton1Click:Connect(function()
nitrateESPToggled = not nitrateESPToggled
nitrateESPBox.BackgroundColor3 = nitrateESPToggled and [Link](0,170,0) or
[Link](60,60,60)
[Link] = nitrateESPToggled
updateAllObjectESP()
end)

local nitrateESPNameToggled = false

nitrateESPNameBox.MouseButton1Click:Connect(function()
nitrateESPNameToggled = not nitrateESPNameToggled
nitrateESPNameBox.BackgroundColor3 = nitrateESPNameToggled and
[Link](0,170,0) or [Link](60,60,60)
[Link] = nitrateESPNameToggled
updateAllObjectESP()
end)

local nitrateESPChamsToggled = false

nitrateESPChamsBox.MouseButton1Click:Connect(function()
nitrateESPChamsToggled = not nitrateESPChamsToggled
nitrateESPChamsBox.BackgroundColor3 = nitrateESPChamsToggled and
[Link](0,170,0) or [Link](60,60,60)
[Link] = nitrateESPChamsToggled
updateAllObjectESP()
end)

-- Initialize Object ESP system

initializeObjectESP()

-- Misc Tab
-- Watermark Section
local watermarkHeader = [Link]("TextLabel", pages["Misc"])
[Link] = [Link](1, -20, 0, 25)
[Link] = 1
[Link] = "Watermark"
watermarkHeader.TextColor3 = [Link](1,1,1)
[Link] = [Link]
[Link] = [Link]
[Link] = 16
-- Create a container for the watermark options
local watermarkContainer = [Link]("Frame", pages["Misc"])
[Link] = [Link](1, -20, 0, 25)
[Link] = 1
-- Enable Watermark Checkbox
local enableWatermarkBox = [Link]("TextButton", watermarkContainer)
[Link] = [Link](0, 20, 0, 20)
[Link] = [Link](0, 0, 0.5, -10)
enableWatermarkBox.BackgroundColor3 = [Link](60,60,60)
[Link] = ""
local enableWatermarkLabel = [Link]("TextLabel", watermarkContainer)
[Link] = [Link](0, 30, 0, 0)
[Link] = [Link](0, 120, 1, 0)
[Link] = 1
[Link] = "Enable Watermark"
enableWatermarkLabel.TextColor3 = [Link](1,1,1)
[Link] = [Link]
-- Rainbow Mode Checkbox
local rainbowModeBox = [Link]("TextButton", watermarkContainer)
[Link] = [Link](0, 20, 0, 20)
[Link] = [Link](0, 160, 0.5, -10)
rainbowModeBox.BackgroundColor3 = [Link](60,60,60)
[Link] = ""
local rainbowModeLabel = [Link]("TextLabel", watermarkContainer)
[Link] = [Link](0, 190, 0, 0)
[Link] = [Link](0, 100, 1, 0)
[Link] = 1
[Link] = "Rainbow Mode"
rainbowModeLabel.TextColor3 = [Link](1,1,1)
[Link] = [Link]
-- Watermark toggle state
local watermarkToggled = false
local rainbowToggled = false
-- Enable Watermark functionality
enableWatermarkBox.MouseButton1Click:Connect(function()
watermarkToggled = not watermarkToggled
enableWatermarkBox.BackgroundColor3 = watermarkToggled and [Link](0,170,0)
or [Link](60,60,60)
watermarkEnabled = watermarkToggled
end)
-- Rainbow Mode functionality
rainbowModeBox.MouseButton1Click:Connect(function()
rainbowToggled = not rainbowToggled
rainbowModeBox.BackgroundColor3 = rainbowToggled and [Link](0,170,0) or
[Link](60,60,60)
watermarkRainbow = rainbowToggled
end)

-- Exploits Tab
-- Speed Hack with keybind
local speedHackWidget = createCheckboxWithKeybind(pages["Exploits"], "Speed Hack",
[Link].Y, function(enabled)
speedHackEnabled = enabled
if not enabled then
niga = speedHackSpeed
wtf = 0
end
end)
createSlider(pages["Exploits"], "Speed Hack Speed", 55, 70, 55, 0, function(value)
speedHackSpeed = value
if not speedHackEnabled then
niga = value
end
end)
-- Long Neck with keybind
local longNeckWidget = createCheckboxWithKeybind(pages["Exploits"], "Long Neck",
[Link].T, function(enabled)
longNeckEnabled = enabled
if topPart and topPart:FindFirstChild("Prism1") then
[Link] = enabled and (originalPrismCFrame - [Link](0, 5, 0)) or
originalPrismCFrame
end
end)
-- Free Cam with keybind
local freeCamWidget = createCheckboxWithKeybind(pages["Exploits"], "Free Cam",
[Link], function(enabled)
freeCamEnabled = enabled
if middlePart then
[Link] = not enabled
end
if not enabled then
freeCamOffset = [Link]
if middlePart then
originalCharacterCFrame = [Link]
end
end
end)
createSlider(pages["Exploits"], "Free Cam Speed", 1, 300, 10, 0, function(value)
freeCamSpeed = value
end)
-- Fast Crouch with keybind (renamed from Force Sprint)
local fastCrouchWidget = createCheckboxWithKeybind(pages["Exploits"], "Fast
Crouch", [Link], function(enabled)
fastCrouchEnabled = enabled
end)

-- ESP Tab
createCheckbox(pages["ESP"], "Enable ESP", function(enabled)
[Link] = enabled
if enabled then
-- Force rescan when enabling
scanForCharacters()
end
[Link]()
end)
createCheckbox(pages["ESP"], "Player Box", function(enabled)
[Link] = enabled
[Link]()
end)
createCheckbox(pages["ESP"], "Player Name", function(enabled)
[Link] = enabled
[Link]()
end)
createCheckbox(pages["ESP"], "Player Distance", function(enabled)
[Link] = enabled
[Link]()
end)
createCheckbox(pages["ESP"], "Player Skeleton", function(enabled)
[Link] = enabled
[Link]()
end)
createCheckbox(pages["ESP"], "Player Chams", function(enabled)
[Link] = enabled
[Link]()
end)

createSlider(pages["ESP"], "Text Size", 8, 24, ESP.main_settings.textSize, 0,

function(value)
ESP.main_settings.textSize = value
[Link]()
end)

------------------------------------------------------
-- Keybind Input Handlers ------------------------------------------------------
[Link]:Connect(function(input, processed)
if processed then return end

-- Speed Hack Keybind

if [Link] == [Link]() then
[Link](not [Link]())
end

-- Long Neck Keybind

if [Link] == [Link]() then
[Link](not [Link]())
end

-- Free Cam Keybind

if [Link] == [Link]() then
[Link](not [Link]())
end

-- Fast Crouch Keybind (renamed from Force Sprint)

if [Link] == [Link]() then
[Link](not [Link]())
end
end)
------------------------------------------------------
-- Toggle UI with RightShift ------------------------------------------------------
[Link]:Connect(function(input, processed)
if not processed and [Link] == [Link] then
[Link] = not [Link]
end
end)