--[[
    Street Life Remastered menu
    place 71600459831333

    Combat  : aimlock, aim filters, hitbox, gun mods
    Visuals : ESP, graphics, FOV, sky
    Main    : local player mods + vehicle mods
    Player  : target list, spectate, teleports, kill, emotes, shops, clean farm
]]

if getgenv().SLR_Menu then
    pcall(function() getgenv().SLR_Menu:Destroy() end)
end

local Library = loadstring(game:HttpGet("https://pastebin.com/raw/9XNEa0jz"))()

local Players           = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService        = game:GetService("RunService")
local UserInputService  = game:GetService("UserInputService")
local TweenService      = game:GetService("TweenService")
local TeleportService   = game:GetService("TeleportService")
local Lighting          = game:GetService("Lighting")
local Workspace         = game:GetService("Workspace")
local VirtualUser       = game:GetService("VirtualUser")
local GuiService        = game:GetService("GuiService")
local CollectionService = game:GetService("CollectionService")
local ProximityPromptService = game:GetService("ProximityPromptService")

local LocalPlayer = Players.LocalPlayer

local Icons = {
    Main = "rbxassetid://117259180607823",
    Combat = "rbxassetid://126193793480527",
    Visuals = "rbxassetid://127234874352422",
    Settings = "rbxassetid://6031280882",
    Logo = "rbxassetid://127120679730794",
}

local Connections = {}
local function track(connection)
    if connection then
        table.insert(Connections, connection)
    end
    return connection
end

local function camera()
    return Workspace.CurrentCamera
end

local function getCharacter(player)
    player = player or LocalPlayer
    return player.Character
end

local function getRoot(player)
    local character = getCharacter(player)
    return character and character:FindFirstChild("HumanoidRootPart")
end

local function getHumanoid(player)
    local character = getCharacter(player)
    return character and character:FindFirstChildOfClass("Humanoid")
end

local function getHead(player)
    local character = getCharacter(player)
    local head = character and character:FindFirstChild("Head")
    if head and head:IsA("BasePart") then
        return head
    end
    return nil
end

local function round(value)
    if typeof(value) == "Vector2" then
        return Vector2.new(math.floor(value.X + 0.5), math.floor(value.Y + 0.5))
    end
    return math.floor(value + 0.5)
end

local function studsToMeters(studs)
    return studs * 0.28
end

local function worldToViewport(position)
    local screen, onScreen = camera():WorldToViewportPoint(position)
    return Vector2.new(screen.X, screen.Y), onScreen, screen.Z
end

local function newRaycastParams(ignore)
    local filtered = {}
    for _, instance in ipairs(ignore or {}) do
        if instance then
            table.insert(filtered, instance)
        end
    end
    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Exclude
    params.FilterDescendantsInstances = filtered
    params.IgnoreWater = true
    return params
end

local function hasLineOfSight(origin, target, ignore)
    local result = Workspace:Raycast(origin, target - origin, newRaycastParams(ignore))
    return result == nil
end

local function playerList(excludeLocal)
    local list = {}
    for _, player in ipairs(Players:GetPlayers()) do
        if not excludeLocal or player ~= LocalPlayer then
            table.insert(list, player.Name)
        end
    end
    table.sort(list)
    return list
end

local function aimPoint()
    local viewport = camera().ViewportSize
    if UserInputService.TouchEnabled and not UserInputService.KeyboardEnabled then
        return Vector2.new(viewport.X * 0.5, viewport.Y * 0.5)
    end
    local ok, mx, my = pcall(function()
        local mouse = LocalPlayer:GetMouse()
        return mouse.X, mouse.Y
    end)
    if ok and mx then
        return Vector2.new(mx, my - GuiService:GetGuiInset().Y)
    end
    return Vector2.new(viewport.X * 0.5, viewport.Y * 0.5)
end

local function notify(text)
    print("[SLR] " .. tostring(text))
    pcall(function()
        if Library.Notify then
            Library:Notify({ Title = "SLR", Description = tostring(text), Duration = 4 })
        elseif Library.Notification then
            Library:Notification({ Name = "SLR", Info = tostring(text), LifeTime = 4 })
        end
    end)
end

--============= anti-cheat bypass =============--
-- Client67 is the LocalScript that owns the ChangeSetting handler. Capturing its
-- settings payload and hanging task.wait for that script's stack keeps the
-- client-side tamper check idle; the captured payload is re-saved on a timer so
-- the server copy stays in sync.
local Bypass = { active = false, note = "starting", payload = nil, hooked = 0 }

task.spawn(function()
    local existing = getgenv().__SLR_BypassState
    if type(existing) == "table" and existing.active then
        Bypass = existing
        return
    end

    local scripts = LocalPlayer:WaitForChild("PlayerScripts", 15)
    local weather = scripts and scripts:FindFirstChild("WeatherSystem")
    if not weather then
        Bypass.note = "WeatherSystem missing"
        return
    end

    local remotes = ReplicatedStorage:WaitForChild("Remotes", 15)
    local changeSetting = remotes and remotes:FindFirstChild("ChangeSetting")
    if not changeSetting then
        Bypass.note = "ChangeSetting missing"
        return
    end

    if type(getconnections) ~= "function" or type(hookfunction) ~= "function" then
        Bypass.note = "executor missing getconnections/hookfunction"
        return
    end

    local caught = nil
    local ok, connections = pcall(getconnections, changeSetting.OnClientEvent)
    if ok then
        for _, connection in ipairs(connections) do
            local fn = connection.Function
            if type(fn) == "function" then
                pcall(hookfunction, fn, newcclosure(function(payload)
                    caught = payload
                end))
                Bypass.hooked = Bypass.hooked + 1
                break
            end
        end
    end

    if Bypass.hooked == 0 then
        Bypass.note = "no ChangeSetting connection"
        return
    end

    local deadline = os.clock() + 25
    while not caught and os.clock() < deadline do
        task.wait(0.25)
    end
    if not caught then
        Bypass.note = "no settings payload"
        return
    end

    Bypass.payload = caught
    task.wait(0.25)

    local oldWait
    oldWait = hookfunction(getrenv().task.wait, function(...)
        local trace = debug.traceback()
        if type(trace) == "string" and trace:find("Client67", 1, true) then
            return oldWait(9000000000)
        end
        return oldWait(...)
    end)

    Bypass.active = true
    Bypass.note = "bypassed"
    getgenv().__SLR_BypassState = Bypass

    task.spawn(function()
        while true do
            task.wait(math.random(3, 5))
            pcall(function()
                changeSetting:FireServer("SaveSettings", "Update", Bypass.payload)
            end)
        end
    end)
end)

--============= ESP =============--
local ESP = {
    options = {
        enabled = false,
        boundingBox = false,
        boundingBoxDescending = false,
        excludedPartNames = { "HumanoidRootPart" },
        font = 2,
        fontSize = 13,
        minScaleFactorX = 1,
        maxScaleFactorX = 10,
        minScaleFactorY = 1,
        maxScaleFactorY = 10,
        scaleFactorX = 5,
        scaleFactorY = 6.5,
        limitDistance = false,
        maxDistance = 1000,
        visibleOnly = false,
        teamCheck = false,
        teamColor = false,
        useCustomTeamColor = false,
        customTeamColor = Color3.new(1, 1, 1),
        fillColor = nil,
        whitelistColor = Color3.new(1, 0, 0),
        names = false,
        nameTransparency = 1,
        nameColor = Color3.new(1, 1, 1),
        boxes = false,
        boxesTransparency = 1,
        boxesColor = Color3.new(1, 1, 1),
        boxFill = false,
        boxFillTransparency = 0.5,
        boxFillColor = Color3.new(1, 1, 1),
        healthBars = false,
        healthBarsSize = 1,
        healthBarsTransparency = 1,
        healthBarsColor = Color3.new(0, 1, 0),
        healthText = false,
        healthTextTransparency = 1,
        healthTextSuffix = "%",
        healthTextColor = Color3.new(1, 1, 1),
        distance = false,
        distanceTransparency = 1,
        distanceSuffix = "m",
        distanceColor = Color3.new(1, 1, 1),
        tool = false,
        toolTransparency = 1,
        toolColor = Color3.new(1, 1, 1),
        tracers = false,
        tracerTransparency = 1,
        tracerColor = Color3.new(1, 1, 1),
        tracerOrigin = "Bottom",
        chams = false,
        chamsFillColor = Color3.new(1, 0, 0),
        chamsFillTransparency = 0.5,
        chamsOutlineColor = Color3.new(),
        chamsOutlineTransparency = 0,
        outOfViewArrows = false,
        outOfViewArrowsFilled = false,
        outOfViewArrowsSize = 25,
        outOfViewArrowsRadius = 100,
        outOfViewArrowsColor = Color3.new(1, 1, 1),
        outOfViewArrowsTransparency = 0.5,
    },
    cache = {},
    chams = {},
    gui = nil,
    frames = 0,
    lastError = nil,
}

local ESP_OBJECTS = {
    { "boxFill", "Square", { Thickness = 1, Filled = true } },
    { "boxOutline", "Square", { Thickness = 3, Color = Color3.new() } },
    { "box", "Square", { Thickness = 1 } },
    { "healthBarOutline", "Square", { Thickness = 1, Color = Color3.new(), Filled = true } },
    { "healthBar", "Square", { Thickness = 1, Filled = true } },
    { "tracerOutline", "Line", { Thickness = 3, Color = Color3.new() } },
    { "tracer", "Line", { Thickness = 1 } },
    { "arrow", "Triangle", { Thickness = 2, Filled = false } },
    { "arrowOutline", "Triangle", { Thickness = 1, Filled = false } },
    { "name", "Text", { Center = true, Outline = true, OutlineColor = Color3.new() } },
    { "healthText", "Text", { Outline = true, OutlineColor = Color3.new() } },
    { "tool", "Text", { Center = true, Outline = true, OutlineColor = Color3.new() } },
    { "distanceText", "Text", { Center = true, Outline = true, OutlineColor = Color3.new() } },
}

local function hasDrawing()
    return Drawing ~= nil and type(Drawing.new) == "function"
end

local function createDrawing(class, props)
    if not hasDrawing() then
        return nil
    end
    local ok, object = pcall(function()
        return Drawing.new(class)
    end)
    if not ok or not object then
        return nil
    end
    if props then
        for key, value in pairs(props) do
            object[key] = value
        end
    end
    return object
end

local function destroyDrawing(object)
    if object then
        pcall(function()
            object:Remove()
        end)
    end
end

local function hideObjects(objects)
    for _, object in pairs(objects) do
        object.Visible = false
    end
end

function ESP:getTeamColor(player)
    local team = player.Team
    return team and player.TeamColor.Color or nil
end

function ESP:getToolName(player)
    local character = player.Character
    local tool = character and character:FindFirstChildOfClass("Tool")
    return tool and tool.Name or "None"
end

function ESP:getBounds(character, root)
    if not self.options.boundingBox then
        return root.Position, Vector3.new(self.options.scaleFactorX, self.options.scaleFactorY, 1)
    end

    local minimum = Vector3.new(math.huge, math.huge, math.huge)
    local maximum = Vector3.new(-math.huge, -math.huge, -math.huge)
    local parts = self.options.boundingBoxDescending and character:GetDescendants() or character:GetChildren()

    for _, part in ipairs(parts) do
        if part:IsA("BasePart") and not table.find(self.options.excludedPartNames, part.Name) then
            local size = part.Size
            local x, y, z, r00, r01, r02, r10, r11, r12, r20, r21, r22 = part.CFrame:GetComponents()

            local extentX = 0.5 * (math.abs(r00) * size.X + math.abs(r01) * size.Y + math.abs(r02) * size.Z)
            local extentY = 0.5 * (math.abs(r10) * size.X + math.abs(r11) * size.Y + math.abs(r12) * size.Z)
            local extentZ = 0.5 * (math.abs(r20) * size.X + math.abs(r21) * size.Y + math.abs(r22) * size.Z)

            minimum = Vector3.new(
                math.min(minimum.X, x - extentX),
                math.min(minimum.Y, y - extentY),
                math.min(minimum.Z, z - extentZ)
            )
            maximum = Vector3.new(
                math.max(maximum.X, x + extentX),
                math.max(maximum.Y, y + extentY),
                math.max(maximum.Z, z + extentZ)
            )
        end
    end

    if minimum.X == math.huge then
        return root.Position, Vector3.new(self.options.scaleFactorX, self.options.scaleFactorY, 1)
    end

    return (minimum + maximum) * 0.5, maximum - minimum
end

function ESP:getColor(player)
    if self.options.fillColor ~= nil then
        return self.options.fillColor
    end
    if self.options.teamColor then
        if self.options.useCustomTeamColor then
            return self.options.customTeamColor
        end
        return self:getTeamColor(player)
    end
    return nil
end

function ESP:createObjects()
    local objects = {}
    for _, definition in ipairs(ESP_OBJECTS) do
        local object = createDrawing(definition[2], definition[3])
        if not object then
            for _, created in pairs(objects) do
                destroyDrawing(created)
            end
            return nil
        end
        objects[definition[1]] = object
    end
    return objects
end

function ESP:addPlayer(player)
    if player == LocalPlayer or self.cache[player] then
        return
    end

    local objects = self:createObjects()
    if not objects then
        return
    end
    self.cache[player] = objects

    local highlight = Instance.new("Highlight")
    highlight.Name = "SLR_Chams"
    highlight.Enabled = false
    highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    highlight.Parent = self.gui
    self.chams[player] = highlight
end

function ESP:removePlayer(player)
    local objects = self.cache[player]
    if objects then
        for _, object in pairs(objects) do
            destroyDrawing(object)
        end
        self.cache[player] = nil
    end

    local highlight = self.chams[player]
    if highlight then
        highlight:Destroy()
        self.chams[player] = nil
    end
end

function ESP:buildGui()
    local gui = Instance.new("ScreenGui")
    gui.Name = "SLR_ESP"
    gui.ResetOnSpawn = false
    gui.IgnoreGuiInset = true
    gui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling

    local parent = (gethui and gethui()) or LocalPlayer:WaitForChild("PlayerGui")
    local ok = pcall(function()
        gui.Parent = parent
    end)
    if not ok then
        gui.Parent = LocalPlayer:WaitForChild("PlayerGui")
    end
    self.gui = gui
    return gui
end

function ESP:load()
    self:buildGui()

    track(Players.PlayerAdded:Connect(function(player)
        self:addPlayer(player)
    end))
    track(Players.PlayerRemoving:Connect(function(player)
        self:removePlayer(player)
    end))

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

    track(RunService:BindToRenderStep("slr_esp", Enum.RenderPriority.Camera.Value + 1, function()
        self.frames = self.frames + 1
        local ok, err = pcall(self.render, self)
        self.lastError = (not ok) and tostring(err) or nil
    end))
end

function ESP:render()
    local options = self.options
    local cam = camera()
    local camPosition = cam.CFrame.Position
    local viewport = cam.ViewportSize
    local screenCenter = Vector2.new(viewport.X * 0.5, viewport.Y * 0.5)
    local fovScale = math.tan(math.rad(cam.FieldOfView * 0.5)) * 2

    if not options.enabled then
        for _, objects in pairs(self.cache) do
            hideObjects(objects)
        end
        for _, highlight in pairs(self.chams) do
            highlight.Enabled = false
        end
        return
    end

    for player, objects in pairs(self.cache) do
        local character = player.Character
        local root = character and character:FindFirstChild("HumanoidRootPart")
        local humanoid = character and character:FindFirstChildOfClass("Humanoid")

        if not character or not root or not humanoid or humanoid.Health <= 0 then
            hideObjects(objects)
        else
            local center, worldSize = self:getBounds(character, root)
            local screenPosition, onScreen, depth = worldToViewport(center)

            if depth <= 0 then
                hideObjects(objects)
            else
                local distance = (camPosition - root.Position).Magnitude
                local scale = 1 / (depth * fovScale) * 1000
                local width = math.clamp(worldSize.X, options.minScaleFactorX, options.maxScaleFactorX) * scale
                local height = math.clamp(worldSize.Y, options.minScaleFactorY, options.maxScaleFactorY) * scale
                local size = Vector2.new(math.floor(width + 0.5), math.floor(height + 0.5))
                local position = Vector2.new(
                    math.floor(screenPosition.X - size.X * 0.5 + 0.5),
                    math.floor(screenPosition.Y - size.Y * 0.5 + 0.5)
                )

                local visible = onScreen
                if options.limitDistance and distance > options.maxDistance then
                    visible = false
                end
                if options.visibleOnly and visible then
                    visible = hasLineOfSight(camPosition, center, { character, cam, LocalPlayer.Character })
                end
                if options.teamCheck and player.Team ~= nil and player.Team == LocalPlayer.Team then
                    visible = false
                end

                local color = self:getColor(player)
                local show = visible and size.X > 0 and size.Y > 0
                local health = math.floor(humanoid.Health + 0.5)
                local maxHealth = math.max(humanoid.MaxHealth, 1)
                local healthRatio = math.clamp(humanoid.Health / maxHealth, 0, 1)

                local objectSpace = cam.CFrame:PointToObjectSpace(center) * Vector3.new(1, 0, 1)
                if objectSpace.Magnitude < 0.001 then
                    objectSpace = Vector3.new(0, 0, -1)
                end
                objectSpace = objectSpace.Unit

                local cross = objectSpace:Cross(Vector3.new(0, 1, 1))
                local right = Vector2.new(cross.X, cross.Z)
                if right.Magnitude < 0.001 then
                    right = Vector2.new(1, 0)
                end
                right = right.Unit

                local radius = options.outOfViewArrowsRadius
                local arrowSize = options.outOfViewArrowsSize
                local arrowPosition = screenCenter + Vector2.new(objectSpace.X, objectSpace.Z) * radius
                local arrowDirection = (arrowPosition - screenCenter)
                if arrowDirection.Magnitude < 0.001 then
                    arrowDirection = Vector2.new(0, 1)
                end
                arrowDirection = arrowDirection.Unit

                local pointA = arrowPosition
                local pointB = screenCenter + arrowDirection * (radius - arrowSize) + right * arrowSize
                local pointC = screenCenter + arrowDirection * (radius - arrowSize) - right * arrowSize

                local showArrow = (not onScreen) and options.outOfViewArrows
                objects.arrow.Visible = showArrow
                objects.arrow.Filled = options.outOfViewArrowsFilled
                objects.arrow.Transparency = options.outOfViewArrowsTransparency
                objects.arrow.Color = color or options.outOfViewArrowsColor
                objects.arrow.PointA = pointA
                objects.arrow.PointB = pointB
                objects.arrow.PointC = pointC

                objects.arrowOutline.Visible = showArrow
                objects.arrowOutline.Filled = options.outOfViewArrowsFilled
                objects.arrowOutline.Transparency = math.clamp(options.outOfViewArrowsTransparency + 0.35, 0, 1)
                objects.arrowOutline.Color = Color3.new()
                objects.arrowOutline.PointA = pointA
                objects.arrowOutline.PointB = pointB
                objects.arrowOutline.PointC = pointC

                objects.name.Visible = show and options.names
                if objects.name.Visible then
                    objects.name.Font = options.font
                    objects.name.Size = options.fontSize
                    objects.name.Transparency = options.nameTransparency
                    objects.name.Color = color or options.nameColor
                    objects.name.Text = player.Name
                    objects.name.Position = round(position + Vector2.new(size.X * 0.5, -(objects.name.TextBounds.Y + 2)))
                end

                objects.healthText.Visible = show and options.healthText
                if objects.healthText.Visible then
                    objects.healthText.Font = options.font
                    objects.healthText.Size = options.fontSize
                    objects.healthText.Transparency = options.healthTextTransparency
                    objects.healthText.Color = color or options.healthTextColor
                    if options.healthTextSuffix == "%" then
                        objects.healthText.Text = tostring(math.floor(healthRatio * 100 + 0.5)) .. options.healthTextSuffix
                    else
                        objects.healthText.Text = tostring(health) .. options.healthTextSuffix
                    end
                    objects.healthText.Position = round(position + Vector2.new(size.X + 3, -3))
                end

                local toolName = self:getToolName(player)
                local hasTool = options.tool and toolName ~= "None"
                objects.tool.Visible = show and hasTool
                if objects.tool.Visible then
                    objects.tool.Font = options.font
                    objects.tool.Size = options.fontSize
                    objects.tool.Transparency = options.toolTransparency
                    objects.tool.Color = color or options.toolColor
                    objects.tool.Text = toolName
                    objects.tool.Position = round(position + Vector2.new(size.X * 0.5, size.Y + 1))
                end

                objects.distanceText.Visible = show and options.distance
                if objects.distanceText.Visible then
                    objects.distanceText.Font = options.font
                    objects.distanceText.Size = options.fontSize
                    objects.distanceText.Transparency = options.distanceTransparency
                    objects.distanceText.Color = color or options.distanceColor
                    objects.distanceText.Text = string.format("%.1f", studsToMeters(distance)) .. options.distanceSuffix

                    local offsetY = size.Y + 4
                    if objects.tool.Visible then
                        local toolHeight = objects.tool.TextBounds.Y
                        if toolHeight <= 0 then
                            toolHeight = options.fontSize + 2
                        end
                        offsetY = size.Y + 1 + toolHeight + 4
                    end
                    objects.distanceText.Position = round(position + Vector2.new(size.X * 0.5, offsetY))
                end

                objects.box.Visible = show and options.boxes
                objects.box.Color = color or options.boxesColor
                objects.box.Transparency = options.boxesTransparency
                objects.box.Size = size
                objects.box.Position = position

                objects.boxOutline.Visible = show and options.boxes
                objects.boxOutline.Transparency = options.boxesTransparency * 0.5
                objects.boxOutline.Size = size + Vector2.new(2, 2)
                objects.boxOutline.Position = position - Vector2.new(1, 1)

                objects.boxFill.Visible = show and options.boxFill
                objects.boxFill.Color = color or options.boxFillColor
                objects.boxFill.Transparency = options.boxFillTransparency
                objects.boxFill.Size = size
                objects.boxFill.Position = position

                local barWidth = options.healthBarsSize
                local barHeight = math.max(size.Y * healthRatio, 0)
                local barPosition = Vector2.new(position.X - barWidth - 3, position.Y + size.Y - barHeight)

                objects.healthBar.Visible = show and options.healthBars
                objects.healthBar.Color = options.healthBarsColor
                objects.healthBar.Transparency = options.healthBarsTransparency
                objects.healthBar.Size = Vector2.new(barWidth, barHeight)
                objects.healthBar.Position = round(barPosition)

                objects.healthBarOutline.Visible = show and options.healthBars
                objects.healthBarOutline.Transparency = options.healthBarsTransparency
                objects.healthBarOutline.Size = Vector2.new(barWidth + 2, size.Y + 2)
                objects.healthBarOutline.Position = round(Vector2.new(position.X - barWidth - 4, position.Y - 1))

                local tracerOrigin
                if options.tracerOrigin == "Mouse" then
                    tracerOrigin = UserInputService:GetMouseLocation()
                elseif options.tracerOrigin == "Top" then
                    tracerOrigin = Vector2.new(viewport.X * 0.5, 0)
                else
                    tracerOrigin = Vector2.new(viewport.X * 0.5, viewport.Y)
                end

                objects.tracer.Visible = show and options.tracers
                objects.tracer.Color = color or options.tracerColor
                objects.tracer.Transparency = options.tracerTransparency
                objects.tracer.From = tracerOrigin
                objects.tracer.To = screenPosition

                objects.tracerOutline.Visible = show and options.tracers
                objects.tracerOutline.Color = Color3.new()
                objects.tracerOutline.Transparency = math.clamp(options.tracerTransparency + 0.35, 0, 1)
                objects.tracerOutline.From = tracerOrigin
                objects.tracerOutline.To = screenPosition
            end
        end

        local highlight = self.chams[player]
        if highlight then
            local character = player.Character
            local root = character and character:FindFirstChild("HumanoidRootPart")
            local humanoid = character and character:FindFirstChildOfClass("Humanoid")
            local distance = root and (camPosition - root.Position).Magnitude or math.huge
            local color = self:getColor(player)

            local show = character ~= nil
                and root ~= nil
                and humanoid ~= nil
                and humanoid.Health > 0
                and options.chams

            if show and options.limitDistance and distance > options.maxDistance then
                show = false
            end
            if show and options.teamCheck and player.Team ~= nil and player.Team == LocalPlayer.Team then
                show = false
            end

            highlight.Enabled = show
            highlight.Adornee = show and character or nil
            highlight.DepthMode = options.visibleOnly and Enum.HighlightDepthMode.Occluded or Enum.HighlightDepthMode.AlwaysOnTop
            highlight.FillColor = color or options.chamsFillColor
            highlight.FillTransparency = options.chamsFillTransparency
            highlight.OutlineColor = color or options.chamsOutlineColor
            highlight.OutlineTransparency = options.chamsOutlineTransparency
        end
    end
end

--============= aim =============--
local Aim = {
    enabled = false,
    held = false,
    useFov = false,
    fovRadius = 150,
    smoothness = 1,
    hitPart = "Head",
    visibleCheck = false,
    healthCheck = false,
    minHealth = 5,
    distanceCheck = false,
    maxDistance = 500,
    friendCheck = false,
    autoFire = false,
    autoFireDelay = 0.1,
    target = nil,
    nextShot = 0,
    friends = {},
    frames = 0,
    lastError = nil,
}

local FieldOfView = {
    draw = false,
    radius = 150,
    color = Color3.new(1, 1, 1),
    transparency = 0.35,
    filled = false,
    fillColor = Color3.new(1, 1, 1),
    filledTransparency = 0.8,
    snapline = false,
    snaplineColor = Color3.new(1, 1, 1),
    highlight = false,
}

local aimSnapline, aimHighlight

local FovGui = { frame = nil, fill = nil, stroke = nil }

local function ensureFovGui()
    if FovGui.frame then
        return
    end

    local gui = Instance.new("ScreenGui")
    gui.Name = "SLR_FOV"
    gui.ResetOnSpawn = false
    gui.IgnoreGuiInset = true
    gui.DisplayOrder = 2

    local parent = (gethui and gethui()) or LocalPlayer:WaitForChild("PlayerGui")
    local ok = pcall(function()
        gui.Parent = parent
    end)
    if not ok then
        gui.Parent = LocalPlayer:WaitForChild("PlayerGui")
    end

    local frame = Instance.new("Frame")
    frame.Name = "FOV"
    frame.AnchorPoint = Vector2.new(0.5, 0.5)
    frame.Position = UDim2.fromScale(0.5, 0.5)
    frame.Size = UDim2.fromOffset(FieldOfView.radius * 2, FieldOfView.radius * 2)
    frame.BackgroundTransparency = 1
    frame.BorderSizePixel = 0
    frame.Visible = false
    frame.ZIndex = 2
    frame.Parent = gui

    local corner = Instance.new("UICorner")
    corner.CornerRadius = UDim.new(1, 0)
    corner.Parent = frame

    local fill = Instance.new("Frame")
    fill.Name = "Fill"
    fill.Size = UDim2.fromScale(1, 1)
    fill.BackgroundColor3 = FieldOfView.fillColor
    fill.BackgroundTransparency = FieldOfView.filledTransparency
    fill.BorderSizePixel = 0
    fill.Visible = false
    fill.ZIndex = 1
    fill.Parent = frame

    local fillCorner = Instance.new("UICorner")
    fillCorner.CornerRadius = UDim.new(1, 0)
    fillCorner.Parent = fill

    local stroke = Instance.new("UIStroke")
    stroke.Thickness = 2
    stroke.Color = FieldOfView.color
    stroke.Transparency = FieldOfView.transparency
    stroke.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
    stroke.Parent = frame

    FovGui.frame = frame
    FovGui.fill = fill
    FovGui.stroke = stroke
end

local function applyFovGuiStyle()
    ensureFovGui()
    if not FovGui.frame then
        return
    end

    FovGui.frame.Size = UDim2.fromOffset(FieldOfView.radius * 2, FieldOfView.radius * 2)
    FovGui.frame.Visible = FieldOfView.draw

    FovGui.stroke.Color = FieldOfView.color
    FovGui.stroke.Transparency = FieldOfView.transparency

    FovGui.fill.BackgroundColor3 = FieldOfView.fillColor
    FovGui.fill.BackgroundTransparency = FieldOfView.filledTransparency
    FovGui.fill.Visible = FieldOfView.filled
end

local function refreshFriend(player)
    if player == LocalPlayer then
        return
    end
    task.spawn(function()
        local ok, isFriend = pcall(function()
            return LocalPlayer:IsFriendsWith(player.UserId)
        end)
        Aim.friends[player.Name] = (ok and isFriend) or nil
    end)
end

for _, player in ipairs(Players:GetPlayers()) do
    refreshFriend(player)
end
track(Players.PlayerAdded:Connect(refreshFriend))
track(Players.PlayerRemoving:Connect(function(player)
    Aim.friends[player.Name] = nil
end))

function Aim:getPart(player)
    local character = player.Character
    if not character then
        return nil
    end
    local part = character:FindFirstChild(self.hitPart)
    if not part and self.hitPart ~= "Head" then
        part = character:FindFirstChild("Head")
    end
    if part and part:IsA("BasePart") then
        return part
    end
    return nil
end

function Aim:isCandidate(player)
    if player == LocalPlayer then
        return false
    end
    local character = player.Character
    local humanoid = character and character:FindFirstChildOfClass("Humanoid")
    local part = self:getPart(player)
    if not character or not humanoid or humanoid.Health <= 0 or not part then
        return false
    end
    if self.friendCheck and self.friends[player.Name] then
        return false
    end
    if self.healthCheck then
        local percent = (humanoid.Health / math.max(humanoid.MaxHealth, 1)) * 100
        if percent < self.minHealth then
            return false
        end
    end
    if self.distanceCheck then
        local root = getRoot(LocalPlayer)
        local targetRoot = character:FindFirstChild("HumanoidRootPart")
        if not root or not targetRoot then
            return false
        end
        if (root.Position - targetRoot.Position).Magnitude > self.maxDistance then
            return false
        end
    end
    if self.visibleCheck then
        local cam = camera()
        if not hasLineOfSight(cam.CFrame.Position, part.Position, { character, cam, LocalPlayer.Character }) then
            return false
        end
    end
    return true
end

function Aim:pick()
    local cam = camera()
    if not cam then
        return nil
    end
    local center = aimPoint()
    local radius = self.useFov and self.fovRadius or math.huge
    local best, bestDistance = nil, math.huge

    for _, player in ipairs(Players:GetPlayers()) do
        if self:isCandidate(player) then
            local part = self:getPart(player)
            local screen, onScreen = cam:WorldToViewportPoint(part.Position)
            if onScreen then
                local distance = (Vector2.new(screen.X, screen.Y) - center).Magnitude
                if distance <= radius and distance < bestDistance then
                    best, bestDistance = player, distance
                end
            end
        end
    end

    self.target = best
    return best
end

function Aim:lock(dt)
    local target = self.target
    if not target then
        return
    end
    local part = self:getPart(target)
    if not part then
        return
    end
    local cam = camera()
    if not cam then
        return
    end

    local screen, onScreen = cam:WorldToViewportPoint(part.Position)
    if not onScreen then
        return
    end

    local cursor = aimPoint()
    local delta = Vector2.new(screen.X, screen.Y) - cursor
    if delta.Magnitude <= 1 then
        return
    end

    local factor = math.clamp(1 / math.max(self.smoothness, 1) * math.min(dt * 60, 1), 0.02, 1)
    local step = delta * factor
    local mouseMove = rawget(getfenv(), "mousemoverel") or (getgenv and getgenv().mousemoverel)
    local mobile = UserInputService.TouchEnabled and not UserInputService.KeyboardEnabled

    if type(mouseMove) == "function" and not mobile then
        pcall(mouseMove, step.X, step.Y)
    else
        local desired = CFrame.lookAt(cam.CFrame.Position, part.Position)
        cam.CFrame = cam.CFrame:Lerp(desired, factor)
    end
end

function Aim:tryFire()
    if not self.autoFire then
        return
    end
    local now = os.clock()
    if now < self.nextShot then
        return
    end
    self.nextShot = now + math.max(self.autoFireDelay, 0.02)

    local character = LocalPlayer.Character
    local tool = character and character:FindFirstChildOfClass("Tool")
    if tool then
        pcall(function()
            tool:Activate()
        end)
    end
end

local function applyFovStyle()
    applyFovGuiStyle()
    if aimSnapline then
        aimSnapline.Color = FieldOfView.snaplineColor
    end
    if aimHighlight then
        aimHighlight.FillColor = FieldOfView.color
    end
end

local function buildAimDrawings()
    if hasDrawing() then
        aimSnapline = createDrawing("Line", { Thickness = 2, Color = FieldOfView.snaplineColor, Visible = false })
    end

    local ok, highlight = pcall(Instance.new, "Highlight")
    if ok and highlight then
        highlight.Name = "SLR_AimTarget"
        highlight.FillColor = FieldOfView.color
        highlight.FillTransparency = 0.7
        highlight.OutlineColor = Color3.new(1, 1, 1)
        highlight.OutlineTransparency = 0.2
        highlight.Enabled = false
        pcall(function()
            highlight.Parent = (gethui and gethui()) or LocalPlayer:WaitForChild("PlayerGui")
        end)
        aimHighlight = highlight
    end

    applyFovStyle()
end

buildAimDrawings()
applyFovStyle()

local function renderAimlock(dt)
    local cam = camera()
    if not cam then
        return
    end
    local center = aimPoint()

    if not Aim.enabled then
        Aim.target = nil
        if aimSnapline then
            aimSnapline.Visible = false
        end
        if aimHighlight then
            aimHighlight.Enabled = false
            aimHighlight.Adornee = nil
        end
        return
    end

    Aim:pick()

    local part = Aim.target and Aim:getPart(Aim.target)
    if not part then
        if aimSnapline then
            aimSnapline.Visible = false
        end
        if aimHighlight then
            aimHighlight.Enabled = false
        end
        return
    end

    local screen, onScreen = cam:WorldToViewportPoint(part.Position)

    if aimSnapline then
        local visible = FieldOfView.snapline and onScreen
        aimSnapline.Visible = visible
        if visible then
            local point = Vector2.new(screen.X, screen.Y)
            aimSnapline.From = center
            aimSnapline.To = point
        end
    end

    if aimHighlight then
        aimHighlight.Enabled = FieldOfView.highlight
        aimHighlight.Adornee = FieldOfView.highlight and Aim.target.Character or nil
    end

    if Aim.held then
        Aim:lock(dt)
        Aim:tryFire()
    end
end

track(RunService:BindToRenderStep("slr_aimlock", Enum.RenderPriority.Camera.Value + 1, function(dt)
    Aim.frames = Aim.frames + 1
    local ok, err = pcall(renderAimlock, dt)
    Aim.lastError = (not ok) and tostring(err) or nil

    if FovGui.frame and FieldOfView.draw then
        local point = aimPoint()
        FovGui.frame.Position = UDim2.fromOffset(point.X, point.Y)
    end
end))

--============= teleport =============--
-- ZalStore method: freeze the humanoid state set, zero gravity, sit and pivot
-- the character for 90 frames behind an opaque cover screen, then hand control
-- back. The cover screen enforces its own integrity while it is up.
local AntiTamper = { atr = false }

local Teleport = {
    swimDelay = 0.45,
    settleDelay = 0.12,
    teleporting = false,
    busy = false,
    AntiTamper = AntiTamper,
}

local function charParts()
    local character = LocalPlayer.Character
    if not character or not character.Parent then
        return nil
    end
    local humanoid = character:FindFirstChildOfClass("Humanoid")
    if not humanoid or humanoid.Health <= 0 then
        return nil
    end
    local root = character:FindFirstChild("HumanoidRootPart")
    if not root then
        return nil
    end
    return character, humanoid, root
end

local COVER_NAME = "SLR | Teleport Cover"

local function createCover(message)
    local gui = Instance.new("ScreenGui")
    gui.Name = COVER_NAME
    gui.ResetOnSpawn = false
    gui.IgnoreGuiInset = true
    gui.DisplayOrder = 15
    gui.ZIndexBehavior = Enum.ZIndexBehavior.Global

    local parent = (gethui and gethui()) or LocalPlayer:WaitForChild("PlayerGui")
    local ok = pcall(function()
        gui.Parent = parent
    end)
    if not ok then
        gui.Parent = LocalPlayer:WaitForChild("PlayerGui")
    end

    local frame = Instance.new("Frame")
    frame.Name = "Frame"
    frame.Size = UDim2.fromScale(2, 2)
    frame.Position = UDim2.new(0, 0, 0, 0)
    frame.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
    frame.BackgroundTransparency = 0
    frame.ZIndex = 0
    frame.Parent = gui

    local label = Instance.new("TextLabel")
    label.Name = "TextLabel"
    label.Size = UDim2.fromScale(0.2, 0.1)
    label.AnchorPoint = Vector2.new(0.5, 0.5)
    label.Position = UDim2.fromScale(0.5, 0.5)
    label.BackgroundTransparency = 1
    label.Font = Enum.Font.SourceSansBold
    label.RichText = true
    label.TextColor3 = Color3.fromRGB(255, 255, 255)
    label.TextSize = 30
    label.Text = "Street Life\n" .. tostring(message)
    label.TextXAlignment = Enum.TextXAlignment.Center
    label.ZIndex = 1
    label.Parent = gui

    task.spawn(function()
        while gui and gui.Parent do
            if AntiTamper.atr then
                pcall(function()
                    gui:Destroy()
                end)
                return
            end
            if gui.Enabled ~= true
                or frame.Visible ~= true
                or label.Visible ~= true
                or frame.BackgroundTransparency ~= 0
                or gui.Name ~= COVER_NAME then
                pcall(function()
                    LocalPlayer:Kick("Teleport cover tampered")
                end)
                return
            end
            task.wait()
        end
    end)

    return gui
end

function Teleport:instant(position)
    if self.teleporting then
        return false, "Another teleport is in progress!"
    end

    local character, humanoid = charParts()
    if not character then
        return false, "Character not found!"
    end
    if tostring(humanoid.SeatPart) == "DriveSeat" then
        return false, "You're driving a vehicle, aborting teleport!"
    end

    if humanoid.Sit then
        humanoid.Sit = false
        task.wait(0.1)
    end
    repeat
        task.wait()
    until not AntiTamper.atr

    self.teleporting = true
    local cover = createCover("teleporting , please wait!")

    local gravity = Workspace.Gravity
    local states = Enum.HumanoidStateType:GetEnumItems()
    table.remove(states, table.find(states, Enum.HumanoidStateType.None))

    humanoid.Sit = true
    Workspace.Gravity = 0
    task.wait(0.25)

    pcall(function()
        humanoid:ChangeState(Enum.HumanoidStateType.Swimming)
    end)
    for _, state in ipairs(states) do
        pcall(function()
            humanoid:SetStateEnabled(state, false)
        end)
    end

    for _ = 1, 90 do
        humanoid.Sit = false
        pcall(function()
            humanoid:ChangeState(Enum.HumanoidStateType.Swimming)
        end)
        character:PivotTo(CFrame.new(position))
        task.wait()
    end

    Workspace.Gravity = gravity
    for _, state in ipairs(states) do
        pcall(function()
            humanoid:SetStateEnabled(state, true)
        end)
    end
    pcall(function()
        humanoid:ChangeState(Enum.HumanoidStateType.GettingUp)
    end)
    pcall(function()
        humanoid:ChangeState(Enum.HumanoidStateType.Running)
    end)

    self.teleporting = false
    task.spawn(function()
        AntiTamper.atr = true
        task.wait(0.1)
        AntiTamper.atr = false
    end)

    if cover then
        cover:Destroy()
    end
    return true
end

function Teleport:vehicle(position)
    local character, humanoid = charParts()
    if not character then
        return false, "Character not found!"
    end
    local seat = humanoid.SeatPart
    if tostring(seat) == "DriveSeat" and seat.Parent then
        pcall(function()
            LocalPlayer:RequestStreamAroundAsync(position)
        end)
        seat.Parent:PivotTo(CFrame.new(position))
        return true
    end
    return false, "You are not the driver of a vehicle, aborting teleport!"
end

function Teleport:handler(position)
    if typeof(position) ~= "Vector3" then
        return false
    end
    local ok, message = self:instant(position)
    if not ok then
        notify("Instant teleport: " .. tostring(message))
        local vehicleOk, vehicleMessage = self:vehicle(position)
        if not vehicleOk then
            notify("Vehicle teleport: " .. tostring(vehicleMessage))
            return false
        end
    end
    return true
end

function Teleport:to(position)
    return self:handler(position)
end

-- quick method: single pivot under the Swimming state, no cover screen.
function Teleport:quick(position)
    if typeof(position) ~= "Vector3" or self.teleporting then
        return false
    end
    local character, humanoid, root = charParts()
    if not character then
        return false
    end
    if self.busy then
        return false
    end
    self.busy = true

    local previous = humanoid:GetState()
    pcall(function()
        humanoid:ChangeState(Enum.HumanoidStateType.Swimming)
    end)
    task.wait(self.swimDelay)

    if root.Parent then
        root.CFrame = CFrame.new(position)
        pcall(function()
            root.AssemblyLinearVelocity = Vector3.zero
            root.AssemblyAngularVelocity = Vector3.zero
            root.Velocity = Vector3.zero
        end)
    end

    task.wait(0.05)
    local restore = previous
    if restore == Enum.HumanoidStateType.Swimming or restore == Enum.HumanoidStateType.None then
        restore = Enum.HumanoidStateType.GettingUp
    end
    pcall(function()
        humanoid:ChangeState(restore)
    end)
    task.wait(self.settleDelay)
    self.busy = false
    return true
end

function Teleport:toCharacter(player)
    local root = getRoot(player)
    if not root then
        return false
    end
    return self:handler(root.Position + Vector3.new(0, 1, 0))
end

local locations = {
    ["Main Gun Store"] = Vector3.new(649, 52, -396),
    ["Second Gun Store"] = Vector3.new(26, 72, 602),
    ["Cleaning Job"] = Vector3.new(281, 52, -185),
    ["Loot Buyer"] = Vector3.new(269, 52, 303),
    ["Spawn"] = Vector3.new(557, 52, -75),
    ["Bank"] = Vector3.new(444, -49, 107),
}

local locationNames = {}
for name in pairs(locations) do
    table.insert(locationNames, name)
end
table.sort(locationNames)

--============= graphics =============--
local Graphics = {
    base = {
        Brightness = Lighting.Brightness,
        Ambient = Lighting.Ambient,
        OutdoorAmbient = Lighting.OutdoorAmbient,
        GlobalShadows = Lighting.GlobalShadows,
        FogEnd = Lighting.FogEnd,
        FogStart = Lighting.FogStart,
        FogColor = Lighting.FogColor,
        ClockTime = Lighting.ClockTime,
        ColorShiftTop = Lighting.ColorShift_Top,
        Fov = camera().FieldOfView,
        PostEffects = {},
    },
    vibrant = nil,
    savedSky = nil,
    day = false,
    night = false,
    fovEnabled = false,
    fovValue = 70,
}

for _, effect in ipairs(Lighting:GetChildren()) do
    if effect:IsA("PostEffect") then
        Graphics.base.PostEffects[effect] = effect.Enabled
    end
end

function Graphics.restore()
    Lighting.Brightness = Graphics.base.Brightness
    Lighting.Ambient = Graphics.base.Ambient
    Lighting.OutdoorAmbient = Graphics.base.OutdoorAmbient
    Lighting.GlobalShadows = Graphics.base.GlobalShadows
    Lighting.FogEnd = Graphics.base.FogEnd
    Lighting.FogStart = Graphics.base.FogStart
    Lighting.FogColor = Graphics.base.FogColor
    Lighting.ClockTime = Graphics.base.ClockTime
    Lighting.ColorShift_Top = Graphics.base.ColorShiftTop

    for effect, enabled in pairs(Graphics.base.PostEffects) do
        if effect and effect.Parent then
            effect.Enabled = enabled
        end
    end

    if Graphics.vibrant then
        Graphics.vibrant:Destroy()
        Graphics.vibrant = nil
    end

    local cam = camera()
    if cam then
        cam.FieldOfView = Graphics.base.Fov
    end
end

function Graphics.restoreLighting()
    Graphics.restore()
end

function Graphics.fpsBoost()
    for _, effect in ipairs(Lighting:GetChildren()) do
        if effect:IsA("PostEffect") then
            if Graphics.base.PostEffects[effect] == nil then
                Graphics.base.PostEffects[effect] = effect.Enabled
            end
            effect.Enabled = false
        end
    end
    Lighting.Brightness = math.max(Graphics.base.Brightness, 1.5)
    Lighting.Ambient = Color3.fromRGB(110, 110, 110)
    Lighting.GlobalShadows = false
end

function Graphics.vibrantLook()
    if Graphics.vibrant and Graphics.vibrant.Parent then
        Graphics.vibrant:Destroy()
    end
    local effect = Instance.new("ColorCorrectionEffect")
    effect.Name = "SLR_Vibrant"
    effect.Saturation = 0.8
    effect.Parent = Lighting
    Graphics.vibrant = effect
end

function Graphics.applyPreset(name)
    if name == "Default" then
        Lighting.FogEnd = 100000
        Lighting.FogStart = 0
        Lighting.FogColor = Color3.fromRGB(192, 192, 192)
        Lighting.Ambient = Color3.fromRGB(70, 70, 70)
        Lighting.OutdoorAmbient = Color3.fromRGB(70, 70, 70)
    elseif name == "Sunset" then
        Lighting.Ambient = Color3.fromRGB(180, 100, 50)
        Lighting.OutdoorAmbient = Color3.fromRGB(200, 120, 60)
        Lighting.ColorShift_Top = Color3.fromRGB(255, 100, 0)
        Lighting.FogEnd = 800
        Lighting.FogColor = Color3.fromRGB(255, 150, 80)
    elseif name == "Foggy" then
        Lighting.FogEnd = 150
        Lighting.FogStart = 10
        Lighting.FogColor = Color3.fromRGB(200, 200, 200)
    elseif name == "Dawn" then
        Lighting.Ambient = Color3.fromRGB(140, 100, 160)
        Lighting.ColorShift_Top = Color3.fromRGB(120, 80, 180)
        Lighting.FogEnd = 600
        Lighting.FogColor = Color3.fromRGB(180, 140, 220)
    elseif name == "Blood Moon" then
        Lighting.Ambient = Color3.fromRGB(120, 0, 0)
        Lighting.ColorShift_Top = Color3.fromRGB(200, 0, 0)
        Lighting.FogEnd = 300
        Lighting.FogColor = Color3.fromRGB(180, 0, 0)
    end
end

local skyboxes = {
    ["Grim Reaper"] = { Ft = "110040638294238", Bk = "107320750438979", Lf = "98208996898314", Rt = "103873843069373", Up = "127128054567141", Dn = "100323483928326" },
    ["Real"] = { Bk = "144933338", Dn = "144931530", Ft = "144933262", Lf = "144933244", Rt = "144933299", Up = "144931564" },
    ["Island"] = { Bk = "14753804949", Dn = "14753795573", Ft = "14753807625", Lf = "14753797417", Rt = "14753799966", Up = "14753810287" },
    ["Purple Sky"] = { Bk = "16553658937", Dn = "16553660713", Ft = "16553662144", Lf = "16553664042", Rt = "16553665766", Up = "16553667750" },
    ["Purple Galaxy"] = { Bk = "15983968922", Dn = "15983966825", Ft = "15983965025", Lf = "15983967420", Rt = "15983966246", Up = "15983964246" },
    ["Pink"] = { Bk = "12635309703", Dn = "12635311686", Ft = "12635312870", Lf = "12635313718", Rt = "12635315817", Up = "12635316856" },
    ["Aurora"] = { Bk = "1189339378", Dn = "1189340601", Ft = "1189339741", Lf = "1189339550", Rt = "1189339155", Up = "1189340203" },
    ["Among Us"] = { Bk = "5752463190", Dn = "5752463190", Ft = "5752463190", Lf = "5752463190", Rt = "5752463190", Up = "5752463190" },
    ["Spongebob"] = { Bk = "277099484", Dn = "277099500", Ft = "277099554", Lf = "277099531", Rt = "277099589", Up = "277101591" },
    ["Deep Space"] = { Bk = "159248188", Dn = "159248183", Ft = "159248187", Lf = "159248173", Rt = "159248192", Up = "159248176" },
    ["Winter"] = { Bk = "510645155", Dn = "510645130", Ft = "510645179", Lf = "510645117", Rt = "510645146", Up = "510645195" },
    ["Clouded Sky"] = { Bk = "252760981", Dn = "252763035", Ft = "252761439", Lf = "252760980", Rt = "252760986", Up = "252762652" },
}

function Graphics.applySkybox(name)
    local sky = Lighting:FindFirstChild("SLR_Sky")
    if name == "Default" then
        if sky then
            sky:Destroy()
        end
        if Graphics.savedSky then
            Graphics.savedSky.Parent = Lighting
            Graphics.savedSky = nil
        end
        return
    end
    local set = skyboxes[name]
    if not set then
        return
    end
    if not sky then
        if Graphics.savedSky == nil then
            local existing = Lighting:FindFirstChildOfClass("Sky")
            if existing then
                Graphics.savedSky = existing
                existing.Parent = nil
            end
        end
        sky = Instance.new("Sky")
        sky.Name = "SLR_Sky"
        sky.Parent = Lighting
    end
    sky.SkyboxBk = set.Bk and ("rbxassetid://" .. set.Bk) or ""
    sky.SkyboxDn = set.Dn and ("rbxassetid://" .. set.Dn) or ""
    sky.SkyboxFt = set.Ft and ("rbxassetid://" .. set.Ft) or ""
    sky.SkyboxLf = set.Lf and ("rbxassetid://" .. set.Lf) or ""
    sky.SkyboxRt = set.Rt and ("rbxassetid://" .. set.Rt) or ""
    sky.SkyboxUp = set.Up and ("rbxassetid://" .. set.Up) or ""
end

track(RunService.RenderStepped:Connect(function()
    if Graphics.day then
        Lighting.ClockTime = 14
    elseif Graphics.night then
        Lighting.ClockTime = 0
    end

    if Graphics.fovEnabled then
        local cam = camera()
        if cam and cam.FieldOfView ~= Graphics.fovValue then
            cam.FieldOfView = Graphics.fovValue
        end
    end
end))

--============= gun mods =============--
-- live layout (client controller table from getgc):
--   ctrl.Instance / ctrl.Settings / ctrl.Spring_Recoil / ctrl.DeltaTime / ctrl._SlideTime
-- settings fields consumed by GunClient: Recoil, RecoilSpeed, SprayAngle,
-- SpreadFactor, FireRate, JamChance, IsAutomatic
local GunMods = {
    state = {
        noRecoil = false,
        noSpread = false,
        fireRate = false,
        fireRateMult = 3,
        automatic = false,
        noJam = false,
    },
    originals = setmetatable({}, { __mode = "k" }),
    ctrlOriginals = setmetatable({}, { __mode = "k" }),
    controllers = {},
}

local CAP_FIRE_RATE = 2400
local lastGunScan = 0

local function isOurTool(instance)
    if typeof(instance) ~= "Instance" or not instance:IsA("Tool") then
        return false
    end
    local parent = instance.Parent
    return parent == LocalPlayer:FindFirstChild("Backpack") or parent == LocalPlayer.Character
end

local function scanGuns()
    local found = {}
    if type(getgc) ~= "function" then
        return found
    end
    for _, object in pairs(getgc(true)) do
        if type(object) == "table" then
            local instance = rawget(object, "Instance")
            if instance and rawget(object, "Settings") and isOurTool(instance) then
                local meta = getmetatable(object)
                if type(meta) == "table" and type(rawget(meta, "Fire")) == "function" then
                    found[#found + 1] = object
                end
            end
        end
    end
    GunMods.controllers = found
    return found
end

local function remember(settings, field, value)
    local record = GunMods.originals[settings]
    if not record then
        record = {}
        GunMods.originals[settings] = record
    end
    if record[field] == nil then
        record[field] = value
    end
end

local function setField(settings, field, value)
    local current = settings[field]
    if current == nil then
        return
    end
    remember(settings, field, current)
    settings[field] = value
end

local function killSpring(ctrl)
    local spring = rawget(ctrl, "Spring_Recoil")
    if type(spring) ~= "table" or rawget(spring, "Position") == nil then
        return
    end
    if not rawget(ctrl, "_slrSpringPatched") then
        local had = rawget(spring, "Shove")
        GunMods.ctrlOriginals[ctrl] = { hadShove = had ~= nil, oldShove = had }
        rawset(ctrl, "_slrSpringPatched", true)
    end
    rawset(spring, "Shove", function() end)
    rawset(spring, "Position", Vector3.new())
    rawset(spring, "Velocity", Vector3.new())
    rawset(spring, "Target", Vector3.new())
end

local function applyGun(ctrl)
    local settings = rawget(ctrl, "Settings")
    local instance = rawget(ctrl, "Instance")
    if type(settings) ~= "table" or typeof(instance) ~= "Instance" then
        return
    end
    local state = GunMods.state

    if state.noRecoil then
        killSpring(ctrl)
        setField(settings, "Recoil", 0)
        setField(settings, "RecoilSpeed", 0)
    end

    if state.noSpread then
        setField(settings, "SprayAngle", 0)
        setField(settings, "SpreadFactor", 0)
    end

    if state.fireRate then
        local base = GunMods.originals[settings] and GunMods.originals[settings].FireRate
        if base == nil then
            base = settings.FireRate
        end
        if type(base) == "number" then
            remember(settings, "FireRate", base)
            local rate = math.min(base * state.fireRateMult, CAP_FIRE_RATE)
            settings.FireRate = rate
            rawset(ctrl, "DeltaTime", 60 / rate)
        end
    end

    if state.automatic then
        setField(settings, "IsAutomatic", true)
    end

    if state.noJam then
        setField(settings, "JamChance", 0)
        if instance:GetAttribute("IsJammed") then
            instance:SetAttribute("IsJammed", false)
        end
        if rawget(ctrl, "_SlideTime") and ctrl._SlideTime > 0 then
            ctrl._SlideTime = -1e9
        end
    end
end

local function restoreGuns()
    for settings, record in pairs(GunMods.originals) do
        for field, value in pairs(record) do
            if settings[field] ~= nil then
                settings[field] = value
            end
        end
    end
    for ctrl, record in pairs(GunMods.ctrlOriginals) do
        local spring = rawget(ctrl, "Spring_Recoil")
        if spring then
            if record.hadShove then
                rawset(spring, "Shove", record.oldShove)
            else
                rawset(spring, "Shove", nil)
            end
        end
        rawset(ctrl, "_slrSpringPatched", nil)
    end
    for _, ctrl in ipairs(GunMods.controllers) do
        local settings = rawget(ctrl, "Settings")
        if settings and type(settings.FireRate) == "number" then
            rawset(ctrl, "DeltaTime", 60 / settings.FireRate)
        end
    end
end

local function gunTick()
    local any = false
    for _, value in pairs(GunMods.state) do
        if type(value) == "boolean" and value then
            any = true
            break
        end
    end
    if not any then
        return
    end
    if #GunMods.controllers == 0 or os.clock() - lastGunScan > 2 then
        lastGunScan = os.clock()
        scanGuns()
    end
    for _, ctrl in ipairs(GunMods.controllers) do
        pcall(applyGun, ctrl)
    end
end

track(RunService.Heartbeat:Connect(function()
    gunTick()
end))

--============= local player state =============--
local LocalState = {
    instantInteract = false,
    infiniteStamina = false,
    hideName = false,
    nameText = "",
    speedEnabled = false,
    speedValue = 16,
    jumpEnabled = false,
    jumpValue = 50,
    clickTeleport = false,
    clickKey = Enum.KeyCode.LeftAlt,
    clickHeld = false,
    vehicleSpeed = false,
    vehicleSpeedValue = 5,
    vehicleBrake = false,
    vehicleBrakeValue = 5,
    infiniteFuel = false,
}

--============= instant interact =============--
local function applyPrompts(root)
    for _, descendant in ipairs(root:GetDescendants()) do
        if descendant:IsA("ProximityPrompt") then
            descendant.HoldDuration = 0
        end
    end
    if root:IsA("ProximityPrompt") then
        root.HoldDuration = 0
    end
end

local function refreshPrompts()
    if not LocalState.instantInteract then
        return
    end
    applyPrompts(Workspace)
end

track(Workspace.DescendantAdded:Connect(function(descendant)
    if LocalState.instantInteract and descendant:IsA("ProximityPrompt") then
        descendant.HoldDuration = 0
    end
end))

track(ProximityPromptService.PromptButtonHoldBegan:Connect(function(prompt, player)
    if LocalState.instantInteract and player == LocalPlayer and prompt.HoldDuration ~= 0 then
        pcall(function()
            fireproximityprompt(prompt)
        end)
    end
end))

--============= infinite stamina =============--
local Stamina = {
    bound = 0,
    slots = {},
}

local function hudNode()
    local gui = LocalPlayer:FindFirstChild("PlayerGui")
    local gameGui = gui and gui:FindFirstChild("GameGui")
    return gameGui and gameGui:FindFirstChild("MainHUD") or nil
end

local function valuesNode()
    local main = hudNode()
    return main and main:FindFirstChild("Values") or nil
end

local function currStamina()
    local values = valuesNode()
    local node = values and values:FindFirstChild("CurrStamina")
    if node and node:IsA("ValueBase") then
        return node
    end
    return nil
end

local function findStaminaClosures(main, values)
    local out = {}
    if type(getgc) ~= "function" then
        return out
    end
    local budget = os.clock() + 8
    for _, object in pairs(getgc()) do
        if type(object) == "function" then
            local holds, matches = false, {}
            local index = 1
            while index <= 16 do
                local ok, value = pcall(debug.getupvalue, object, index)
                if not ok then
                    break
                end
                if value == values or value == main then
                    holds = true
                end
                if type(value) == "number" and index <= 6
                    and value == math.floor(value) and value >= 0 and value <= 100 then
                    matches[#matches + 1] = index
                end
                index = index + 1
            end
            if holds and #matches > 0 then
                out[#out + 1] = { fn = object, slots = matches }
            end
            if os.clock() > budget then
                break
            end
        end
    end
    return out
end

local function bindStamina(force)
    local curr = currStamina()
    local values = valuesNode()
    local main = hudNode()
    if not (curr and values and main) then
        return false
    end
    if Stamina.bound > 0 and not force then
        return true
    end

    Stamina.slots = {}
    Stamina.bound = 0

    for _, entry in ipairs(findStaminaClosures(main, values)) do
        for _, index in ipairs(entry.slots) do
            if pcall(debug.setupvalue, entry.fn, index, 100) then
                Stamina.slots[#Stamina.slots + 1] = { fn = entry.fn, index = index }
            end
        end
    end

    Stamina.bound = #Stamina.slots
    return Stamina.bound > 0
end

local function staminaTick()
    if Stamina.bound == 0 then
        return
    end
    for _, slot in ipairs(Stamina.slots) do
        local ok = pcall(debug.setupvalue, slot.fn, slot.index, 100)
        if not ok then
            Stamina.slots = {}
            Stamina.bound = 0
            return
        end
    end
    local humanoid = getHumanoid()
    if humanoid and humanoid.JumpPower < 50 and humanoid.Health > 0 then
        humanoid.JumpPower = 50
    end
end

task.spawn(function()
    while true do
        task.wait(0.5)
        if LocalState.infiniteStamina and currStamina() and Stamina.bound == 0 then
            pcall(bindStamina)
        end
    end
end)

--============= speed / jump / hide name =============--
--============= speed watch =============--
-- The game rewrites WalkSpeed from its own controller (7.5 on foot), so the
-- override has to be re-applied from a property-changed edge instead of a timer.
local SpeedWatch = { connection = nil, humanoid = nil, native = nil, guard = false }

local function stopSpeedWatch(restore)
    local humanoid = SpeedWatch.humanoid
    local native = SpeedWatch.native
    if SpeedWatch.connection then
        pcall(function()
            SpeedWatch.connection:Disconnect()
        end)
        SpeedWatch.connection = nil
    end
    SpeedWatch.humanoid = nil
    SpeedWatch.native = nil
    SpeedWatch.guard = false
    if restore and humanoid and native then
        pcall(function()
            humanoid.WalkSpeed = native
        end)
    end
end

local function applySpeedValue()
    local humanoid = SpeedWatch.humanoid or getHumanoid()
    if not humanoid then
        return
    end
    SpeedWatch.guard = true
    pcall(function()
        humanoid.WalkSpeed = LocalState.speedValue
    end)
    SpeedWatch.guard = false
end

local function ensureSpeedWatch()
    if not LocalState.speedEnabled then
        return
    end
    local humanoid = getHumanoid()
    if not humanoid then
        return
    end
    if SpeedWatch.humanoid == humanoid and SpeedWatch.connection then
        return
    end

    stopSpeedWatch(false)
    SpeedWatch.humanoid = humanoid
    SpeedWatch.native = humanoid.WalkSpeed

    SpeedWatch.connection = humanoid:GetPropertyChangedSignal("WalkSpeed"):Connect(function()
        if SpeedWatch.guard or not LocalState.speedEnabled then
            return
        end
        local incoming = humanoid.WalkSpeed
        if incoming ~= LocalState.speedValue then
            SpeedWatch.native = incoming
        end
        applySpeedValue()
    end)

    applySpeedValue()
end

--============= local apply =============--
local function applyLocalTick()
    local humanoid = getHumanoid()
    if not humanoid then
        return
    end

    if LocalState.speedEnabled then
        ensureSpeedWatch()
    end

    if LocalState.jumpEnabled then
        humanoid.UseJumpPower = true
        humanoid.JumpPower = LocalState.jumpValue
    end
end

local function applyName()
    local character = LocalPlayer.Character
    local humanoid = character and character:FindFirstChildOfClass("Humanoid")
    local head = character and character:FindFirstChild("Head")
    local overhead = head and head:FindFirstChild("Overhead")
    local label = overhead and overhead:FindFirstChild("Username")

    local text = LocalState.nameText or ""
    if humanoid and text ~= "" then
        pcall(function()
            humanoid.DisplayName = text
        end)
    end
    if label and label:IsA("TextLabel") then
        label.Text = text
    end
end

local function restoreName()
    local character = LocalPlayer.Character
    local humanoid = character and character:FindFirstChildOfClass("Humanoid")
    local head = character and character:FindFirstChild("Head")
    local overhead = head and head:FindFirstChild("Overhead")
    local label = overhead and overhead:FindFirstChild("Username")
    if humanoid then
        humanoid.DisplayName = LocalPlayer.DisplayName
    end
    if label and label:IsA("TextLabel") then
        label.Text = LocalPlayer.DisplayName
    end
end

task.spawn(function()
    while true do
        task.wait(0.4)
        if LocalState.hideName then
            applyName()
        end
    end
end)

--============= fly =============--
local Fly = {
    enabled = false,
    speed = 60,
    bodyVelocity = nil,
    bodyGyro = nil,
    connection = nil,
}

function Fly:stop()
    self.enabled = false
    if self.connection then
        self.connection:Disconnect()
        self.connection = nil
    end
    if self.bodyVelocity then
        self.bodyVelocity:Destroy()
        self.bodyVelocity = nil
    end
    if self.bodyGyro then
        self.bodyGyro:Destroy()
        self.bodyGyro = nil
    end
end

function Fly:start()
    self:stop()
    local character = LocalPlayer.Character
    local root = character and character:FindFirstChild("HumanoidRootPart")
    if not root then
        return
    end

    local velocity = Instance.new("BodyVelocity")
    velocity.MaxForce = Vector3.new(1e9, 1e9, 1e9)
    velocity.Velocity = Vector3.zero
    velocity.Parent = root

    local gyro = Instance.new("BodyGyro")
    gyro.MaxTorque = Vector3.new(1e9, 1e9, 1e9)
    gyro.P = 12000
    gyro.D = 500
    gyro.CFrame = root.CFrame
    gyro.Parent = root

    self.bodyVelocity = velocity
    self.bodyGyro = gyro
    self.enabled = true

    self.connection = RunService.RenderStepped:Connect(function()
        if not self.enabled then
            return
        end
        local characterNow = LocalPlayer.Character
        local rootNow = characterNow and characterNow:FindFirstChild("HumanoidRootPart")
        if not rootNow or not self.bodyVelocity or not self.bodyGyro then
            return
        end

        local cam = camera()
        local look = cam.CFrame.LookVector
        local right = cam.CFrame.RightVector
        local move = Vector3.zero

        if UserInputService.TouchEnabled then
            local humanoid = characterNow:FindFirstChildOfClass("Humanoid")
            move = humanoid and humanoid.MoveDirection or Vector3.zero
        else
            if UserInputService:IsKeyDown(Enum.KeyCode.W) then move = move + look end
            if UserInputService:IsKeyDown(Enum.KeyCode.S) then move = move - look end
            if UserInputService:IsKeyDown(Enum.KeyCode.A) then move = move - right end
            if UserInputService:IsKeyDown(Enum.KeyCode.D) then move = move + right end
            if UserInputService:IsKeyDown(Enum.KeyCode.Space) then move = move + Vector3.new(0, 1, 0) end
            if UserInputService:IsKeyDown(Enum.KeyCode.LeftControl) then move = move - Vector3.new(0, 1, 0) end
        end

        self.bodyVelocity.Velocity = move.Magnitude > 0 and move.Unit * self.speed or Vector3.zero
        self.bodyGyro.CFrame = cam.CFrame
    end)
end

--============= click to teleport =============--
local function teleportToScreenPoint(x, y)
    local cam = camera()
    local ok, ray = pcall(function()
        return cam:ScreenPointToRay(x, y - GuiService:GetGuiInset().Y)
    end)
    if not ok or not ray then
        return
    end
    local params = newRaycastParams({ LocalPlayer.Character })
    local result = Workspace:Raycast(ray.Origin, ray.Direction * 3000, params)
    if result then
        task.spawn(function()
            Teleport:to(result.Position + Vector3.new(0, 3, 0))
        end)
    end
end

local function clickTeleport()
    if not LocalState.clickTeleport or not LocalState.clickHeld then
        return
    end
    local mouse = UserInputService:GetMouseLocation()
    teleportToScreenPoint(mouse.X, mouse.Y)
end

track(LocalPlayer:GetMouse().Button1Down:Connect(clickTeleport))

track(UserInputService.TouchTap:Connect(function(positions, processed)
    if processed or not LocalState.clickTeleport then
        return
    end
    local point = positions and positions[1]
    if point then
        teleportToScreenPoint(point.X, point.Y)
    end
end))

--============= vehicle mods =============--
track(RunService.Heartbeat:Connect(function()
    local character = LocalPlayer.Character
    local humanoid = character and character:FindFirstChildOfClass("Humanoid")
    if not humanoid then
        return
    end
    local seat = humanoid.SeatPart
    if not seat or not seat:IsA("VehicleSeat") then
        return
    end
    local model = seat.Parent
    if not model then
        return
    end

    if LocalState.vehicleSpeed then
        local throttle = seat.Throttle
        if throttle == 1 or UserInputService:IsKeyDown(Enum.KeyCode.W) then
            local factor = 1 + LocalState.vehicleSpeedValue / 1000
            pcall(function()
                seat.AssemblyLinearVelocity = seat.AssemblyLinearVelocity * Vector3.new(factor, 1, factor)
            end)
        end
    end

    if LocalState.vehicleBrake then
        local throttle = seat.Throttle
        if throttle == -1 or UserInputService:IsKeyDown(Enum.KeyCode.S) then
            local factor = math.max(1 - LocalState.vehicleBrakeValue / 1000, 0)
            pcall(function()
                seat.AssemblyLinearVelocity = seat.AssemblyLinearVelocity * Vector3.new(factor, 1, factor)
            end)
        end
    end

    if LocalState.infiniteFuel then
        if model:GetAttribute("Fuel") ~= nil then
            pcall(function()
                model:SetAttribute("Fuel", math.huge)
            end)
        end
    end
end))

--============= targeting =============--
local Selected = { player = nil }

function Selected:get()
    local player = self.player
    if player and player.Parent then
        return player
    end
    return nil
end

local Spectate = { enabled = false, connection = nil }

function Spectate:stop()
    self.enabled = false
    if self.connection then
        self.connection:Disconnect()
        self.connection = nil
    end
    local humanoid = getHumanoid()
    local cam = camera()
    if humanoid and cam then
        cam.CameraType = Enum.CameraType.Custom
        cam.CameraSubject = humanoid
    end
end

function Spectate:start(player)
    self:stop()
    if not player then
        return
    end
    self.enabled = true

    local function attach(character)
        local humanoid = character and character:FindFirstChildOfClass("Humanoid")
        if humanoid and self.enabled then
            local cam = camera()
            cam.CameraType = Enum.CameraType.Custom
            cam.CameraSubject = humanoid
        end
    end

    attach(player.Character)
    self.connection = player.CharacterAdded:Connect(attach)
end

--============= mouse hit override =============--
-- Fire() reads Mouse.Hit once per shot; overriding that one property redirects
-- the outgoing Fire remote without touching camera, spread or fire rate.
local HitOverride = { part = nil }
getgenv().SLR_HitOverride = HitOverride

if not getgenv().SLR_MouseHooked
    and type(hookmetamethod) == "function"
    and type(newcclosure) == "function" then
    local oldIndex
    oldIndex = hookmetamethod(game, "__index", newcclosure(function(self, key)
        local override = getgenv().SLR_HitOverride
        if key == "Hit" and override and override.part and override.part.Parent then
            local class = typeof(self) == "Instance" and self.ClassName or nil
            if class == "PlayerMouse" or class == "Mouse" then
                return CFrame.new(override.part.Position)
            end
        end
        return oldIndex(self, key)
    end))
    getgenv().SLR_MouseHooked = true
end

local function heldGun()
    local character = LocalPlayer.Character
    local tool = character and character:FindFirstChildOfClass("Tool")
    if tool and (CollectionService:HasTag(tool, "Gun") or tool:FindFirstChild("Settings")) then
        return tool
    end
    return nil
end

local function killPlayer(player)
    if not player or not player.Character then
        notify("select a player first")
        return
    end
    if player == LocalPlayer then
        return
    end
    local head = player.Character:FindFirstChild("Head")
    if not head or not head:IsA("BasePart") then
        notify("target has no head")
        return
    end
    local gun = heldGun()
    if not gun then
        notify("hold a gun first")
        return
    end

    HitOverride.part = head
    task.spawn(function()
        for _ = 1, 18 do
            if not head.Parent or not gun.Parent then
                break
            end
            pcall(function()
                gun:Activate()
            end)
            task.wait(0.08)
        end
        HitOverride.part = nil
    end)
end

--============= apartments / vehicles =============--
local function fetchApartment(playerName)
    local map = Workspace:FindFirstChild("Map")
    local doors = map and map:FindFirstChild("Doors")
    local buy = doors and doors:FindFirstChild("Buy")
    if not buy then
        return nil
    end
    for _, door in ipairs(buy:GetChildren()) do
        local homeOwner = door:FindFirstChild("HomeOwner")
        local gui = homeOwner and homeOwner:FindFirstChild("SurfaceGui")
        local owner = gui and gui:FindFirstChild("Owner")
        local main = door:FindFirstChild("Main")
        if owner and main and main:IsA("BasePart") then
            local text = ""
            if owner:IsA("TextLabel") then
                text = owner.Text
            elseif owner:IsA("StringValue") then
                text = owner.Value
            end
            text = tostring(text):gsub("OWNER:%s*", "")
            if text == playerName then
                return main
            end
        end
    end
    return nil
end

local function playerVehicle(player)
    local vehicles = Workspace:FindFirstChild("Vehicles")
    if not vehicles then
        return nil
    end
    local model = vehicles:FindFirstChild(player.Name .. "'s Car")
    if not model then
        return nil
    end
    return model:FindFirstChild("DriveSeat") or model:FindFirstChildOfClass("VehicleSeat")
end

--============= emotes =============--
local Emotes = {
    ["Solar System"] = "92281817840531",
    ["Crawling"] = "76348568458914",
    ["Chinese Dancing"] = "100193638270362",
    ["Invisible"] = "130371895389423",
    ["Helicopter"] = "119431985170060",
    ["Planet"] = "85275763637868",
    ["Race Car"] = "121936817462716",
    ["Tank"] = "85076031433488",
    ["Obby Head"] = "122814100170962",
    ["No"] = "77206866044608",
    ["Wave"] = "105209959441169",
    ["Ghost"] = "75911227509248",
    ["Wolf"] = "114131394923812",
    ["Jamal"] = "71286446361487",
    ["Kawai"] = "118691207680367",
    ["Zamn"] = "112516309569252",
    ["Shake"] = "132367660388476",
    ["Cute Anime"] = "83496519050227",
    ["Tuff Emote"] = "85636872110453",
    ["I Want Money"] = "89114994401113",
    ["Kawai Sit"] = "113578589119917",
    ["Kawai Fly"] = "100848613923963",
    ["Zesty Backflip"] = "78243540508781",
    ["Zesty Laid Up"] = "75517713793873",
}

local emoteNames = {}
for name in pairs(Emotes) do
    table.insert(emoteNames, name)
end
table.sort(emoteNames)

local CurrentTrack = nil
local SelectedEmote = emoteNames[1]

local function playEmote(name)
    local id = Emotes[name]
    if not id then
        return
    end
    local character = LocalPlayer.Character
    local humanoid = character and character:FindFirstChildOfClass("Humanoid")
    if not humanoid then
        return
    end
    if CurrentTrack then
        pcall(function()
            CurrentTrack:Stop()
        end)
        CurrentTrack = nil
    end
    local animation = Instance.new("Animation")
    animation.AnimationId = "rbxassetid://" .. id
    local ok, track = pcall(function()
        return humanoid:LoadAnimation(animation)
    end)
    if ok and track then
        CurrentTrack = track
        track:Play()
    end
end

local function stopEmote()
    if CurrentTrack then
        pcall(function()
            CurrentTrack:Stop()
        end)
        CurrentTrack = nil
    end
end

--============= shops =============--
local ShopData = nil

local function fetchGunStore()
    local map = Workspace:FindFirstChild("Map")
    local store = map and map:FindFirstChild("GunStore")
    if not store then
        return nil
    end

    local weapons, ammo = {}, {}
    local function read(container, out)
        if not container then
            return
        end
        for _, child in ipairs(container:GetChildren()) do
            local price = child:FindFirstChild("Price")
            local tool = child:FindFirstChild("Tool")
            if price and tool and tool:IsA("ValueBase") and price:IsA("ValueBase") then
                out[tostring(tool.Value)] = price.Value
            end
        end
    end
    read(store:FindFirstChild("Wall"), weapons)
    read(store:FindFirstChild("GWall"), ammo)

    if next(weapons) == nil and next(ammo) == nil then
        return nil
    end
    return { Weapon = weapons, Ammo = ammo }
end

local function nearGunStore()
    local root = getRoot()
    if not root then
        return false
    end
    for _, point in ipairs({ Vector3.new(649, 52, -396), Vector3.new(26, 72, 602) }) do
        if (root.Position - point).Magnitude <= 90 then
            return true
        end
    end
    return false
end

local function purchase(kind, name)
    if not name or name == "" or name == "None" then
        notify("pick a shop item first")
        return
    end
    ShopData = ShopData or fetchGunStore()
    if not ShopData then
        notify("gun store not loaded, get near a store")
        return
    end
    local price
    if kind == "Weapon" then
        price = ShopData.Weapon[name]
    else
        price = ShopData.Ammo[name]
    end
    if not price then
        notify("price not found for " .. tostring(name))
        return
    end

    if not nearGunStore() then
        Teleport:to(Vector3.new(649, 52, -396))
        task.wait(1.2)
    end

    local remotes = ReplicatedStorage:FindFirstChild("Remotes")
    local gunBuy = remotes and remotes:FindFirstChild("GunBuy")
    if not gunBuy then
        notify("GunBuy remote missing")
        return
    end

    pcall(function()
        gunBuy:FireServer(name, price)
    end)
end

--============= clean farm =============--
local CleanFarm = {
    enabled = false,
    claim = true,
    lastAction = "idle",
    cleans = 0,
    misses = 0,
    dirty = 0,
    spots = 0,
    running = false,
}

local JOB_PATH = { "Map", "Jobs", "CleanNPC" }

local function jobNode()
    local node = Workspace
    for _, part in ipairs(JOB_PATH) do
        node = node and node:FindFirstChild(part)
        if not node then
            return nil
        end
    end
    return node
end

local function dataValue(name)
    local data = LocalPlayer:FindFirstChild("Data")
    local value = data and data:FindFirstChild(name)
    return value and value:IsA("ValueBase") and value.Value or nil
end

local function liveCharacter()
    local character = LocalPlayer.Character
    if not character or not character.Parent then
        return nil, nil, nil
    end
    local humanoid = character:FindFirstChildOfClass("Humanoid")
    if not humanoid or humanoid.Health <= 0 then
        return nil, nil, nil
    end
    local root = character:FindFirstChild("HumanoidRootPart")
    if not root then
        return nil, nil, nil
    end
    return character, humanoid, root
end

local CLAIM_WORDS = { "claim", "start work", "start job", "apply", "hire", "clock in", "begin work" }

local function claimJob()
    local current = dataValue("Job")
    if current and current ~= "" then
        return true
    end
    local node = jobNode()
    if not node then
        return false
    end
    local origin = node:GetPivot().Position
    for _, descendant in ipairs(Workspace:GetDescendants()) do
        if descendant:IsA("ProximityPrompt") and descendant.Enabled then
            local parent = descendant.Parent
            if parent and parent:IsA("BasePart") and (parent.Position - origin).Magnitude < 60 then
                local text = (descendant.ActionText .. " " .. descendant.ObjectText):lower()
                for _, word in ipairs(CLAIM_WORDS) do
                    if text:find(word, 1, true) then
                        Teleport:to(parent.Position + Vector3.new(0, 3, 0))
                        pcall(function()
                            fireproximityprompt(descendant)
                        end)
                        task.wait(0.5)
                        return true
                    end
                end
            end
        end
    end
    return false
end

local function collectSpots()
    local node = jobNode()
    local out = {}
    local folder = node and node:FindFirstChild("Clean")
    if not folder then
        return out
    end
    for _, spot in ipairs(folder:GetChildren()) do
        if spot:IsA("BasePart") then
            local prompt = spot:FindFirstChildOfClass("ProximityPrompt")
            if prompt then
                out[#out + 1] = { part = spot, prompt = prompt }
            end
        end
    end
    table.sort(out, function(a, b)
        return a.part.Name < b.part.Name
    end)
    return out
end

local CleanStatusLabel = nil

local function cleanTick()
    if not CleanFarm.enabled then
        CleanFarm.lastAction = "off"
        task.wait(0.25)
        return
    end

    local character, humanoid, root = liveCharacter()
    if not character then
        CleanFarm.lastAction = "waiting for character"
        return
    end

    if CleanFarm.claim then
        pcall(claimJob)
    end

    local spots = collectSpots()
    CleanFarm.spots = #spots
    local dirty = 0
    for _, spot in ipairs(spots) do
        if spot.prompt.Enabled then
            dirty = dirty + 1
        end
    end
    CleanFarm.dirty = dirty

    if dirty == 0 then
        CleanFarm.lastAction = "no dirty spots"
        task.wait(0.6)
        return
    end

    for _, spot in ipairs(spots) do
        if not CleanFarm.enabled then
            return
        end
        if spot.prompt.Enabled then
            Teleport:to(spot.part.Position + Vector3.new(0, 3, 0))
            CleanFarm.lastAction = "cleaning " .. spot.part.Name

            local before = tonumber(LocalPlayer:GetAttribute("TotalCleaned")) or 0
            pcall(function()
                fireproximityprompt(spot.prompt)
            end)

            local deadline = os.clock() + 5
            local paid = false
            while CleanFarm.enabled and os.clock() < deadline do
                task.wait(0.1)
                local now = tonumber(LocalPlayer:GetAttribute("TotalCleaned")) or 0
                if now > before then
                    paid = true
                    break
                end
            end

            if paid then
                CleanFarm.cleans = CleanFarm.cleans + 1
            else
                CleanFarm.misses = CleanFarm.misses + 1
            end
            task.wait(0.1)
        end
    end
end

task.spawn(function()
    while true do
        CleanFarm.running = true
        local ok, err = pcall(cleanTick)
        if not ok then
            CleanFarm.lastAction = "error: " .. tostring(err)
            task.wait(1)
        end
        task.wait(0.05)
    end
end)

task.spawn(function()
    while true do
        task.wait(1)
        if CleanStatusLabel then
            pcall(function()
                CleanStatusLabel:SetText(string.format("%s | %d cleaned, %d spot(s), %d dirty",
                    CleanFarm.lastAction, CleanFarm.cleans, CleanFarm.spots, CleanFarm.dirty))
            end)
        end
    end
end)

--============= UI =============--
local Window = Library:Window({
    Name = "Street Life Remastered",
    FadeTime = 0.3,
})

local Watermark = Library:Watermark("Street Life Remastered")
local KeybindList = Library:KeybindList()

local MainPage = Window:Page({ Name = "Main", Icon = Icons.Main, SubPages = true })
local CombatPage = Window:Page({ Name = "Combat", Icon = Icons.Combat })
local VisualsPage = Window:Page({ Name = "Visuals", Icon = Icons.Visuals })

local MainTab = MainPage:SubPage({ Name = "Main" })
local PlayerTab = MainPage:SubPage({ Name = "Player" })

--============= main / local player =============--
local LocalSection = MainTab:Section({ Name = "Local Player", Side = 1 })
local VehicleSection = MainTab:Section({ Name = "Vehicle", Side = 2 })

LocalSection:Toggle({
    Name = "Instant Interact",
    Flag = "InstantInteract",
    Default = false,
    Callback = function(value)
        LocalState.instantInteract = value
        if value then
            refreshPrompts()
        end
    end,
})

LocalSection:Toggle({
    Name = "Infinite Stamina",
    Flag = "InfiniteStamina",
    Default = false,
    Callback = function(value)
        LocalState.infiniteStamina = value
        if value then
            task.spawn(function()
                for _ = 1, 20 do
                    if bindStamina() then
                        break
                    end
                    task.wait(0.25)
                end
            end)
        else
            Stamina.slots = {}
            Stamina.bound = 0
        end
    end,
})

LocalSection:Toggle({
    Name = "Hide Name",
    Flag = "HideName",
    Default = false,
    Callback = function(value)
        LocalState.hideName = value
        if value then
            applyName()
        else
            restoreName()
        end
    end,
})

LocalSection:Textbox({
    Name = "Name Text",
    Flag = "NameText",
    Default = "",
    Placeholder = "blank = hidden",
    Callback = function(value)
        LocalState.nameText = tostring(value or "")
        if LocalState.hideName then
            applyName()
        end
    end,
})

LocalSection:Toggle({
    Name = "Click To Teleport",
    Flag = "ClickTeleport",
    Default = false,
    Callback = function(value)
        LocalState.clickTeleport = value
    end,
})

LocalSection:Label("Click TP Key"):Keybind({
    Flag = "ClickTeleportKey",
    Mode = "Hold",
    Default = Enum.KeyCode.LeftAlt,
    Callback = function(state)
        if type(state) == "boolean" then
            LocalState.clickHeld = state
        end
    end,
})

LocalSection:Toggle({
    Name = "Speed",
    Flag = "SpeedEnabled",
    Default = false,
    Callback = function(value)
        LocalState.speedEnabled = value
        if value then
            ensureSpeedWatch()
        else
            stopSpeedWatch(true)
        end
    end,
})

LocalSection:Slider({
    Name = "Speed Value",
    Flag = "SpeedValue",
    Default = 16,
    Min = 16,
    Max = 200,
    Decimals = 1,
    Suffix = "",
    Callback = function(value)
        LocalState.speedValue = value
        if LocalState.speedEnabled then
            applySpeedValue()
        end
    end,
})

LocalSection:Toggle({
    Name = "Fly",
    Flag = "FlyEnabled",
    Default = false,
    Callback = function(value)
        if value then
            Fly:start()
        else
            Fly:stop()
        end
    end,
})

LocalSection:Slider({
    Name = "Fly Speed",
    Flag = "FlySpeed",
    Default = 60,
    Min = 10,
    Max = 300,
    Decimals = 1,
    Suffix = "",
    Callback = function(value)
        Fly.speed = value
    end,
})

LocalSection:Toggle({
    Name = "Jump Power",
    Flag = "JumpEnabled",
    Default = false,
    Callback = function(value)
        LocalState.jumpEnabled = value
        local humanoid = getHumanoid()
        if humanoid and not value then
            humanoid.JumpPower = 50
        end
    end,
})

LocalSection:Slider({
    Name = "Jump Power Value",
    Flag = "JumpValue",
    Default = 50,
    Min = 50,
    Max = 300,
    Decimals = 1,
    Suffix = "",
    Callback = function(value)
        LocalState.jumpValue = value
    end,
})

VehicleSection:Toggle({
    Name = "Vehicle Speed",
    Flag = "VehicleSpeedEnabled",
    Default = false,
    Callback = function(value)
        LocalState.vehicleSpeed = value
    end,
})

VehicleSection:Slider({
    Name = "Speed Boost",
    Flag = "VehicleSpeedValue",
    Default = 5,
    Min = 1,
    Max = 25,
    Decimals = 1,
    Suffix = "",
    Callback = function(value)
        LocalState.vehicleSpeedValue = value
    end,
})

VehicleSection:Toggle({
    Name = "Vehicle Brake",
    Flag = "VehicleBrakeEnabled",
    Default = false,
    Callback = function(value)
        LocalState.vehicleBrake = value
    end,
})

VehicleSection:Slider({
    Name = "Brake Power",
    Flag = "VehicleBrakeValue",
    Default = 5,
    Min = 1,
    Max = 25,
    Decimals = 1,
    Suffix = "",
    Callback = function(value)
        LocalState.vehicleBrakeValue = value
    end,
})

VehicleSection:Toggle({
    Name = "Infinite Fuel",
    Flag = "InfiniteFuel",
    Default = false,
    Callback = function(value)
        LocalState.infiniteFuel = value
    end,
})

--============= player page =============--
local PlayersSection = PlayerTab:Section({ Name = "Players", Side = 1 })
local ActionsSection = PlayerTab:Section({ Name = "Actions", Side = 1 })
local ShopSection = PlayerTab:Section({ Name = "Shops", Side = 2 })
local EmoteSection = PlayerTab:Section({ Name = "Emotes", Side = 2 })
local FarmSection = PlayerTab:Section({ Name = "Auto Farm", Side = 1 })

local initialPlayers = playerList(true)
table.insert(initialPlayers, 1, "None")

local selectedDropdown = PlayersSection:Dropdown({
    Name = "Select Player",
    Flag = "SelectedPlayer",
    Default = "None",
    Items = initialPlayers,
    Multi = false,
    Callback = function(value)
        Selected.player = value ~= "None" and Players:FindFirstChild(value) or nil
        if Spectate.enabled then
            local player = Selected:get()
            if player then
                Spectate:start(player)
            else
                Spectate:stop()
            end
        end
    end,
})

PlayersSection:Toggle({
    Name = "Spectate",
    Flag = "Spectate",
    Default = false,
    Callback = function(value)
        if value then
            local player = Selected:get()
            if player then
                Spectate:start(player)
            end
        else
            Spectate:stop()
        end
    end,
})

ActionsSection:Button():Add("Teleport To Player", function()
    local player = Selected:get()
    if not player then
        notify("select a player first")
        return
    end
    task.spawn(function()
        Teleport:toCharacter(player)
    end)
end)

ActionsSection:Button():Add("Teleport To Apartment", function()
    local player = Selected:get()
    if not player then
        notify("select a player first")
        return
    end
    local main = fetchApartment(player.Name)
    if not main then
        notify("no apartment found for " .. player.Name)
        return
    end
    task.spawn(function()
        Teleport:to(main.Position - main.CFrame.LookVector + Vector3.new(0, 1, 0))
    end)
end)

ActionsSection:Button():Add("Teleport To Vehicle", function()
    local player = Selected:get()
    if not player then
        notify("select a player first")
        return
    end
    local seat = playerVehicle(player)
    if not seat then
        notify("no vehicle found for " .. player.Name)
        return
    end
    task.spawn(function()
        Teleport:to(seat.Position + Vector3.new(0, 3, 0))
    end)
end)

ActionsSection:Button():Add("Kill Player - Hold Gun", function()
    killPlayer(Selected:get())
end)

local gunNames = { "None" }
local ammoNames = { "None" }
local SelectedGun = "None"
local SelectedAmmo = "None"

local gunDropdown = ShopSection:Dropdown({
    Name = "Purchase Gun",
    Flag = "ShopGun",
    Default = "None",
    Items = gunNames,
    Multi = false,
    Callback = function(value)
        SelectedGun = value
    end,
})

local ammoDropdown = ShopSection:Dropdown({
    Name = "Purchase Ammo",
    Flag = "ShopAmmo",
    Default = "None",
    Items = ammoNames,
    Multi = false,
    Callback = function(value)
        SelectedAmmo = value
    end,
})

ShopSection:Button():Add("Refresh Shop", function()
    ShopData = fetchGunStore()
    if not ShopData then
        notify("get near a gun store to load items")
        return
    end
    local weapons, ammo = {}, {}
    for name in pairs(ShopData.Weapon) do
        table.insert(weapons, name)
    end
    for name in pairs(ShopData.Ammo) do
        table.insert(ammo, name)
    end
    table.sort(weapons)
    table.sort(ammo)
    table.insert(weapons, 1, "None")
    table.insert(ammo, 1, "None")
    pcall(function()
        gunDropdown:Refresh(weapons)
    end)
    pcall(function()
        ammoDropdown:Refresh(ammo)
    end)
end)

ShopSection:Button():Add("Buy Gun", function()
    purchase("Weapon", SelectedGun)
end)

ShopSection:Button():Add("Buy Ammo", function()
    purchase("Ammo", SelectedAmmo)
end)

local emoteDropdown = EmoteSection:Dropdown({
    Name = "Emote",
    Flag = "SelectedEmote",
    Default = emoteNames[1],
    Items = emoteNames,
    Multi = false,
    Callback = function(value)
        SelectedEmote = value
    end,
})

EmoteSection:Button():Add("Play Emote", function()
    playEmote(SelectedEmote)
end)

EmoteSection:Button():Add("Stop Emote", stopEmote)

FarmSection:Toggle({
    Name = "Auto Farm Cleaning",
    Flag = "CleanFarm",
    Default = false,
    Callback = function(value)
        CleanFarm.enabled = value
    end,
})

FarmSection:Toggle({
    Name = "Claim Job",
    Flag = "ClaimJob",
    Default = true,
    Callback = function(value)
        CleanFarm.claim = value
    end,
})

CleanStatusLabel = FarmSection:Label("idle")

local function refreshTargetLists()
    local names = playerList(true)
    table.insert(names, 1, "None")
    pcall(function()
        selectedDropdown:Refresh(names)
    end)
end

track(Players.PlayerAdded:Connect(function()
    task.wait(0.5)
    refreshTargetLists()
end))

track(Players.PlayerRemoving:Connect(function(player)
    if Selected.player == player then
        Selected.player = nil
        Spectate:stop()
    end
    task.wait(0.1)
    refreshTargetLists()
end))

--============= combat =============--
local AimSection = CombatPage:Section({ Name = "Aimlock", Side = 1 })
local AimFilterSection = CombatPage:Section({ Name = "Aimlock Filters", Side = 2 })
local GunModsSection = CombatPage:Section({ Name = "Gun Mods", Side = 1 })
local HitboxSection = CombatPage:Section({ Name = "Hitbox", Side = 2 })

AimSection:Toggle({
    Name = "Enable Aimlock",
    Flag = "AimEnabled",
    Default = false,
    Callback = function(value)
        Aim.enabled = value
    end,
})

AimSection:Label("Aim Key"):Keybind({
    Flag = "AimKey",
    Mode = "Hold",
    Default = Enum.KeyCode.E,
    Callback = function(state)
        Aim.held = state
    end,
})

AimSection:Toggle({
    Name = "Use FOV",
    Flag = "AimUseFov",
    Default = true,
    Callback = function(value)
        Aim.useFov = value
    end,
})

AimSection:Slider({
    Name = "FOV Radius",
    Flag = "AimFovRadius",
    Default = 150,
    Min = 10,
    Max = 800,
    Decimals = 1,
    Callback = function(value)
        Aim.fovRadius = value
        FieldOfView.radius = value
        applyFovStyle()
    end,
})

AimSection:Slider({
    Name = "Smoothness",
    Flag = "AimSmoothness",
    Default = 1,
    Min = 1,
    Max = 20,
    Decimals = 1,
    Callback = function(value)
        Aim.smoothness = value
    end,
})

AimSection:Dropdown({
    Name = "Hit Part",
    Flag = "AimHitPart",
    Default = "Head",
    Items = { "Head", "UpperTorso", "LowerTorso", "HumanoidRootPart", "Torso" },
    Multi = false,
    Callback = function(value)
        Aim.hitPart = value
    end,
})

AimSection:Toggle({
    Name = "Auto Fire",
    Flag = "AimAutoFire",
    Default = false,
    Callback = function(value)
        Aim.autoFire = value
    end,
})

AimSection:Slider({
    Name = "Auto Fire Delay",
    Flag = "AimAutoFireDelay",
    Default = 0.1,
    Min = 0.02,
    Max = 1,
    Decimals = 2,
    Suffix = "s",
    Callback = function(value)
        Aim.autoFireDelay = value
    end,
})

AimFilterSection:Toggle({
    Name = "Visible Check",
    Flag = "AimVisibleCheck",
    Default = false,
    Callback = function(value)
        Aim.visibleCheck = value
    end,
})

AimFilterSection:Toggle({
    Name = "Health Check",
    Flag = "AimHealthCheck",
    Default = false,
    Callback = function(value)
        Aim.healthCheck = value
    end,
})

AimFilterSection:Slider({
    Name = "Minimum Health",
    Flag = "AimMinHealth",
    Default = 5,
    Min = 0,
    Max = 100,
    Decimals = 1,
    Suffix = "%",
    Callback = function(value)
        Aim.minHealth = value
    end,
})

AimFilterSection:Toggle({
    Name = "Distance Check",
    Flag = "AimDistanceCheck",
    Default = false,
    Callback = function(value)
        Aim.distanceCheck = value
    end,
})

AimFilterSection:Slider({
    Name = "Maximum Distance",
    Flag = "AimMaxDistance",
    Default = 500,
    Min = 10,
    Max = 2000,
    Decimals = 1,
    Suffix = " studs",
    Callback = function(value)
        Aim.maxDistance = value
    end,
})

AimFilterSection:Toggle({
    Name = "Friend Check",
    Flag = "AimFriendCheck",
    Default = false,
    Callback = function(value)
        Aim.friendCheck = value
    end,
})

AimFilterSection:Toggle({
    Name = "Draw FOV",
    Flag = "AimDrawFov",
    Default = false,
    Callback = function(value)
        FieldOfView.draw = value
        applyFovStyle()
    end,
})

AimFilterSection:Label("FOV Color"):Colorpicker({
    Flag = "AimFovColor",
    Default = Color3.new(1, 1, 1),
    Callback = function(color)
        FieldOfView.color = color
        applyFovStyle()
    end,
})

AimFilterSection:Toggle({
    Name = "Fill FOV",
    Flag = "AimFillFov",
    Default = false,
    Callback = function(value)
        FieldOfView.filled = value
        applyFovStyle()
    end,
})

AimFilterSection:Label("FOV Fill Color"):Colorpicker({
    Flag = "AimFovFillColor",
    Default = Color3.new(1, 1, 1),
    Callback = function(color)
        FieldOfView.fillColor = color
        applyFovStyle()
    end,
})

AimFilterSection:Slider({
    Name = "FOV Transparency",
    Flag = "AimFovTransparency",
    Default = 0.35,
    Min = 0,
    Max = 1,
    Decimals = 2,
    Callback = function(value)
        FieldOfView.transparency = value
        FieldOfView.filledTransparency = math.clamp(value + 0.2, 0, 1)
        applyFovStyle()
    end,
})

AimFilterSection:Toggle({
    Name = "Draw Snapline",
    Flag = "AimSnapline",
    Default = false,
    Callback = function(value)
        FieldOfView.snapline = value
    end,
})

AimFilterSection:Label("Snapline Color"):Colorpicker({
    Flag = "AimSnaplineColor",
    Default = Color3.new(1, 1, 1),
    Callback = function(color)
        FieldOfView.snaplineColor = color
        applyFovStyle()
    end,
})

AimFilterSection:Toggle({
    Name = "Highlight Target",
    Flag = "AimHighlight",
    Default = false,
    Callback = function(value)
        FieldOfView.highlight = value
    end,
})

GunModsSection:Toggle({
    Name = "No Recoil",
    Flag = "GunNoRecoil",
    Default = false,
    Callback = function(value)
        GunMods.state.noRecoil = value
        if not value then
            restoreGuns()
        end
    end,
})

GunModsSection:Toggle({
    Name = "No Spread",
    Flag = "GunNoSpread",
    Default = false,
    Callback = function(value)
        GunMods.state.noSpread = value
        if not value then
            restoreGuns()
        end
    end,
})

GunModsSection:Toggle({
    Name = "Fire Rate",
    Flag = "GunFireRate",
    Default = false,
    Callback = function(value)
        GunMods.state.fireRate = value
        if not value then
            restoreGuns()
        end
    end,
})

GunModsSection:Slider({
    Name = "Fire Rate Multiplier",
    Flag = "GunFireRateMult",
    Default = 3,
    Min = 1,
    Max = 15,
    Decimals = 1,
    Suffix = "x",
    Callback = function(value)
        GunMods.state.fireRateMult = value
    end,
})

GunModsSection:Toggle({
    Name = "Automatic",
    Flag = "GunAutomatic",
    Default = false,
    Callback = function(value)
        GunMods.state.automatic = value
        if not value then
            restoreGuns()
        end
    end,
})

GunModsSection:Toggle({
    Name = "No Jam",
    Flag = "GunNoJam",
    Default = false,
    Callback = function(value)
        GunMods.state.noJam = value
        if not value then
            restoreGuns()
        end
    end,
})

local Hitbox = {
    enabled = false,
    size = 2,
    originals = {},
    connection = nil,
}

local function restoreHitboxes()
    for head, data in pairs(Hitbox.originals) do
        if head and head.Parent then
            pcall(function()
                head.Size = data.Size
                head.Massless = data.Massless
            end)
        end
    end
    Hitbox.originals = {}
end

local function expandHeads()
    for _, player in ipairs(Players:GetPlayers()) do
        if player ~= LocalPlayer then
            local head = getHead(player)
            if head then
                if not Hitbox.originals[head] then
                    Hitbox.originals[head] = { Size = head.Size, Massless = head.Massless }
                end
                pcall(function()
                    head.Size = Vector3.new(Hitbox.size, Hitbox.size, Hitbox.size)
                    head.Massless = true
                end)
            end
        end
    end
end

local function hitboxTick()
    if not Hitbox.enabled then
        return
    end
    for _, player in ipairs(Players:GetPlayers()) do
        if player ~= LocalPlayer then
            local head = getHead(player)
            if head and not Hitbox.originals[head] then
                expandHeads()
                return
            end
        end
    end
    local character = LocalPlayer.Character
    local own = character and character:FindFirstChild("Head")
    if own and Hitbox.originals[own] then
        Hitbox.originals[own] = nil
    end
end

HitboxSection:Slider({
    Name = "Hitbox Size",
    Flag = "HitboxSize",
    Default = 2,
    Min = 1,
    Max = 12,
    Decimals = 1,
    Suffix = " studs",
    Callback = function(value)
        Hitbox.size = value
        if Hitbox.enabled then
            restoreHitboxes()
            expandHeads()
        end
    end,
})

HitboxSection:Toggle({
    Name = "Hitbox Expander",
    Flag = "HitboxEnabled",
    Default = false,
    Callback = function(value)
        Hitbox.enabled = value
        if value then
            expandHeads()
        else
            restoreHitboxes()
        end
    end,
})

track(RunService.Heartbeat:Connect(function()
    hitboxTick()
end))

--============= visuals =============--
local ESPSection = VisualsPage:Section({ Name = "Player Visuals", Side = 1 })
local ESPSettings = VisualsPage:Section({ Name = "Player Settings", Side = 1 })
local PerfSection = VisualsPage:Section({ Name = "Performance", Side = 2 })
local GraphSection = VisualsPage:Section({ Name = "Graphics", Side = 2 })
local FOVSection = VisualsPage:Section({ Name = "FOV", Side = 2 })
local SkySection = VisualsPage:Section({ Name = "Sky / Time", Side = 2 })

ESPSection:Toggle({
    Name = "Enable ESP",
    Flag = "ESPEnabled",
    Default = false,
    Callback = function(value)
        ESP.options.enabled = value
    end,
})

ESPSection:Toggle({
    Name = "Player Names",
    Flag = "ESPNames",
    Default = false,
    Callback = function(value)
        ESP.options.names = value
    end,
}):Colorpicker({
    Flag = "ESPNameColor",
    Default = Color3.new(1, 1, 1),
    Callback = function(color)
        ESP.options.nameColor = color
    end,
})

ESPSection:Toggle({
    Name = "Bounding Boxes",
    Flag = "ESPBoxes",
    Default = false,
    Callback = function(value)
        ESP.options.boxes = value
    end,
}):Colorpicker({
    Flag = "ESPBoxColor",
    Default = Color3.new(1, 1, 1),
    Callback = function(color)
        ESP.options.boxesColor = color
    end,
})

ESPSection:Toggle({
    Name = "Box Fill",
    Flag = "ESPBoxFill",
    Default = false,
    Callback = function(value)
        ESP.options.boxFill = value
    end,
}):Colorpicker({
    Flag = "ESPBoxFillColor",
    Default = Color3.new(1, 1, 1),
    Callback = function(color)
        ESP.options.boxFillColor = color
    end,
})

ESPSection:Toggle({
    Name = "Health Bars",
    Flag = "ESPHealthBars",
    Default = false,
    Callback = function(value)
        ESP.options.healthBars = value
    end,
}):Colorpicker({
    Flag = "ESPHealthBarColor",
    Default = Color3.new(0, 1, 0),
    Callback = function(color)
        ESP.options.healthBarsColor = color
    end,
})

ESPSection:Toggle({
    Name = "Health Text",
    Flag = "ESPHealthText",
    Default = false,
    Callback = function(value)
        ESP.options.healthText = value
    end,
}):Colorpicker({
    Flag = "ESPHealthTextColor",
    Default = Color3.new(1, 1, 1),
    Callback = function(color)
        ESP.options.healthTextColor = color
    end,
})

ESPSection:Toggle({
    Name = "Distance",
    Flag = "ESPDistance",
    Default = false,
    Callback = function(value)
        ESP.options.distance = value
    end,
}):Colorpicker({
    Flag = "ESPDistanceColor",
    Default = Color3.new(1, 1, 1),
    Callback = function(color)
        ESP.options.distanceColor = color
    end,
})

ESPSection:Toggle({
    Name = "Show Tool",
    Flag = "ESPTool",
    Default = false,
    Callback = function(value)
        ESP.options.tool = value
    end,
}):Colorpicker({
    Flag = "ESPToolColor",
    Default = Color3.new(1, 1, 1),
    Callback = function(color)
        ESP.options.toolColor = color
    end,
})

ESPSection:Toggle({
    Name = "Tracers",
    Flag = "ESPTracers",
    Default = false,
    Callback = function(value)
        ESP.options.tracers = value
    end,
}):Colorpicker({
    Flag = "ESPTracerColor",
    Default = Color3.new(1, 1, 1),
    Callback = function(color)
        ESP.options.tracerColor = color
    end,
})

ESPSection:Toggle({
    Name = "Chams",
    Flag = "ESPChams",
    Default = false,
    Callback = function(value)
        ESP.options.chams = value
    end,
}):Colorpicker({
    Flag = "ESPChamsColor",
    Default = Color3.new(1, 0, 0),
    Callback = function(color)
        ESP.options.chamsFillColor = color
    end,
})

ESPSettings:Toggle({
    Name = "Visible Only",
    Flag = "ESPVisibleOnly",
    Default = false,
    Callback = function(value)
        ESP.options.visibleOnly = value
    end,
})

ESPSettings:Toggle({
    Name = "Limit Distance",
    Flag = "ESPLimitDistance",
    Default = false,
    Callback = function(value)
        ESP.options.limitDistance = value
    end,
})

ESPSettings:Slider({
    Name = "Max Distance",
    Flag = "ESPMaxDistance",
    Default = 1000,
    Min = 100,
    Max = 5000,
    Decimals = 1,
    Callback = function(value)
        ESP.options.maxDistance = value
    end,
})

ESPSettings:Dropdown({
    Name = "Tracer Origin",
    Flag = "ESPTracerOrigin",
    Default = "Bottom",
    Items = { "Bottom", "Top", "Mouse" },
    Callback = function(value)
        ESP.options.tracerOrigin = value
    end,
})

ESPSettings:Toggle({
    Name = "Team Check",
    Flag = "ESPTeamCheck",
    Default = false,
    Callback = function(value)
        ESP.options.teamCheck = value
    end,
})

local perfButtons = PerfSection:Button()
perfButtons:Add("FPS Boost", function()
    Graphics.fpsBoost()
end)
perfButtons:Add("Restore Lighting", function()
    Graphics.restoreLighting()
end)
perfButtons:Add("RTX Vibrant", function()
    Graphics.vibrantLook()
end)

GraphSection:Toggle({
    Name = "Brightness Boost",
    Flag = "GfxBrightness",
    Default = false,
    Callback = function(value)
        if value then
            Lighting.Brightness = 2.5
            Lighting.Ambient = Color3.fromRGB(200, 200, 200)
        else
            Lighting.Brightness = Graphics.base.Brightness
            Lighting.Ambient = Graphics.base.Ambient
        end
    end,
})

GraphSection:Toggle({
    Name = "Disable Shadows",
    Flag = "GfxShadows",
    Default = false,
    Callback = function(value)
        Lighting.GlobalShadows = not value
    end,
})

GraphSection:Toggle({
    Name = "Bright Outdoor",
    Flag = "GfxOutdoor",
    Default = false,
    Callback = function(value)
        if value then
            Lighting.OutdoorAmbient = Color3.fromRGB(255, 255, 255)
            Lighting.ClockTime = 14
        else
            Lighting.OutdoorAmbient = Graphics.base.OutdoorAmbient
            Lighting.ClockTime = Graphics.base.ClockTime
        end
    end,
})

GraphSection:Toggle({
    Name = "Remove Fog",
    Flag = "GfxFog",
    Default = false,
    Callback = function(value)
        Lighting.FogEnd = value and 100000 or Graphics.base.FogEnd
    end,
})

FOVSection:Toggle({
    Name = "Custom FOV",
    Flag = "FovEnabled",
    Default = false,
    Callback = function(value)
        Graphics.fovEnabled = value
        if not value then
            local cam = camera()
            if cam then
                cam.FieldOfView = Graphics.base.Fov
            end
        end
    end,
})

FOVSection:Slider({
    Name = "FOV Value",
    Flag = "FovValue",
    Default = 70,
    Min = 30,
    Max = 120,
    Decimals = 1,
    Callback = function(value)
        Graphics.fovValue = value
    end,
})

SkySection:Toggle({
    Name = "Permanent Day",
    Flag = "DayLock",
    Default = false,
    Callback = function(value)
        Graphics.day = value
        if not value and not Graphics.night then
            Lighting.ClockTime = Graphics.base.ClockTime
        end
    end,
})

SkySection:Toggle({
    Name = "Permanent Night",
    Flag = "NightLock",
    Default = false,
    Callback = function(value)
        Graphics.night = value
        if not value and not Graphics.day then
            Lighting.ClockTime = Graphics.base.ClockTime
        end
    end,
})

SkySection:Dropdown({
    Name = "Sky Preset",
    Flag = "SkyPreset",
    Default = "Default",
    Items = { "Default", "Sunset", "Foggy", "Dawn", "Blood Moon" },
    Callback = function(value)
        Graphics.applyPreset(value)
    end,
})

SkySection:Dropdown({
    Name = "Skybox",
    Flag = "Skybox",
    Default = "Default",
    Items = { "Default", "Grim Reaper", "Real", "Island", "Purple Sky", "Purple Galaxy", "Pink", "Aurora", "Among Us", "Spongebob", "Deep Space", "Winter", "Clouded Sky" },
    Callback = function(value)
        Graphics.applySkybox(value)
    end,
})

Library:CreateSettingsPage(Window, Watermark, KeybindList)

local settingsPage
for _, page in ipairs(Window.Pages) do
    if page.Name == "Settings" then
        settingsPage = page
        break
    end
end

if settingsPage then
    pcall(function()
        settingsPage.Items.Icon.Instance.Image = Icons.Settings
    end)
end

task.spawn(function()
    local mainFrame = Window.Items and Window.Items.MainFrame and Window.Items.MainFrame.Instance
    if not mainFrame then
        return
    end

    local glow = Instance.new("UIStroke")
    glow.Name = "PurpleGlow"
    glow.Color = Color3.fromRGB(149, 0, 211)
    glow.Thickness = 4
    glow.Transparency = 0.55
    glow.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
    glow.LineJoinMode = Enum.LineJoinMode.Round
    glow.Parent = mainFrame

    local stroke = Instance.new("UIStroke")
    stroke.Name = "PurpleStroke"
    stroke.Color = Color3.fromRGB(149, 0, 211)
    stroke.Thickness = 2
    stroke.Transparency = 0.15
    stroke.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
    stroke.LineJoinMode = Enum.LineJoinMode.Round
    stroke.Parent = mainFrame

    local gradient = Instance.new("UIGradient")
    gradient.Color = ColorSequence.new({
        ColorSequenceKeypoint.new(0.00, Color3.fromRGB(90, 0, 160)),
        ColorSequenceKeypoint.new(0.25, Color3.fromRGB(200, 40, 255)),
        ColorSequenceKeypoint.new(0.50, Color3.fromRGB(255, 140, 255)),
        ColorSequenceKeypoint.new(0.75, Color3.fromRGB(200, 40, 255)),
        ColorSequenceKeypoint.new(1.00, Color3.fromRGB(90, 0, 160)),
    })
    gradient.Rotation = 0
    gradient.Parent = stroke

    TweenService:Create(gradient, TweenInfo.new(8, Enum.EasingStyle.Linear, Enum.EasingDirection.InOut, -1), {
        Rotation = 360,
    }):Play()
end)

local toggleGui = Instance.new("ScreenGui")
toggleGui.Name = "SLR_Toggle"
toggleGui.ResetOnSpawn = false
toggleGui.DisplayOrder = 10
do
    local toggleParent = (gethui and gethui()) or LocalPlayer:WaitForChild("PlayerGui")
    local parentOk = pcall(function()
        toggleGui.Parent = toggleParent
    end)
    if not parentOk then
        toggleGui.Parent = LocalPlayer:WaitForChild("PlayerGui")
    end
end

local toggleButton = Instance.new("ImageButton")
toggleButton.Name = "ToggleButton"
toggleButton.Size = UDim2.new(0, 46, 0, 46)
toggleButton.Position = UDim2.new(0, 10, 0, 50)
toggleButton.Image = Icons.Logo
toggleButton.BackgroundColor3 = Color3.fromRGB(20, 18, 24)
toggleButton.BackgroundTransparency = 0.15
toggleButton.ScaleType = Enum.ScaleType.Fit
toggleButton.Parent = toggleGui

Instance.new("UICorner", toggleButton).CornerRadius = UDim.new(0, 10)

local toggleStroke = Instance.new("UIStroke", toggleButton)
toggleStroke.Color = Color3.fromRGB(149, 0, 211)
toggleStroke.Thickness = 2
toggleStroke.Transparency = 0.25

local dragging, dragInput, dragStart, startPosition = false, nil, nil, nil

toggleButton.InputBegan:Connect(function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
        dragging = true
        dragStart = input.Position
        startPosition = toggleButton.Position
        input.Changed:Connect(function()
            if input.UserInputState == Enum.UserInputState.End then
                dragging = false
            end
        end)
    end
end)

toggleButton.InputChanged:Connect(function(input)
    if input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch then
        dragInput = input
    end
end)

track(UserInputService.InputChanged:Connect(function(input)
    if dragging and input == dragInput then
        local delta = input.Position - dragStart
        toggleButton.Position = UDim2.new(
            startPosition.X.Scale,
            startPosition.X.Offset + delta.X,
            startPosition.Y.Scale,
            startPosition.Y.Offset + delta.Y
        )
    end
end))

toggleButton.MouseButton1Click:Connect(function()
    Window:SetOpen(not Window.IsOpen)
end)

ESP:load()

task.spawn(function()
    task.wait(0.2)
    pcall(function()
        Window:SetBackgroundImage("rbxassetid://117186050112432")
    end)
end)

track(RunService.Heartbeat:Connect(function()
    applyLocalTick()
    if LocalState.infiniteStamina then
        staminaTick()
    end
end))

track(LocalPlayer.CharacterAdded:Connect(function()
    task.wait(1)
    if Fly.enabled then
        Fly:start()
    end
    if Hitbox.enabled then
        expandHeads()
    end
end))

local api = {
    Version = "1.0",
    Library = Library,
    Bypass = Bypass,
    Shop = { Fetch = fetchGunStore, Purchase = purchase },
    Kill = killPlayer,
    ESP = ESP,
    Aim = Aim,
    Teleport = Teleport,
    Graphics = Graphics,
    GunMods = GunMods,
    LocalState = LocalState,
    CleanFarm = CleanFarm,
    Window = Window,
    Pages = { Main = MainPage, Combat = CombatPage, Visuals = VisualsPage, Settings = settingsPage },
}

function api:Destroy()
    pcall(function()
        RunService:UnbindFromRenderStep("slr_esp")
    end)
    pcall(function()
        RunService:UnbindFromRenderStep("slr_aimlock")
    end)
    for _, connection in ipairs(Connections) do
        pcall(function()
            connection:Disconnect()
        end)
    end
    Connections = {}

    Fly:stop()
    Spectate:stop()
    restoreGuns()
    restoreHitboxes()
    Graphics.restore()

    local function destroyByName(container, name)
        if not container then
            return
        end
        for _, gui in ipairs(container:GetChildren()) do
            if gui.Name == name then
                pcall(function()
                    gui:Destroy()
                end)
            end
        end
    end

    destroyByName((gethui and gethui()) or LocalPlayer:FindFirstChild("PlayerGui"), "SLR_ESP")
    destroyByName((gethui and gethui()) or LocalPlayer:FindFirstChild("PlayerGui"), "SLR_FOV")
    destroyByName((gethui and gethui()) or LocalPlayer:FindFirstChild("PlayerGui"), "SLR_Toggle")
    if aimHighlight then
        aimHighlight:Destroy()
    end
    if aimSnapline then
        destroyDrawing(aimSnapline)
    end
    if toggleGui then
        toggleGui:Destroy()
        toggleGui = nil
    end
    pcall(function()
        if Library.Unload then
            Library:Unload()
        end
    end)
    getgenv().SLR_Menu = nil
end

getgenv().SLR_Menu = api

notify("Street Life Remastered loaded")

task.wait(1)
local _api = getgenv().SLR_Menu
print("[TEST] api", type(_api), "bypass", _api and _api.Bypass and _api.Bypass.note)
if _api then
    local _sf = _api.Library.SetFlags
    _sf.CleanFarm(true)
    for i = 1, 10 do
        task.wait(1)
        print("[TEST] t+" .. i, _api.CleanFarm.lastAction, _api.CleanFarm.cleans, _api.CleanFarm.spots)
    end
    _sf.CleanFarm(false)
    print("[TEST] final", _api.CleanFarm.cleans, _api.CleanFarm.misses)
end