-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. Deal with caution.
--
-- Stay safe:
--   • Never log in on unofficial Roblox sites or lookalike domains.
--   • Real Roblox links use roblox.com (check the .com ending).
--   • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End Rscripts Risk Notice ]]


local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UIS = game:GetService("UserInputService")
local TweenService = game:GetService("TweenService")
local Debris = game:GetService("Debris")
local Lighting = game:GetService("Lighting")
local InsertService = game:GetService("InsertService")
local Stats = game:GetService("Stats")

local LP = Players.LocalPlayer
local PlayerGui = LP:WaitForChild("PlayerGui")
local env = (getgenv and getgenv()) or _G

if env.SolarCleanup then pcall(env.SolarCleanup) end
for _, name in ipairs({ "SolarCdtGui", "SolarSplash", "SolarCdtUltimateGui" }) do
    local old = PlayerGui:FindFirstChild(name)
    if old then old:Destroy() end
end

local Connections = {}
local function connect(signal, fn)
    local c = signal:Connect(fn)
    Connections[#Connections + 1] = c
    return c
end

local function make(class, props, parent)
    local inst = Instance.new(class)
    for k, v in pairs(props) do inst[k] = v end
    if parent then inst.Parent = parent end
    return inst
end

local function round(parent, radius)
    return make("UICorner", { CornerRadius = UDim.new(0, radius) }, parent)
end

local function stroke(parent, color, transparency, thickness)
    return make("UIStroke", {
        Color = color or Color3.fromRGB(88, 70, 132),
        Transparency = transparency or 0.5,
        Thickness = thickness or 1,
    }, parent)
end

local function gradient(parent, from, to, rotation)
    return make("UIGradient", {
        Color = ColorSequence.new(from, to),
        Rotation = rotation or 0,
    }, parent)
end

--==============================================================
--  THEME
--==============================================================
local C = {
    bg1 = Color3.fromRGB(24, 15, 44),
    bg2 = Color3.fromRGB(6, 4, 12),
    panel = Color3.fromRGB(13, 10, 22),
    card = Color3.fromRGB(23, 17, 39),
    cardHi = Color3.fromRGB(33, 25, 56),
    track = Color3.fromRGB(44, 34, 68),
    line = Color3.fromRGB(70, 54, 112),
    purple = Color3.fromRGB(146, 92, 255),
    purple2 = Color3.fromRGB(92, 40, 210),
    pink = Color3.fromRGB(224, 74, 246),
    cyan = Color3.fromRGB(56, 214, 240),
    green = Color3.fromRGB(52, 211, 153),
    red = Color3.fromRGB(248, 113, 113),
    text = Color3.fromRGB(244, 240, 255),
    sub = Color3.fromRGB(152, 142, 188),
    dim = Color3.fromRGB(98, 88, 132),
}

--==============================================================
--  STATE
--==============================================================
local S = {
    walkSpeed = 16,
    jumpPower = 50,
    fly = false,
    flySpeed = 65,
    noclip = false,
    infJump = false,

    accel = 1,
    maxSpeed = 9999,
    drift = false,
    antiDrift = false,
    tracks = false,
    carFly = false,
    carJump = false,
    carJumpPower = 72,
    carFlySpeed = 55,
    driftAngle = 35,
    driftGrip = 0.4,

    fullbright = false,
    noFog = false,
    fov = 70,
    uiScale = 1,

    showPlates = true,
    autoFarm = false,
    farmMiles = 0,
    farmMoney = 0,
    farmSpeed = 320,
    writeStats = true,
}

local Toggles = {}
local setMenuVisible, closeMenu, cleanup
local getVehicle, restoreGrip, restoreNoclip, applyFullbright, applyNoFog
local startFarm, stopFarm, refreshFarmLabels

local closing = false
local menuVisible = true

--==============================================================
--  SPLASH
--==============================================================
-- Solar Eclipse (asset 106711499550773): thumbnail renders more reliably than the decal
local SPLASH_IMAGE = "rbxthumb://type=Asset&id=106711499550773&w=420&h=420"

local function playSplash(onDone)
    local sg = make("ScreenGui", {
        Name = "SolarSplash",
        DisplayOrder = 6000,
        IgnoreGuiInset = true,
        ResetOnSpawn = false,
        ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
    }, PlayerGui)

    local back = make("Frame", {
        Size = UDim2.fromScale(1, 1),
        BackgroundColor3 = Color3.fromRGB(3, 2, 7),
        BorderSizePixel = 0,
        BackgroundTransparency = 1,
    }, sg)

    local center = make("Frame", {
        AnchorPoint = Vector2.new(0.5, 0.5),
        Position = UDim2.fromScale(0.5, 0.5),
        Size = UDim2.fromOffset(760, 420),
        BackgroundTransparency = 1,
    }, back)

    local typed = make("TextLabel", {
        Position = UDim2.fromOffset(0, 0),
        Size = UDim2.new(1, 0, 0, 34),
        BackgroundTransparency = 1,
        Text = "",
        TextColor3 = C.text,
        TextSize = 24,
        Font = Enum.Font.GothamBold,
        TextXAlignment = Enum.TextXAlignment.Center,
    }, center)
    gradient(typed, Color3.fromRGB(255, 255, 255), C.pink, 0)

    local showcase = make("Frame", {
        AnchorPoint = Vector2.new(0.5, 0),
        Position = UDim2.new(0.5, 0, 0, 46),
        Size = UDim2.fromOffset(0, 0),
        BackgroundColor3 = C.panel,
        BorderSizePixel = 0,
        ClipsDescendants = true,
    }, center)
    round(showcase, 18)
    local showcaseStroke = stroke(showcase, C.purple, 1, 2)
    gradient(showcase, C.bg1, C.bg2, 120)

    local shot = make("ImageLabel", {
        Size = UDim2.fromScale(1, 1),
        BackgroundTransparency = 1,
        Image = SPLASH_IMAGE,
        ImageTransparency = 1,
        ScaleType = Enum.ScaleType.Crop,
    }, showcase)

    local shotShade = make("Frame", {
        Size = UDim2.fromScale(1, 1),
        BackgroundColor3 = Color3.fromRGB(8, 5, 16),
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
    }, showcase)
    gradient(shotShade, Color3.fromRGB(8, 5, 16), Color3.fromRGB(8, 5, 16), 90)

    local barWrap = make("Frame", {
        AnchorPoint = Vector2.new(0.5, 0),
        Position = UDim2.new(0.5, 0, 0, 274),
        Size = UDim2.fromOffset(420, 40),
        BackgroundTransparency = 1,
    }, center)

    local barLabel = make("TextLabel", {
        Size = UDim2.new(1, 0, 0, 18),
        BackgroundTransparency = 1,
        Text = "",
        TextColor3 = C.sub,
        TextSize = 11,
        Font = Enum.Font.GothamMedium,
        TextTransparency = 1,
    }, barWrap)

    local barBg = make("Frame", {
        Position = UDim2.fromOffset(0, 24),
        Size = UDim2.new(1, 0, 0, 4),
        BackgroundColor3 = Color3.fromRGB(38, 30, 60),
        BorderSizePixel = 0,
        BackgroundTransparency = 1,
    }, barWrap)
    round(barBg, 2)

    local barFill = make("Frame", {
        Size = UDim2.new(0, 0, 1, 0),
        BackgroundColor3 = C.purple,
        BorderSizePixel = 0,
        BackgroundTransparency = 1,
    }, barBg)
    round(barFill, 2)
    gradient(barFill, C.purple, C.pink)

    task.spawn(function()
        TweenService:Create(back, TweenInfo.new(0.35), { BackgroundTransparency = 0 }):Play()
        task.wait(0.35)

        local text = "SOLAR SCRIPT PRESENTS"
        for i = 1, #text do
            typed.Text = string.sub(text, 1, i)
            task.wait(0.028)
        end
        task.wait(0.2)

        TweenService:Create(showcase, TweenInfo.new(0.55, Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
            Size = UDim2.fromOffset(520, 200),
        }):Play()
        TweenService:Create(showcaseStroke, TweenInfo.new(0.6), { Transparency = 0.35 }):Play()
        TweenService:Create(shot, TweenInfo.new(0.8), { ImageTransparency = 0.15 }):Play()
        TweenService:Create(shotShade, TweenInfo.new(0.8), { BackgroundTransparency = 0.55 }):Play()
        task.wait(0.75)

        TweenService:Create(center, TweenInfo.new(0.6, Enum.EasingStyle.Quart, Enum.EasingDirection.InOut), {
            Position = UDim2.fromScale(0.5, 0.56),
        }):Play()
        task.wait(0.3)

        TweenService:Create(barLabel, TweenInfo.new(0.3), { TextTransparency = 0 }):Play()
        TweenService:Create(barBg, TweenInfo.new(0.3), { BackgroundTransparency = 0 }):Play()
        TweenService:Create(barFill, TweenInfo.new(0.3), { BackgroundTransparency = 0 }):Play()

        local label = "solar script present"
        for i = 1, #label do
            barLabel.Text = string.sub(label, 1, i)
            task.wait(0.026)
        end

        TweenService:Create(barFill, TweenInfo.new(1.0, Enum.EasingStyle.Quad), {
            Size = UDim2.new(1, 0, 1, 0),
        }):Play()
        task.wait(1.1)

        local out = TweenInfo.new(0.45, Enum.EasingStyle.Quad, Enum.EasingDirection.In)
        TweenService:Create(back, out, { BackgroundTransparency = 1 }):Play()
        TweenService:Create(typed, out, { TextTransparency = 1 }):Play()
        TweenService:Create(shot, out, { ImageTransparency = 1 }):Play()
        TweenService:Create(barLabel, out, { TextTransparency = 1 }):Play()
        TweenService:Create(barBg, out, { BackgroundTransparency = 1 }):Play()
        TweenService:Create(barFill, out, { BackgroundTransparency = 1 }):Play()
        TweenService:Create(showcase, out, { BackgroundTransparency = 1 }):Play()
        TweenService:Create(showcaseStroke, out, { Transparency = 1 }):Play()
        task.wait(0.5)

        if sg then sg:Destroy() end
        if onDone then onDone() end
    end)
end

--==============================================================
--  GUI SHELL
--==============================================================
local W, H = 700, 470
local SIDE_W, GAP = 132, 8
local PANEL_X = SIDE_W + GAP
local MENU_W = W + PANEL_X * 2
local TOP = 54
local RAIL_X, RAIL_Y, RAIL_W = 10, 64, 54
local CONTENT_X, CONTENT_Y = 74, 64
local CONTENT_W, CONTENT_H = W - CONTENT_X - 12, H - CONTENT_Y - 12

local HAS_CANVAS = pcall(function()
    local probe = Instance.new("CanvasGroup")
    probe.GroupTransparency = 0.5
    probe:Destroy()
end)

local function newGroup(props, parent)
    if HAS_CANVAS then
        return make("CanvasGroup", props, parent)
    end
    props.GroupTransparency = nil
    return make("Frame", props, parent)
end

local function fadeGroup(inst, alpha, info)
    if not inst:IsA("CanvasGroup") then return end
    if info then
        TweenService:Create(inst, info, { GroupTransparency = alpha }):Play()
    else
        inst.GroupTransparency = alpha
    end
end

local gui = make("ScreenGui", {
    Name = "SolarCdtGui",
    ResetOnSpawn = false,
    DisplayOrder = 999,
    IgnoreGuiInset = true,
    ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
}, PlayerGui)

local menu = newGroup({
    Name = "Menu",
    AnchorPoint = Vector2.new(0.5, 0.5),
    Position = UDim2.fromScale(0.5, 0.5),
    Size = UDim2.fromOffset(MENU_W, H),
    BackgroundTransparency = 1,
    GroupTransparency = 1,
    Visible = false,
}, gui)

local guiScale = make("UIScale", { Scale = 1 }, menu)

local baseScale = 1
local plateScale
local function refreshScale()
    local cam = workspace.CurrentCamera
    local vp = cam and cam.ViewportSize or Vector2.new(1280, 720)
    local fit = math.min((vp.X - 24) / MENU_W, (vp.Y - 24) / H)
    fit = math.clamp(fit, 0.35, 1.05)
    baseScale = fit * S.uiScale
    guiScale.Scale = baseScale
    if plateScale then
        plateScale.Scale = math.clamp(fit, 0.6, 1)
    end
end

--==============================================================
--  PANEL
--==============================================================
local panel = make("Frame", {
    Name = "Panel",
    Position = UDim2.fromOffset(PANEL_X, 0),
    Size = UDim2.fromOffset(W, H),
    BackgroundColor3 = C.panel,
    BorderSizePixel = 0,
    Active = true,
    ZIndex = 2,
}, menu)
round(panel, 18)
local panelStroke = stroke(panel, C.purple, 0.45, 1.4)
local panelGrad = gradient(panel, C.bg1, C.bg2, 125)

task.spawn(function()
    while panelGrad and panelGrad.Parent do
        TweenService:Create(panelGrad, TweenInfo.new(5, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut), {
            Rotation = 165,
        }):Play()
        task.wait(5.1)
        if not panelGrad.Parent then break end
        TweenService:Create(panelGrad, TweenInfo.new(5, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut), {
            Rotation = 125,
        }):Play()
        task.wait(5.1)
    end
end)

--==============================================================
--  FLOATING PLATES (speed + system stats)
--==============================================================
local plateHolder = make("Frame", {
    Name = "Plates",
    AnchorPoint = Vector2.new(1, 0),
    Position = UDim2.new(1, -18, 0, 96),
    Size = UDim2.fromOffset(196, 360),
    BackgroundTransparency = 1,
    Visible = false,
    ZIndex = 20,
}, gui)
plateScale = make("UIScale", { Scale = 1 }, plateHolder)

-- speed plate
local speedPlate = make("Frame", {
    Size = UDim2.fromOffset(150, 150),
    Position = UDim2.fromOffset(46, 0),
    BackgroundColor3 = C.panel,
    BackgroundTransparency = 0.05,
    BorderSizePixel = 0,
    ZIndex = 21,
}, plateHolder)
round(speedPlate, 16)
local speedPlateStroke = stroke(speedPlate, C.purple, 0.35, 1.5)
gradient(speedPlate, C.bg1, C.bg2, 120)

make("TextLabel", {
    Position = UDim2.fromOffset(0, 18),
    Size = UDim2.new(1, 0, 0, 20),
    BackgroundTransparency = 1,
    Text = "⚡",
    TextColor3 = C.purple,
    TextSize = 17,
    Font = Enum.Font.GothamBold,
    ZIndex = 22,
}, speedPlate)

local plateSpeedValue = make("TextLabel", {
    Position = UDim2.fromOffset(0, 44),
    Size = UDim2.new(1, 0, 0, 40),
    BackgroundTransparency = 1,
    Text = "0",
    TextColor3 = C.text,
    TextSize = 34,
    Font = Enum.Font.GothamBold,
    ZIndex = 22,
}, speedPlate)
gradient(plateSpeedValue, Color3.new(1, 1, 1), C.pink, 90)

make("TextLabel", {
    Position = UDim2.fromOffset(0, 88),
    Size = UDim2.new(1, 0, 0, 16),
    BackgroundTransparency = 1,
    Text = "STUDS / S",
    TextColor3 = C.sub,
    TextSize = 9,
    Font = Enum.Font.GothamBold,
    ZIndex = 22,
}, speedPlate)

local plateBarBg = make("Frame", {
    Position = UDim2.fromOffset(22, 118),
    Size = UDim2.new(1, -44, 0, 4),
    BackgroundColor3 = C.track,
    BorderSizePixel = 0,
    ZIndex = 22,
}, speedPlate)
round(plateBarBg, 2)
local plateBarFill = make("Frame", {
    Size = UDim2.new(0, 0, 1, 0),
    BackgroundColor3 = C.purple,
    BorderSizePixel = 0,
    ZIndex = 23,
}, plateBarBg)
round(plateBarFill, 2)
gradient(plateBarFill, C.purple, C.pink)

-- system stats plate
local statsPlate = make("Frame", {
    Size = UDim2.fromOffset(196, 202),
    Position = UDim2.fromOffset(0, 162),
    BackgroundColor3 = C.panel,
    BackgroundTransparency = 0.05,
    BorderSizePixel = 0,
    ZIndex = 21,
}, plateHolder)
round(statsPlate, 14)
stroke(statsPlate, C.line, 0.4, 1.2)
gradient(statsPlate, C.bg1, C.bg2, 100)

local STAT_ROWS = {
    { id = "ping",   icon = "rbxassetid://77498244056417", glyph = "≋" },
    { id = "fps",    icon = "rbxassetid://12684119292",    glyph = "▤" },
    { id = "server", icon = "rbxassetid://9692125179",     glyph = "◈" },
    { id = "user",   icon = "rbxassetid://53890741",       glyph = "★" },
}

local statValues = {}

for index, row in ipairs(STAT_ROWS) do
    local y = 10 + (index - 1) * 38
    local rowFrame = make("Frame", {
        Position = UDim2.fromOffset(10, y),
        Size = UDim2.new(1, -20, 0, 32),
        BackgroundColor3 = C.card,
        BackgroundTransparency = 0.55,
        BorderSizePixel = 0,
        ZIndex = 22,
    }, statsPlate)
    round(rowFrame, 8)

    make("TextLabel", {
        Position = UDim2.fromOffset(4, 6),
        Size = UDim2.fromOffset(20, 20),
        BackgroundTransparency = 1,
        Text = row.glyph,
        TextColor3 = C.purple,
        TextSize = 12,
        Font = Enum.Font.GothamBold,
        ZIndex = 23,
    }, rowFrame)

    local icon = make("ImageLabel", {
        Position = UDim2.fromOffset(4, 6),
        Size = UDim2.fromOffset(20, 20),
        BackgroundTransparency = 1,
        Image = row.icon,
        ImageTransparency = 0.15,
        ZIndex = 24,
    }, rowFrame)

    local value = make("TextLabel", {
        Position = UDim2.fromOffset(30, 0),
        Size = UDim2.new(1, -36, 1, 0),
        BackgroundTransparency = 1,
        Text = "—",
        TextColor3 = C.text,
        TextSize = 10,
        Font = Enum.Font.GothamBold,
        TextXAlignment = Enum.TextXAlignment.Left,
        TextTruncate = Enum.TextTruncate.AtEnd,
        ZIndex = 23,
    }, rowFrame)

    if row.id == "user" then
        local rainbow = make("UIGradient", {
            Color = ColorSequence.new({
                ColorSequenceKeypoint.new(0, C.purple),
                ColorSequenceKeypoint.new(0.25, C.pink),
                ColorSequenceKeypoint.new(0.5, C.cyan),
                ColorSequenceKeypoint.new(0.75, C.green),
                ColorSequenceKeypoint.new(1, C.purple),
            }),
            Rotation = 0,
        }, value)
        task.spawn(function()
            while rainbow and rainbow.Parent do
                TweenService:Create(rainbow, TweenInfo.new(3, Enum.EasingStyle.Linear), {
                    Rotation = 360,
                }):Play()
                task.wait(3)
                if rainbow.Parent then rainbow.Rotation = 0 end
            end
        end)
        value.Text = LP.DisplayName .. " @" .. LP.Name
        value.TextSize = 10
    end

    if row.id == "ping" then
        local bars = {}
        for b = 1, 3 do
            local bar = make("Frame", {
                AnchorPoint = Vector2.new(0, 1),
                Position = UDim2.new(1, -38 + (b - 1) * 6, 0.5, 6),
                Size = UDim2.fromOffset(4, 4 + b * 3),
                BackgroundColor3 = C.track,
                BorderSizePixel = 0,
                ZIndex = 23,
            }, rowFrame)
            round(bar, 2)
            bars[b] = bar
        end
        statValues.pingBars = bars
        value.Size = UDim2.new(1, -84, 1, 0)
    end

    statValues[row.id] = value
end

--==============================================================
--  HEADER
--==============================================================
local header = make("Frame", {
    Size = UDim2.new(1, 0, 0, TOP),
    BackgroundTransparency = 1,
    ZIndex = 3,
}, panel)

local mark = make("Frame", {
    Position = UDim2.fromOffset(14, 11),
    Size = UDim2.fromOffset(32, 32),
    BackgroundColor3 = Color3.new(1, 1, 1),
    BorderSizePixel = 0,
}, header)
round(mark, 9)
gradient(mark, C.purple, C.pink, 45)
make("TextLabel", {
    Size = UDim2.fromScale(1, 1),
    BackgroundTransparency = 1,
    Text = "★",
    TextColor3 = Color3.new(1, 1, 1),
    TextSize = 17,
    Font = Enum.Font.GothamBold,
}, mark)

local brand = make("TextLabel", {
    Position = UDim2.fromOffset(56, 8),
    Size = UDim2.fromOffset(160, 22),
    BackgroundTransparency = 1,
    Text = "SOLAR",
    TextColor3 = C.text,
    TextSize = 17,
    Font = Enum.Font.GothamBold,
    TextXAlignment = Enum.TextXAlignment.Left,
}, header)
gradient(brand, Color3.fromRGB(255, 255, 255), C.pink, 0)

make("TextLabel", {
    Position = UDim2.fromOffset(57, 28),
    Size = UDim2.fromOffset(240, 14),
    BackgroundTransparency = 1,
    Text = "ULTIMATE CONTROL",
    TextColor3 = C.dim,
    TextSize = 8,
    Font = Enum.Font.GothamMedium,
    TextXAlignment = Enum.TextXAlignment.Left,
}, header)

local statusPill = make("Frame", {
    Position = UDim2.new(1, -226, 0, 13),
    Size = UDim2.fromOffset(126, 28),
    BackgroundColor3 = C.card,
    BackgroundTransparency = 0.4,
    BorderSizePixel = 0,
}, header)
round(statusPill, 14)
stroke(statusPill, C.line, 0.6, 1)

local statusDot = make("Frame", {
    Position = UDim2.fromOffset(11, 10),
    Size = UDim2.fromOffset(8, 8),
    BackgroundColor3 = C.green,
    BorderSizePixel = 0,
}, statusPill)
round(statusDot, 4)
local statusGlow = stroke(statusDot, C.green, 0.5, 1)

local statusText = make("TextLabel", {
    Position = UDim2.fromOffset(25, 0),
    Size = UDim2.new(1, -30, 1, 0),
    BackgroundTransparency = 1,
    Text = "Ready",
    TextColor3 = C.text,
    TextSize = 9,
    Font = Enum.Font.GothamMedium,
    TextXAlignment = Enum.TextXAlignment.Left,
}, statusPill)

local function topButton(text, x, onClick)
    local b = make("TextButton", {
        Position = UDim2.new(1, x, 0, 13),
        Size = UDim2.fromOffset(28, 28),
        BackgroundColor3 = C.card,
        BackgroundTransparency = 0.25,
        Text = text,
        TextColor3 = C.text,
        TextSize = 15,
        Font = Enum.Font.GothamBold,
        AutoButtonColor = false,
    }, header)
    round(b, 8)
    stroke(b, C.line, 0.55, 1)
    connect(b.MouseEnter, function()
        TweenService:Create(b, TweenInfo.new(0.12), { BackgroundTransparency = 0 }):Play()
    end)
    connect(b.MouseLeave, function()
        TweenService:Create(b, TweenInfo.new(0.12), { BackgroundTransparency = 0.25 }):Play()
    end)
    connect(b.MouseButton1Click, onClick)
    return b
end

--==============================================================
--  DRAG
--==============================================================
local dragZone = make("Frame", {
    Size = UDim2.new(1, -300, 0, TOP),
    BackgroundTransparency = 1,
    ZIndex = 2,
}, header)

local dragging, dragStart, panelStart = false, nil, nil
connect(dragZone.InputBegan, function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch then
        dragging = true
        dragStart = input.Position
        panelStart = menu.Position
    end
end)
connect(UIS.InputChanged, function(input)
    if not dragging then return end
    if input.UserInputType == Enum.UserInputType.MouseMovement
        or input.UserInputType == Enum.UserInputType.Touch then
        local d = input.Position - dragStart
        menu.Position = UDim2.new(
            panelStart.X.Scale, panelStart.X.Offset + d.X,
            panelStart.Y.Scale, panelStart.Y.Offset + d.Y
        )
    end
end)
connect(UIS.InputEnded, function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch then
        dragging = false
    end
end)

--==============================================================
--  RAIL (tabs)
--==============================================================
local rail = make("Frame", {
    Position = UDim2.fromOffset(RAIL_X, RAIL_Y),
    Size = UDim2.fromOffset(RAIL_W, H - RAIL_Y - 10),
    BackgroundColor3 = C.card,
    BackgroundTransparency = 0.45,
    BorderSizePixel = 0,
    ZIndex = 3,
}, panel)
round(rail, 14)
stroke(rail, C.line, 0.7, 1)

local TABS = {
    { id = "main",      label = "Main",   icon = "✦" },
    { id = "player",    label = "Player",     icon = "◉" },
    { id = "vehicle",   label = "Vehicle",    icon = "◆" },
    { id = "visuals",   label = "Visuals",    icon = "✧" },
    { id = "teleports", label = "Teleports", icon = "◈" },
    { id = "farms",     label = "Farm",      icon = "▤" },
    { id = "misc",      label = "Misc",    icon = "▣" },
    { id = "settings",  label = "Settings", icon = "⚙" },
}

local tabButtons = {}
local activeTab = nil

-- rail tooltip
local tipHolder = make("Frame", {
    Position = UDim2.fromOffset(RAIL_X + RAIL_W + 8, RAIL_Y),
    Size = UDim2.fromOffset(118, 26),
    BackgroundTransparency = 1,
    ZIndex = 30,
}, panel)
local tipBack = make("Frame", {
    Size = UDim2.fromScale(1, 1),
    BackgroundColor3 = C.cardHi,
    BackgroundTransparency = 1,
    BorderSizePixel = 0,
}, tipHolder)
round(tipBack, 8)
stroke(tipBack, C.line, 0.4, 1)
local tipText = make("TextLabel", {
    Size = UDim2.fromScale(1, 1),
    BackgroundTransparency = 1,
    Text = "",
    TextColor3 = C.text,
    TextSize = 10,
    Font = Enum.Font.GothamMedium,
    TextTransparency = 1,
}, tipBack)

local function showTip(label, y)
    tipText.Text = label
    tipHolder.Position = UDim2.fromOffset(RAIL_X + RAIL_W + 8, RAIL_Y + y + 6)
    TweenService:Create(tipText, TweenInfo.new(0.12), { TextTransparency = 0 }):Play()
    TweenService:Create(tipBack, TweenInfo.new(0.12), { BackgroundTransparency = 0.05 }):Play()
end

local function hideTip()
    TweenService:Create(tipText, TweenInfo.new(0.12), { TextTransparency = 1 }):Play()
    TweenService:Create(tipBack, TweenInfo.new(0.12), { BackgroundTransparency = 1 }):Play()
end

local function renderTab(entry, active, animate)
    local info = TweenInfo.new(0.18, Enum.EasingStyle.Quart, Enum.EasingDirection.Out)
    local bg = active and 0.1 or 1
    local line = active and 0.2 or 1
    local color = active and C.text or C.sub
    if animate then
        TweenService:Create(entry.btn, info, { BackgroundTransparency = bg }):Play()
        TweenService:Create(entry.fill, info, { BackgroundTransparency = active and 0.15 or 1 }):Play()
        TweenService:Create(entry.btnStroke, info, { Transparency = line }):Play()
        TweenService:Create(entry.icon, info, { TextColor3 = color }):Play()
    else
        entry.btn.BackgroundTransparency = bg
        entry.fill.BackgroundTransparency = active and 0.15 or 1
        entry.btnStroke.Transparency = line
        entry.icon.TextColor3 = color
    end
end

for index, tab in ipairs(TABS) do
    local y = 8 + (index - 1) * 46
    local btn = make("TextButton", {
        Position = UDim2.fromOffset(8, y),
        Size = UDim2.fromOffset(38, 38),
        BackgroundColor3 = C.cardHi,
        BackgroundTransparency = 1,
        Text = "",
        AutoButtonColor = false,
        ZIndex = 4,
    }, rail)
    round(btn, 10)
    local btnStroke = stroke(btn, C.purple, 1, 1)

    local fill = make("Frame", {
        Size = UDim2.fromScale(1, 1),
        BackgroundColor3 = C.purple2,
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
    }, btn)
    round(fill, 10)
    gradient(fill, C.purple2, C.purple, 20)

    local icon = make("TextLabel", {
        Size = UDim2.fromScale(1, 1),
        BackgroundTransparency = 1,
        Text = tab.icon,
        TextColor3 = C.sub,
        TextSize = 15,
        Font = Enum.Font.GothamBold,
        ZIndex = 5,
    }, btn)

    local entry = { btn = btn, fill = fill, icon = icon, btnStroke = btnStroke }
    tabButtons[tab.id] = entry

    connect(btn.MouseEnter, function()
        if activeTab ~= tab.id then
            TweenService:Create(btn, TweenInfo.new(0.12), { BackgroundTransparency = 0.55 }):Play()
        end
        showTip(tab.label, y)
    end)
    connect(btn.MouseLeave, function()
        if activeTab ~= tab.id then
            TweenService:Create(btn, TweenInfo.new(0.12), { BackgroundTransparency = 1 }):Play()
        end
        hideTip()
    end)
end

--==============================================================
--  CONTENT
--==============================================================
local content = make("Frame", {
    Position = UDim2.fromOffset(CONTENT_X, CONTENT_Y),
    Size = UDim2.fromOffset(CONTENT_W, CONTENT_H),
    BackgroundTransparency = 1,
    ClipsDescendants = true,
    ZIndex = 3,
}, panel)

local pages = {}

local function makePage()
    local page = newGroup({
        Size = UDim2.fromScale(1, 1),
        BackgroundTransparency = 1,
        GroupTransparency = 1,
        Visible = false,
    }, content)

    local scroll = make("ScrollingFrame", {
        Size = UDim2.fromScale(1, 1),
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        ScrollBarThickness = 3,
        ScrollBarImageColor3 = C.purple,
        CanvasSize = UDim2.new(0, 0, 0, 1200),
        ScrollingDirection = Enum.ScrollingDirection.Y,
    }, page)
    pcall(function() scroll.AutomaticCanvasSize = Enum.AutomaticSize.Y end)
    pcall(function() scroll.ElasticBehavior = Enum.ElasticBehavior.WhenScrollable end)
    make("UIPadding", {
        PaddingLeft = UDim.new(0, 2),
        PaddingRight = UDim.new(0, 8),
        PaddingTop = UDim.new(0, 2),
        PaddingBottom = UDim.new(0, 12),
    }, scroll)
    make("UIListLayout", {
        Padding = UDim.new(0, 8),
        SortOrder = Enum.SortOrder.LayoutOrder,
    }, scroll)

    return page, scroll
end

local function makeSection(scroll, order, text)
    local row = make("Frame", {
        Size = UDim2.new(1, -12, 0, 16),
        BackgroundTransparency = 1,
        LayoutOrder = order,
    }, scroll)
    local bar = make("Frame", {
        Position = UDim2.fromOffset(0, 2),
        Size = UDim2.fromOffset(3, 12),
        BackgroundColor3 = C.purple,
        BorderSizePixel = 0,
    }, row)
    round(bar, 2)
    make("TextLabel", {
        Position = UDim2.fromOffset(11, 0),
        Size = UDim2.new(1, -11, 1, 0),
        BackgroundTransparency = 1,
        Text = text,
        TextColor3 = C.sub,
        TextSize = 9,
        Font = Enum.Font.GothamBold,
        TextXAlignment = Enum.TextXAlignment.Left,
    }, row)
end

local function makeCard(scroll, order)
    local card = make("Frame", {
        Size = UDim2.new(1, -12, 0, 0),
        AutomaticSize = Enum.AutomaticSize.Y,
        BackgroundColor3 = C.card,
        BackgroundTransparency = 0.12,
        BorderSizePixel = 0,
        LayoutOrder = order,
    }, scroll)
    round(card, 13)
    stroke(card, C.line, 0.72, 1)
    make("UIPadding", {
        PaddingLeft = UDim.new(0, 10),
        PaddingRight = UDim.new(0, 10),
        PaddingTop = UDim.new(0, 10),
        PaddingBottom = UDim.new(0, 10),
    }, card)
    make("UIListLayout", {
        Padding = UDim.new(0, 7),
        SortOrder = Enum.SortOrder.LayoutOrder,
    }, card)
    return card
end

--==============================================================
--  COMPONENTS
--==============================================================
local function makeSlider(parent, order, titleText, minV, maxV, defV, fmt, cb)
    local row = make("Frame", {
        Size = UDim2.new(1, 0, 0, 48),
        BackgroundTransparency = 1,
        LayoutOrder = order,
    }, parent)

    make("TextLabel", {
        Size = UDim2.new(1, -70, 0, 16),
        BackgroundTransparency = 1,
        Text = titleText,
        TextColor3 = C.text,
        TextSize = 10,
        Font = Enum.Font.GothamMedium,
        TextXAlignment = Enum.TextXAlignment.Left,
    }, row)

    local badge = make("Frame", {
        Position = UDim2.new(1, -62, 0, 0),
        Size = UDim2.fromOffset(62, 18),
        BackgroundColor3 = C.panel,
        BackgroundTransparency = 0.15,
        BorderSizePixel = 0,
    }, row)
    round(badge, 5)
    stroke(badge, C.purple, 0.6, 1)

    local valueText = make("TextLabel", {
        Size = UDim2.fromScale(1, 1),
        BackgroundTransparency = 1,
        TextColor3 = C.text,
        TextSize = 9,
        Font = Enum.Font.GothamBold,
    }, badge)

    local track = make("Frame", {
        Position = UDim2.fromOffset(0, 30),
        Size = UDim2.new(1, 0, 0, 5),
        BackgroundColor3 = C.track,
        BorderSizePixel = 0,
    }, row)
    round(track, 3)

    local fill = make("Frame", {
        Size = UDim2.new(0, 0, 1, 0),
        BackgroundColor3 = C.purple,
        BorderSizePixel = 0,
    }, track)
    round(fill, 3)
    gradient(fill, C.purple, C.pink)

    local knob = make("Frame", {
        AnchorPoint = Vector2.new(0.5, 0.5),
        Position = UDim2.new(0, 0, 0.5, 0),
        Size = UDim2.fromOffset(13, 13),
        BackgroundColor3 = Color3.fromRGB(250, 248, 255),
        BorderSizePixel = 0,
        ZIndex = 4,
    }, track)
    round(knob, 7)
    stroke(knob, C.purple, 0.05, 2)

    local hit = make("TextButton", {
        Position = UDim2.fromOffset(-6, 20),
        Size = UDim2.new(1, 12, 0, 26),
        BackgroundTransparency = 1,
        Text = "",
        AutoButtonColor = false,
        ZIndex = 5,
    }, row)

    local function apply(value, fire)
        value = math.clamp(math.floor(value + 0.5), minV, maxV)
        local p = (value - minV) / (maxV - minV)
        knob.Position = UDim2.new(p, 0, 0.5, 0)
        fill.Size = UDim2.new(p, 0, 1, 0)
        valueText.Text = fmt and fmt(value) or tostring(value)
        if fire and cb then cb(value) end
    end

    local sliding = false
    local function fromInput(input)
        local rel = (input.Position.X - track.AbsolutePosition.X) / math.max(track.AbsoluteSize.X, 1)
        apply(minV + (maxV - minV) * math.clamp(rel, 0, 1), true)
    end

    local scrollParent = parent
    while scrollParent and not scrollParent:IsA("ScrollingFrame") do
        scrollParent = scrollParent.Parent
    end

    connect(hit.InputBegan, function(input)
        if input.UserInputType == Enum.UserInputType.MouseButton1
            or input.UserInputType == Enum.UserInputType.Touch then
            sliding = true
            if scrollParent then scrollParent.ScrollingEnabled = false end
            fromInput(input)
        end
    end)
    connect(UIS.InputChanged, function(input)
        if sliding and (input.UserInputType == Enum.UserInputType.MouseMovement
            or input.UserInputType == Enum.UserInputType.Touch) then
            fromInput(input)
        end
    end)
    connect(UIS.InputEnded, function(input)
        if input.UserInputType == Enum.UserInputType.MouseButton1
            or input.UserInputType == Enum.UserInputType.Touch then
            sliding = false
            if scrollParent then scrollParent.ScrollingEnabled = true end
        end
    end)

    apply(defV, true)
    return { set = function(v) apply(v, false) end }
end

local function makeToggle(parent, order, iconText, titleText, initial, cb)
    local row = make("TextButton", {
        Size = UDim2.new(1, 0, 0, 38),
        BackgroundColor3 = C.cardHi,
        BackgroundTransparency = 0.5,
        AutoButtonColor = false,
        Text = "",
        LayoutOrder = order,
    }, parent)
    round(row, 9)
    local rowStroke = stroke(row, C.line, 0.75, 1)

    local iconBox = make("Frame", {
        Position = UDim2.fromOffset(8, 8),
        Size = UDim2.fromOffset(22, 22),
        BackgroundColor3 = C.purple2,
        BackgroundTransparency = 0.55,
        BorderSizePixel = 0,
    }, row)
    round(iconBox, 7)
    make("TextLabel", {
        Size = UDim2.fromScale(1, 1),
        BackgroundTransparency = 1,
        Text = iconText,
        TextColor3 = C.text,
        TextSize = 11,
        Font = Enum.Font.GothamBold,
    }, iconBox)

    make("TextLabel", {
        Position = UDim2.fromOffset(38, 0),
        Size = UDim2.new(1, -92, 1, 0),
        BackgroundTransparency = 1,
        Text = titleText,
        TextColor3 = C.text,
        TextSize = 10,
        Font = Enum.Font.GothamMedium,
        TextXAlignment = Enum.TextXAlignment.Left,
        TextTruncate = Enum.TextTruncate.AtEnd,
    }, row)

    local pill = make("Frame", {
        Position = UDim2.new(1, -46, 0.5, -9),
        Size = UDim2.fromOffset(36, 18),
        BackgroundColor3 = C.track,
        BorderSizePixel = 0,
    }, row)
    round(pill, 9)
    local pillStroke = stroke(pill, C.line, 0.5, 1)

    local knob = make("Frame", {
        Position = UDim2.fromOffset(2, 2),
        Size = UDim2.fromOffset(14, 14),
        BackgroundColor3 = Color3.fromRGB(236, 232, 248),
        BorderSizePixel = 0,
    }, pill)
    round(knob, 7)

    local state = initial
    local info = TweenInfo.new(0.2, Enum.EasingStyle.Quart, Enum.EasingDirection.Out)

    local function render(animate)
        local pillColor = state and C.purple or C.track
        local knobPos = state and UDim2.new(1, -16, 0, 2) or UDim2.fromOffset(2, 2)
        if animate then
            TweenService:Create(pill, info, { BackgroundColor3 = pillColor }):Play()
            TweenService:Create(knob, info, { Position = knobPos }):Play()
            TweenService:Create(pillStroke, info, { Color = state and C.pink or C.line, Transparency = state and 0.2 or 0.5 }):Play()
            TweenService:Create(rowStroke, info, { Color = state and C.purple or C.line }):Play()
            TweenService:Create(iconBox, info, { BackgroundTransparency = state and 0.2 or 0.55 }):Play()
        else
            pill.BackgroundColor3 = pillColor
            knob.Position = knobPos
            pillStroke.Color = state and C.pink or C.line
            rowStroke.Color = state and C.purple or C.line
            iconBox.BackgroundTransparency = state and 0.2 or 0.55
        end
    end

    local api = {}
    function api.get() return state end
    function api.set(value)
        if state == value then return end
        state = value
        render(true)
        if cb then cb(state) end
    end
    function api.toggle() api.set(not state) end

    render(false)

    connect(row.MouseButton1Click, function() api.toggle() end)
    connect(row.MouseEnter, function()
        TweenService:Create(row, TweenInfo.new(0.12), { BackgroundTransparency = 0.25 }):Play()
    end)
    connect(row.MouseLeave, function()
        TweenService:Create(row, TweenInfo.new(0.12), { BackgroundTransparency = 0.5 }):Play()
    end)

    return api
end

local function makeAction(parent, order, iconText, titleText, cb)
    local row = make("TextButton", {
        Size = UDim2.new(1, 0, 0, 36),
        BackgroundColor3 = C.cardHi,
        BackgroundTransparency = 0.5,
        AutoButtonColor = false,
        Text = "",
        LayoutOrder = order,
    }, parent)
    round(row, 9)
    stroke(row, C.line, 0.75, 1)

    local iconBox = make("Frame", {
        Position = UDim2.fromOffset(8, 7),
        Size = UDim2.fromOffset(22, 22),
        BackgroundColor3 = C.purple2,
        BackgroundTransparency = 0.55,
        BorderSizePixel = 0,
    }, row)
    round(iconBox, 7)
    make("TextLabel", {
        Size = UDim2.fromScale(1, 1),
        BackgroundTransparency = 1,
        Text = iconText,
        TextColor3 = C.text,
        TextSize = 11,
        Font = Enum.Font.GothamBold,
    }, iconBox)

    make("TextLabel", {
        Position = UDim2.fromOffset(38, 0),
        Size = UDim2.new(1, -66, 1, 0),
        BackgroundTransparency = 1,
        Text = titleText,
        TextColor3 = C.text,
        TextSize = 10,
        Font = Enum.Font.GothamMedium,
        TextXAlignment = Enum.TextXAlignment.Left,
    }, row)

    make("TextLabel", {
        Position = UDim2.new(1, -26, 0, 0),
        Size = UDim2.fromOffset(18, 36),
        BackgroundTransparency = 1,
        Text = "›",
        TextColor3 = C.purple,
        TextSize = 16,
        Font = Enum.Font.GothamBold,
    }, row)

    connect(row.MouseButton1Click, cb)
    connect(row.MouseEnter, function()
        TweenService:Create(row, TweenInfo.new(0.12), { BackgroundTransparency = 0.25 }):Play()
    end)
    connect(row.MouseLeave, function()
        TweenService:Create(row, TweenInfo.new(0.12), { BackgroundTransparency = 0.5 }):Play()
    end)
end

local function makeInput(parent, order, placeholder, buttonText, onSubmit)
    local row = make("Frame", {
        Size = UDim2.new(1, 0, 0, 34),
        BackgroundTransparency = 1,
        LayoutOrder = order,
    }, parent)

    local box = make("Frame", {
        Size = UDim2.new(1, -78, 1, 0),
        BackgroundColor3 = C.panel,
        BackgroundTransparency = 0.2,
        BorderSizePixel = 0,
    }, row)
    round(box, 8)
    stroke(box, C.line, 0.6, 1)

    local input = make("TextBox", {
        Position = UDim2.fromOffset(9, 0),
        Size = UDim2.new(1, -18, 1, 0),
        BackgroundTransparency = 1,
        Text = "",
        PlaceholderText = placeholder,
        PlaceholderColor3 = C.dim,
        TextColor3 = C.text,
        TextSize = 10,
        Font = Enum.Font.Gotham,
        TextXAlignment = Enum.TextXAlignment.Left,
        ClearTextOnFocus = false,
    }, box)

    local btn = make("TextButton", {
        Position = UDim2.new(1, -70, 0, 0),
        Size = UDim2.fromOffset(70, 34),
        BackgroundColor3 = C.purple2,
        BackgroundTransparency = 0.15,
        Text = buttonText,
        TextColor3 = C.text,
        TextSize = 9,
        Font = Enum.Font.GothamBold,
        AutoButtonColor = false,
    }, row)
    round(btn, 8)
    stroke(btn, C.purple, 0.4, 1)
    gradient(btn, C.purple2, C.purple, 20)

    connect(btn.MouseEnter, function()
        TweenService:Create(btn, TweenInfo.new(0.12), { BackgroundTransparency = 0 }):Play()
    end)
    connect(btn.MouseLeave, function()
        TweenService:Create(btn, TweenInfo.new(0.12), { BackgroundTransparency = 0.15 }):Play()
    end)
    connect(btn.MouseButton1Click, function()
        onSubmit(input.Text)
    end)
    connect(input.FocusLost, function(enterPressed)
        if enterPressed then onSubmit(input.Text) end
    end)

    return input
end

local function makeNote(parent, order, text)
    local label = make("TextLabel", {
        Size = UDim2.new(1, 0, 0, 0),
        AutomaticSize = Enum.AutomaticSize.Y,
        BackgroundTransparency = 1,
        Text = text,
        TextColor3 = C.dim,
        TextSize = 9,
        Font = Enum.Font.Gotham,
        TextWrapped = true,
        TextXAlignment = Enum.TextXAlignment.Left,
        LayoutOrder = order,
    }, parent)
    return label
end

--==============================================================
--  PAGE: MAIN
--==============================================================
local mainPage, mainScroll = makePage()
pages.main = mainPage

makeSection(mainScroll, 1, "SPEED")
local speedCard = makeCard(mainScroll, 2)
makeSlider(speedCard, 1, "Acceleration multiplier", 1, 50, 1, function(v)
    return v .. "x"
end, function(v)
    S.accel = v
end)
makeSlider(speedCard, 2, "Max speed", 100, 9999, 9999, nil, function(v)
    S.maxSpeed = v
end)

makeSection(mainScroll, 3, "MODES")
local driveCard = makeCard(mainScroll, 4)
Toggles.drift = makeToggle(driveCard, 1, "◆", "Drift on all cars", false, function(v)
    S.drift = v
    if v and Toggles.antiDrift then Toggles.antiDrift.set(false) end
end)
Toggles.antiDrift = makeToggle(driveCard, 2, "◈", "Anti-drift (sharp steering)", false, function(v)
    S.antiDrift = v
    if v and Toggles.drift then Toggles.drift.set(false) end
end)
Toggles.tracks = makeToggle(driveCard, 3, "✧", "Tire tracks", false, function(v)
    S.tracks = v
end)
Toggles.carJump = makeToggle(driveCard, 4, "↥", "Car jump (Space)", false, function(v)
    S.carJump = v
end)
Toggles.carFly = makeToggle(driveCard, 5, "▲", "Car fly (Space / Ctrl)", false, function(v)
    S.carFly = v
end)

makeSection(mainScroll, 5, "TIP")
local hintCard = makeCard(mainScroll, 6)
makeNote(hintCard, 1, "W — throttle, A / D — steering, Space — car jump.\nRightShift — hide or show the menu.\nHover the menu to reveal the side panels.")

--==============================================================
--  PAGE: PLAYER
--==============================================================
local playerPage, playerScroll = makePage()
pages.player = playerPage

makeSection(playerScroll, 1, "MOVEMENT")
local moveCard = makeCard(playerScroll, 2)
makeSlider(moveCard, 1, "Walk speed", 16, 500, 16, nil, function(v)
    S.walkSpeed = v
    local hum = LP.Character and LP.Character:FindFirstChildOfClass("Humanoid")
    if hum then hum.WalkSpeed = v end
end)
makeSlider(moveCard, 2, "Jump power", 50, 500, 50, nil, function(v)
    S.jumpPower = v
    local hum = LP.Character and LP.Character:FindFirstChildOfClass("Humanoid")
    if hum then
        hum.UseJumpPower = true
        hum.JumpPower = v
    end
end)

makeSection(playerScroll, 3, "ABILITIES")
local abilityCard = makeCard(playerScroll, 4)
Toggles.fly = makeToggle(abilityCard, 1, "▲", "Player fly", false, function(v)
    S.fly = v
    if not v then
        local hum = LP.Character and LP.Character:FindFirstChildOfClass("Humanoid")
        if hum then hum.PlatformStand = false end
    end
end)
makeSlider(abilityCard, 2, "Fly speed", 20, 250, 65, nil, function(v)
    S.flySpeed = v
end)
Toggles.noclip = makeToggle(abilityCard, 3, "◇", "Noclip", false, function(v)
    S.noclip = v
    if not v and restoreNoclip then restoreNoclip() end
end)
Toggles.infJump = makeToggle(abilityCard, 4, "↥", "Infinite jump", false, function(v)
    S.infJump = v
end)

--==============================================================
--  PAGE: VEHICLE
--==============================================================
local vehiclePage, vehicleScroll = makePage()
pages.vehicle = vehiclePage

makeSection(vehicleScroll, 1, "TUNING")
local tuneCard = makeCard(vehicleScroll, 2)
makeSlider(tuneCard, 1, "Car jump power", 30, 220, 72, nil, function(v)
    S.carJumpPower = v
end)
makeSlider(tuneCard, 2, "Car fly speed", 20, 160, 55, nil, function(v)
    S.carFlySpeed = v
end)

makeSection(vehicleScroll, 3, "DRIFT")
local driftCard = makeCard(vehicleScroll, 4)
makeSlider(driftCard, 1, "Drift angle", 10, 60, 35, function(v)
    return v .. "°"
end, function(v)
    S.driftAngle = v
end)
makeSlider(driftCard, 2, "Drift grip", 10, 100, 40, function(v)
    return v .. "%"
end, function(v)
    S.driftGrip = v / 100
end)

makeSection(vehicleScroll, 5, "SWAP CAR WITH MESH")
local meshCard = makeCard(vehicleScroll, 6)
local meshStatus = makeNote(meshCard, 2, "Paste a MeshPart link or its ID.")
local meshInput

local meshHidden = {}

local function parseAssetId(text)
    text = tostring(text or "")
    local id = text:match("rbxassetid://(%d+)")
        or text:match("/asset/(%d+)")
        or text:match("^%s*(%d+)%s*$")
    return id and tonumber(id) or nil
end

local function applyMeshSwap(assetId)
    local car = getVehicle and getVehicle()
    if not car then
        meshStatus.Text = "Get in a car first."
        meshStatus.TextColor3 = C.red
        return
    end

    meshStatus.Text = "Loading mesh..."
    meshStatus.TextColor3 = C.sub

    task.spawn(function()
        local ok, model = pcall(function()
            return InsertService:LoadAsset(assetId)
        end)

        if not ok or not model then
            local ok2, objects = pcall(function()
                return game:GetObjects("rbxassetid://" .. tostring(assetId))
            end)
            if ok2 and objects and objects[1] then
                model = objects[1]
                ok = true
            end
        end

        if not ok or not model then
            meshStatus.Text = "Failed to load asset " .. tostring(assetId)
            meshStatus.TextColor3 = C.red
            return
        end

        local mesh = model:FindFirstChildWhichIsA("MeshPart", true)
            or model:FindFirstChildWhichIsA("BasePart", true)
        if not mesh then
            meshStatus.Text = "No MeshPart in this asset."
            meshStatus.TextColor3 = C.red
            model:Destroy()
            return
        end

        local root = car.PrimaryPart or car:FindFirstChildWhichIsA("BasePart")
        if not root then
            meshStatus.Text = "Car root part not found."
            meshStatus.TextColor3 = C.red
            model:Destroy()
            return
        end

        local clone = mesh:Clone()
        clone.Name = "SolarMesh_" .. assetId
        clone.CFrame = root.CFrame
        clone.Anchored = false
        clone.CanCollide = false
        clone.Massless = true
        clone.Parent = car

        local weld = Instance.new("WeldConstraint")
        weld.Part0 = root
        weld.Part1 = clone
        weld.Parent = clone

        for _, part in ipairs(car:GetDescendants()) do
            if part:IsA("BasePart") and part ~= root and part ~= clone
                and not part:IsDescendantOf(clone) then
                meshHidden[part] = part.Transparency
                part.Transparency = 1
            end
        end

        model:Destroy()
        meshStatus.Text = "Done: mesh applied (" .. assetId .. ")"
        meshStatus.TextColor3 = C.green
    end)
end

meshInput = makeInput(meshCard, 1, "rbxassetid://1234567890", "APPLY", function(text)
    local id = parseAssetId(text)
    if not id then
        meshStatus.Text = "Invalid link or ID."
        meshStatus.TextColor3 = C.red
        return
    end
    applyMeshSwap(id)
end)

makeAction(meshCard, 3, "↺", "Restore original look", function()
    local car = getVehicle and getVehicle()
    if not car then
        meshStatus.Text = "Get in a car first."
        meshStatus.TextColor3 = C.red
        return
    end
    for part, transparency in pairs(meshHidden) do
        if part.Parent then part.Transparency = transparency end
    end
    meshHidden = {}
    for _, part in ipairs(car:GetDescendants()) do
        if part.Name:find("SolarMesh_") then part:Destroy() end
    end
    meshStatus.Text = "Original look restored."
    meshStatus.TextColor3 = C.green
end)

--==============================================================
--  PAGE: VISUALS
--==============================================================
local visualsPage, visualsScroll = makePage()
pages.visuals = visualsPage

local bannerCard = makeCard(visualsScroll, 1)
local banner = make("ImageLabel", {
    Size = UDim2.new(1, 0, 0, 132),
    BackgroundColor3 = C.cardHi,
    BackgroundTransparency = 0.15,
    BorderSizePixel = 0,
    Image = "rbxassetid://103289157776464",
    ImageTransparency = 0.05,
    ScaleType = Enum.ScaleType.Crop,
    LayoutOrder = 1,
}, bannerCard)
round(banner, 10)
stroke(banner, C.purple, 0.6, 1)

local bannerShade = make("Frame", {
    Size = UDim2.fromScale(1, 1),
    BackgroundColor3 = Color3.fromRGB(8, 5, 16),
    BackgroundTransparency = 0.72,
    BorderSizePixel = 0,
}, banner)
round(bannerShade, 10)

make("TextLabel", {
    Position = UDim2.fromOffset(12, 0),
    Size = UDim2.new(1, -24, 1, 0),
    BackgroundTransparency = 1,
    Text = "SOLAR VISUALS",
    TextColor3 = C.text,
    TextSize = 15,
    Font = Enum.Font.GothamBold,
    TextXAlignment = Enum.TextXAlignment.Left,
}, banner)

makeSection(visualsScroll, 2, "GRAPHICS")
local visCard = makeCard(visualsScroll, 3)
Toggles.fullbright = makeToggle(visCard, 1, "☀", "Fullbright", false, function(v)
    S.fullbright = v
    if applyFullbright then applyFullbright(v) end
end)
Toggles.noFog = makeToggle(visCard, 2, "≋", "Remove fog", false, function(v)
    S.noFog = v
    if applyNoFog then applyNoFog(v) end
end)

local fovCard = makeCard(visualsScroll, 4)
makeSlider(fovCard, 1, "Field of view (FOV)", 50, 120, 70, nil, function(v)
    S.fov = v
    local cam = workspace.CurrentCamera
    if cam then cam.FieldOfView = v end
end)

--==============================================================
--  PAGES: PLACEHOLDERS
--==============================================================
local function makePlaceholder(id, titleText, noteText)
    local page, scroll = makePage()
    pages[id] = page

    makeSection(scroll, 1, titleText)
    local card = makeCard(scroll, 2)
    makeNote(card, 1, "Work in progress.\nFeatures arrive in the next update.")

    makeSection(scroll, 3, "COMING SOON")
    local list = makeCard(scroll, 4)
    makeNote(list, 1, noteText)
end

makePlaceholder("teleports", "TELEPORTS",
    "· Teleport to dealer\n· Teleport to home\n· Teleport to garage\n· Player list and teleport")

--==============================================================
--  PAGE: AUTO FARM
--==============================================================
local farmPage, farmScroll = makePage()
pages.farms = farmPage

makeSection(farmScroll, 1, "AUTO FARM")
local farmCard = makeCard(farmScroll, 2)
local farmStatus = makeNote(farmCard, 2, "Get in a car, then enable auto farm.")

Toggles.autoFarm = makeToggle(farmCard, 1, "▤", "Auto farm (loop track)", false, function(v)
    S.autoFarm = v
    if v then
        if startFarm then startFarm() end
    else
        if stopFarm then stopFarm() end
    end
end)

makeSlider(farmCard, 3, "Farm speed", 60, 700, 320, nil, function(v)
    S.farmSpeed = v
end)

makeSection(farmScroll, 3, "SESSION")
local sessionCard = makeCard(farmScroll, 4)
local farmMilesLabel = makeNote(sessionCard, 1, "Miles: 0")
local farmMoneyLabel = makeNote(sessionCard, 2, "Money: $0")
makeNote(sessionCard, 3, "Counters grow while the car loops on the platform. If the game has Miles / Cash leaderstats, they are increased too.")

Toggles.writeStats = makeToggle(sessionCard, 4, "✎", "Write to leaderstats", true, function(v)
    S.writeStats = v
end)

refreshFarmLabels = function()
    farmMilesLabel.Text = "Miles: " .. string.format("%.1f", S.farmMiles)
    farmMoneyLabel.Text = "Money: $" .. string.format("%d", math.floor(S.farmMoney))
end
refreshFarmLabels()

--==============================================================
--  PAGE: MISC
--==============================================================
local miscPage, miscScroll = makePage()
pages.misc = miscPage

makeSection(miscScroll, 1, "ACTIONS")
local miscCard = makeCard(miscScroll, 2)
makeAction(miscCard, 1, "↺", "Respawn character", function()
    local hum = LP.Character and LP.Character:FindFirstChildOfClass("Humanoid")
    if hum then hum.Health = 0 end
end)
makeAction(miscCard, 2, "◐", "Hide menu", function()
    if setMenuVisible then setMenuVisible(false) end
end)

makeSection(miscScroll, 3, "INFO")
local infoCard = makeCard(miscScroll, 4)
makeNote(infoCard, 1, "Game: " .. tostring(game.PlaceId) ..
    "\nServer: " .. tostring(game.JobId ~= "" and string.sub(game.JobId, 1, 8) or "private") ..
    "\nUser: " .. LP.Name)

--==============================================================
--  PAGE: SETTINGS
--==============================================================
local settingsPage, settingsScroll = makePage()
pages.settings = settingsPage

makeSection(settingsScroll, 1, "INTERFACE")
local uiCard = makeCard(settingsScroll, 2)
makeSlider(uiCard, 1, "Menu scale", 60, 130, 100, function(v)
    return v .. "%"
end, function(v)
    S.uiScale = v / 100
    refreshScale()
end)
Toggles.showPlates = makeToggle(uiCard, 2, "▦", "Show side plates", true, function(v)
    S.showPlates = v
    if plateHolder then
        plateHolder.Visible = v and menuVisible and menu.Visible and not closing
    end
end)

makeSection(settingsScroll, 3, "ABOUT")
local aboutCard = makeCard(settingsScroll, 4)
makeNote(aboutCard, 1, "SOLAR · ULTIMATE CONTROL\nVersion 8.0.0\nDrift: grip blend + yaw slip\nMesh car swap + auto farm")

local closeCard = makeCard(settingsScroll, 5)
makeAction(closeCard, 1, "✕", "Close menu", function()
    if closeMenu then closeMenu() end
end)

--==============================================================
--  HOVER SIDE PANELS
--==============================================================
local function makeSidePanel(side)
    local x = side == "left" and -SIDE_W or (PANEL_X + W + GAP)
    local holder = newGroup({
        Position = UDim2.fromOffset(x, 0),
        Size = UDim2.fromOffset(SIDE_W, H),
        BackgroundTransparency = 1,
        GroupTransparency = 1,
        Visible = false,
        ZIndex = 1,
    }, menu)

    local box = make("Frame", {
        Size = UDim2.fromScale(1, 1),
        BackgroundColor3 = C.panel,
        BackgroundTransparency = 0.05,
        BorderSizePixel = 0,
    }, holder)
    round(box, 16)
    stroke(box, C.purple, 0.5, 1.2)
    gradient(box, C.bg1, C.bg2, side == "left" and 100 or 260)

    return holder, box
end

local leftHolder, leftBox = makeSidePanel("left")
local rightHolder, rightBox = makeSidePanel("right")

-- left panel: HP + speed
make("TextLabel", {
    Position = UDim2.fromOffset(0, 16),
    Size = UDim2.new(1, 0, 0, 14),
    BackgroundTransparency = 1,
    Text = "STATUS",
    TextColor3 = C.dim,
    TextSize = 8,
    Font = Enum.Font.GothamBold,
}, leftBox)

local hpIcon = make("TextLabel", {
    Position = UDim2.fromOffset(0, 36),
    Size = UDim2.new(1, 0, 0, 16),
    BackgroundTransparency = 1,
    Text = "♥",
    TextColor3 = C.red,
    TextSize = 12,
    Font = Enum.Font.GothamBold,
}, leftBox)

local hpValue = make("TextLabel", {
    Position = UDim2.fromOffset(0, 52),
    Size = UDim2.new(1, 0, 0, 20),
    BackgroundTransparency = 1,
    Text = "100",
    TextColor3 = C.text,
    TextSize = 16,
    Font = Enum.Font.GothamBold,
}, leftBox)

local hpBarBg = make("Frame", {
    Position = UDim2.fromOffset(14, 78),
    Size = UDim2.new(1, -28, 0, 4),
    BackgroundColor3 = C.track,
    BorderSizePixel = 0,
}, leftBox)
round(hpBarBg, 2)
local hpBarFill = make("Frame", {
    Size = UDim2.new(1, 0, 1, 0),
    BackgroundColor3 = C.red,
    BorderSizePixel = 0,
}, hpBarBg)
round(hpBarFill, 2)

local spdIcon = make("TextLabel", {
    Position = UDim2.fromOffset(0, 104),
    Size = UDim2.new(1, 0, 0, 16),
    BackgroundTransparency = 1,
    Text = "⚡",
    TextColor3 = C.cyan,
    TextSize = 13,
    Font = Enum.Font.GothamBold,
}, leftBox)

local spdValue = make("TextLabel", {
    Position = UDim2.fromOffset(0, 120),
    Size = UDim2.new(1, 0, 0, 22),
    BackgroundTransparency = 1,
    Text = "0",
    TextColor3 = C.text,
    TextSize = 18,
    Font = Enum.Font.GothamBold,
}, leftBox)

make("TextLabel", {
    Position = UDim2.fromOffset(0, 143),
    Size = UDim2.new(1, 0, 0, 12),
    BackgroundTransparency = 1,
    Text = "STUDS / S",
    TextColor3 = C.dim,
    TextSize = 7,
    Font = Enum.Font.GothamBold,
}, leftBox)

local quickLeft = make("Frame", {
    Position = UDim2.fromOffset(12, 172),
    Size = UDim2.new(1, -24, 0, 0),
    AutomaticSize = Enum.AutomaticSize.Y,
    BackgroundTransparency = 1,
}, leftBox)
make("UIListLayout", {
    Padding = UDim.new(0, 6),
    SortOrder = Enum.SortOrder.LayoutOrder,
}, quickLeft)

local quickRight = make("Frame", {
    Position = UDim2.fromOffset(12, 16),
    Size = UDim2.new(1, -24, 0, 0),
    AutomaticSize = Enum.AutomaticSize.Y,
    BackgroundTransparency = 1,
}, rightBox)
make("UIListLayout", {
    Padding = UDim.new(0, 6),
    SortOrder = Enum.SortOrder.LayoutOrder,
}, quickRight)

make("TextLabel", {
    Position = UDim2.fromOffset(0, 0),
    Size = UDim2.new(1, 0, 0, 14),
    BackgroundTransparency = 1,
    Text = "QUICK",
    TextColor3 = C.dim,
    TextSize = 8,
    Font = Enum.Font.GothamBold,
}, rightBox)
quickRight.Position = UDim2.fromOffset(12, 32)

local sideStateLabels = {}

local function makeSideSquare(parent, order, id, iconText)
    local b = make("TextButton", {
        Size = UDim2.new(1, 0, 0, 44),
        BackgroundColor3 = C.card,
        BackgroundTransparency = 0.2,
        AutoButtonColor = false,
        Text = "",
        LayoutOrder = order,
    }, parent)
    round(b, 10)
    local bStroke = stroke(b, C.line, 0.7, 1)

    local icon = make("TextLabel", {
        Position = UDim2.fromOffset(0, 5),
        Size = UDim2.new(1, 0, 0, 18),
        BackgroundTransparency = 1,
        Text = iconText,
        TextColor3 = C.purple,
        TextSize = 13,
        Font = Enum.Font.GothamBold,
    }, b)

    local state = make("TextLabel", {
        Position = UDim2.fromOffset(0, 24),
        Size = UDim2.new(1, 0, 0, 14),
        BackgroundTransparency = 1,
        Text = "OFF",
        TextColor3 = C.dim,
        TextSize = 7,
        Font = Enum.Font.GothamBold,
    }, b)

    connect(b.MouseButton1Click, function()
        if Toggles[id] then Toggles[id].toggle() end
    end)
    connect(b.MouseEnter, function()
        TweenService:Create(b, TweenInfo.new(0.12), { BackgroundTransparency = 0.02 }):Play()
        TweenService:Create(bStroke, TweenInfo.new(0.12), { Color = C.purple, Transparency = 0.35 }):Play()
    end)
    connect(b.MouseLeave, function()
        TweenService:Create(b, TweenInfo.new(0.12), { BackgroundTransparency = 0.2 }):Play()
        TweenService:Create(bStroke, TweenInfo.new(0.12), { Color = C.line, Transparency = 0.7 }):Play()
    end)

    sideStateLabels[#sideStateLabels + 1] = function()
        local api = Toggles[id]
        local on = api and api.get()
        state.Text = on and "ON" or "OFF"
        state.TextColor3 = on and C.green or C.dim
        icon.TextColor3 = on and C.pink or C.purple
    end
end

makeSideSquare(quickLeft, 1, "drift", "◆")
makeSideSquare(quickLeft, 2, "carJump", "↥")
makeSideSquare(quickLeft, 3, "carFly", "▲")
makeSideSquare(quickLeft, 4, "tracks", "✧")

makeSideSquare(quickRight, 1, "fly", "▲")
makeSideSquare(quickRight, 2, "noclip", "◇")
makeSideSquare(quickRight, 3, "infJump", "↥")
makeSideSquare(quickRight, 4, "antiDrift", "◈")

-- sparks flying out on hover
local sparks = {}
for i = 1, 6 do
    local spark = make("TextLabel", {
        Position = UDim2.fromOffset(math.random(0, W), math.random(20, H - 40)),
        Size = UDim2.fromOffset(24, 24),
        BackgroundTransparency = 1,
        Text = "⚡",
        TextColor3 = C.purple,
        TextSize = 14,
        Font = Enum.Font.GothamBold,
        TextTransparency = 1,
        Rotation = math.random(-25, 25),
        ZIndex = 1,
    }, panel)
    sparks[i] = spark
end

local hovered = false

local function setHovered(value)
    if hovered == value then return end
    hovered = value

    local info = TweenInfo.new(0.32, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)

    if value then
        leftHolder.Visible = true
        rightHolder.Visible = true
        fadeGroup(leftHolder, 1)
        fadeGroup(rightHolder, 1)
        leftHolder.Position = UDim2.fromOffset(SIDE_W * 0.35, 0)
        rightHolder.Position = UDim2.fromOffset(PANEL_X + W + GAP - SIDE_W * 0.35, 0)
        TweenService:Create(leftHolder, info, { Position = UDim2.fromOffset(0, 0) }):Play()
        TweenService:Create(rightHolder, info, {
            Position = UDim2.fromOffset(PANEL_X + W + GAP, 0),
        }):Play()
        fadeGroup(leftHolder, 0, info)
        fadeGroup(rightHolder, 0, info)
        TweenService:Create(panelStroke, TweenInfo.new(0.3), { Color = C.pink, Transparency = 0.25 }):Play()

        for index, spark in ipairs(sparks) do
            local target = UDim2.fromOffset(math.random(10, W - 30), math.random(16, H - 40))
            spark.TextTransparency = 1
            spark.Position = target
            TweenService:Create(spark, TweenInfo.new(0.5 + index * 0.05, Enum.EasingStyle.Quad), {
                TextTransparency = 0.35,
            }):Play()
            task.delay(0.5 + index * 0.05, function()
                if spark then
                    TweenService:Create(spark, TweenInfo.new(0.7, Enum.EasingStyle.Quad), {
                        TextTransparency = 1,
                    }):Play()
                end
            end)
        end
    else
        fadeGroup(leftHolder, 1, TweenInfo.new(0.22, Enum.EasingStyle.Quad, Enum.EasingDirection.In))
        fadeGroup(rightHolder, 1, TweenInfo.new(0.22, Enum.EasingStyle.Quad, Enum.EasingDirection.In))
        TweenService:Create(leftHolder, TweenInfo.new(0.24), {
            Position = UDim2.fromOffset(SIDE_W * 0.35, 0),
        }):Play()
        TweenService:Create(rightHolder, TweenInfo.new(0.24), {
            Position = UDim2.fromOffset(PANEL_X + W + GAP - SIDE_W * 0.35, 0),
        }):Play()
        TweenService:Create(panelStroke, TweenInfo.new(0.3), { Color = C.purple, Transparency = 0.45 }):Play()
        task.delay(0.26, function()
            if not hovered then
                leftHolder.Visible = false
                rightHolder.Visible = false
            end
        end)
    end
end

-- hover zone is computed from cursor position, not MouseEnter,
-- so the panels do not flicker when crossing the gap
local hoverClock = 0
connect(RunService.Heartbeat, function(dt)
    hoverClock = hoverClock + dt
    if hoverClock < 0.05 then return end
    hoverClock = 0

    if not menuVisible or closing or not menu.Visible then
        setHovered(false)
        return
    end

    local mouse = UIS:GetMouseLocation()
    local ap = panel.AbsolutePosition
    local as = panel.AbsoluteSize
    local unit = as.X / W
    local sideSpan = (SIDE_W + GAP) * unit

    local inside = mouse.X >= ap.X - sideSpan - 4
        and mouse.X <= ap.X + as.X + sideSpan + 4
        and mouse.Y >= ap.Y - 6
        and mouse.Y <= ap.Y + as.Y + 6

    setHovered(inside)
end)

--==============================================================
--  TAB SWITCHING
--==============================================================
local function selectTab(id)
    if activeTab == id then return end
    local prev = activeTab
    activeTab = id

    for tabId, entry in pairs(tabButtons) do
        renderTab(entry, tabId == id, true)
    end

    if prev and pages[prev] then
        local oldPage = pages[prev]
        fadeGroup(oldPage, 1, TweenInfo.new(0.1, Enum.EasingStyle.Quad, Enum.EasingDirection.In))
        task.delay(0.12, function()
            if activeTab ~= prev then oldPage.Visible = false end
        end)
    end

    local page = pages[id]
    if page then
        page.Visible = true
        fadeGroup(page, 1)
        page.Position = UDim2.fromOffset(12, 0)
        TweenService:Create(page, TweenInfo.new(0.26, Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
            Position = UDim2.fromOffset(0, 0),
        }):Play()
        fadeGroup(page, 0, TweenInfo.new(0.26, Enum.EasingStyle.Quint, Enum.EasingDirection.Out))
    end
end

for _, tab in ipairs(TABS) do
    connect(tabButtons[tab.id].btn.MouseButton1Click, function()
        selectTab(tab.id)
    end)
end

activeTab = "main"
pages.main.Visible = true
fadeGroup(pages.main, 0)
for tabId, entry in pairs(tabButtons) do
    renderTab(entry, tabId == "main", false)
end

topButton("–", -68, function()
    if setMenuVisible then setMenuVisible(false) end
end)
topButton("×", -38, function()
    if closeMenu then closeMenu() end
end)

--==============================================================
--  STATUS POLL
--==============================================================
local fpsValue = 60
local fpsFrames = 0
local fpsClock = 0
connect(RunService.RenderStepped, function(dt)
    fpsFrames = fpsFrames + 1
    fpsClock = fpsClock + dt
    if fpsClock >= 1 then
        fpsValue = math.floor(fpsFrames / fpsClock + 0.5)
        fpsFrames = 0
        fpsClock = 0
    end
end)

local pollTimer = 0
connect(RunService.Heartbeat, function(dt)
    pollTimer = pollTimer + dt
    if pollTimer < 0.12 then return end
    pollTimer = 0

    local hum = LP.Character and LP.Character:FindFirstChildOfClass("Humanoid")
    if hum then
        local hp = math.clamp(hum.Health / math.max(hum.MaxHealth, 1), 0, 1)
        hpValue.Text = tostring(math.floor(hum.Health))
        hpBarFill.Size = UDim2.new(hp, 0, 1, 0)
        hpBarFill.BackgroundColor3 = hp > 0.5 and C.green or (hp > 0.25 and Color3.fromRGB(250, 204, 21) or C.red)
    else
        hpValue.Text = "0"
        hpBarFill.Size = UDim2.new(0, 0, 1, 0)
    end

    local car = getVehicle and getVehicle()
    local root = car and (car.PrimaryPart or car:FindFirstChildWhichIsA("BasePart"))
    if root then
        local v = root.AssemblyLinearVelocity
        spdValue.Text = tostring(math.floor(Vector3.new(v.X, 0, v.Z).Magnitude))
    else
        local hrp = LP.Character and LP.Character:FindFirstChild("HumanoidRootPart")
        local v = hrp and hrp.AssemblyLinearVelocity or Vector3.zero
        spdValue.Text = tostring(math.floor(Vector3.new(v.X, 0, v.Z).Magnitude))
    end

    for _, update in ipairs(sideStateLabels) do update() end

    -- floating plates
    if plateHolder.Visible then
        local speedNow = 0
        if root then
            local v = root.AssemblyLinearVelocity
            speedNow = math.floor(Vector3.new(v.X, 0, v.Z).Magnitude)
        else
            local hrp = LP.Character and LP.Character:FindFirstChild("HumanoidRootPart")
            local v = hrp and hrp.AssemblyLinearVelocity or Vector3.zero
            speedNow = math.floor(Vector3.new(v.X, 0, v.Z).Magnitude)
        end
        plateSpeedValue.Text = tostring(speedNow)
        plateBarFill.Size = UDim2.new(math.clamp(speedNow / 400, 0, 1), 0, 1, 0)

        local ping = nil
        pcall(function()
            local item = Stats.Network.ServerStatsItem["Data Ping"]
            if item then ping = math.floor(item:GetValue()) end
        end)
        local level = 0
        if ping then
            statValues.ping.Text = tostring(ping) .. " ms"
            statValues.ping.TextColor3 = ping < 80 and C.green
                or (ping < 160 and Color3.fromRGB(250, 204, 21) or C.red)
            level = ping < 80 and 3 or (ping < 160 and 2 or 1)
        else
            statValues.ping.Text = "— ms"
            statValues.ping.TextColor3 = C.dim
        end

        if statValues.pingBars then
            local colors = {
                C.red,
                Color3.fromRGB(250, 204, 21),
                C.green,
            }
            for b, bar in ipairs(statValues.pingBars) do
                bar.BackgroundColor3 = (b == level) and colors[b] or C.track
            end
        end

        statValues.fps.Text = tostring(fpsValue) .. " FPS"
        statValues.fps.TextColor3 = fpsValue >= 45 and C.green
            or (fpsValue >= 25 and Color3.fromRGB(250, 204, 21) or C.red)

        local job = game.JobId
        statValues.server.Text = job ~= "" and string.sub(job, 1, 8) or "private"
    end

    refreshFarmLabels()
end)

-- status pulse
task.spawn(function()
    while statusDot and statusDot.Parent do
        TweenService:Create(statusGlow, TweenInfo.new(0.9, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut), {
            Transparency = 0.85,
        }):Play()
        task.wait(0.9)
        if not statusDot.Parent then break end
        TweenService:Create(statusGlow, TweenInfo.new(0.9, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut), {
            Transparency = 0.3,
        }):Play()
        task.wait(0.9)
    end
end)

--==============================================================
--  LOGIC: PLAYER
--==============================================================
local function getHumanoid()
    local ch = LP.Character
    return ch and ch:FindFirstChildOfClass("Humanoid")
end

local function getHRP()
    local ch = LP.Character
    return ch and ch:FindFirstChild("HumanoidRootPart")
end

local noclipParts = {}
restoreNoclip = function()
    for part in pairs(noclipParts) do
        if part.Parent then
            pcall(function() part.CanCollide = true end)
        end
    end
    noclipParts = {}
end

local noclipTimer = 0
connect(RunService.Heartbeat, function(dt)
    if not S.noclip then return end
    noclipTimer = noclipTimer + dt
    if noclipTimer < 0.15 then return end
    noclipTimer = 0
    local ch = LP.Character
    if not ch then return end
    for _, part in ipairs(ch:GetDescendants()) do
        if part:IsA("BasePart") and part.CanCollide then
            part.CanCollide = false
            noclipParts[part] = true
        end
    end
end)

local flying = false
connect(RunService.RenderStepped, function(dt)
    local hum = getHumanoid()
    local hrp = getHRP()
    if not hum or not hrp or hum.Health <= 0 then
        if flying then
            flying = false
            if hum then hum.PlatformStand = false end
        end
        return
    end

    if S.fly and not hum.SeatPart then
        if not flying then
            flying = true
            hum.PlatformStand = true
        end
        local dir = Vector3.zero
        local cam = workspace.CurrentCamera
        if cam then
            local cf = cam.CFrame
            if UIS:IsKeyDown(Enum.KeyCode.W) then dir = dir + cf.LookVector end
            if UIS:IsKeyDown(Enum.KeyCode.S) then dir = dir - cf.LookVector end
            if UIS:IsKeyDown(Enum.KeyCode.D) then dir = dir + cf.RightVector end
            if UIS:IsKeyDown(Enum.KeyCode.A) then dir = dir - cf.RightVector end
        end
        if UIS:IsKeyDown(Enum.KeyCode.Space) then dir = dir + Vector3.yAxis end
        if UIS:IsKeyDown(Enum.KeyCode.LeftControl) then dir = dir - Vector3.yAxis end
        if dir.Magnitude > 0 then dir = dir.Unit end
        hrp.AssemblyLinearVelocity = hrp.AssemblyLinearVelocity:Lerp(
            dir * S.flySpeed, math.clamp(dt * 9, 0, 1)
        )
    elseif flying then
        flying = false
        hum.PlatformStand = false
    end
end)

connect(LP.CharacterAdded, function(ch)
    task.wait(0.35)
    local hum = ch:FindFirstChildOfClass("Humanoid")
    if hum then
        hum.WalkSpeed = S.walkSpeed
        hum.UseJumpPower = true
        hum.JumpPower = S.jumpPower
    end
end)

--==============================================================
--  LOGIC: LIGHTING
--==============================================================
local lightSaved = nil
applyFullbright = function(on)
    if on then
        if not lightSaved then
            lightSaved = {
                brightness = Lighting.Brightness,
                ambient = Lighting.Ambient,
                outdoor = Lighting.OutdoorAmbient,
                shadows = Lighting.GlobalShadows,
            }
        end
        Lighting.Brightness = 3
        Lighting.Ambient = Color3.fromRGB(185, 185, 195)
        Lighting.OutdoorAmbient = Color3.fromRGB(195, 195, 205)
        Lighting.GlobalShadows = false
    elseif lightSaved then
        Lighting.Brightness = lightSaved.brightness
        Lighting.Ambient = lightSaved.ambient
        Lighting.OutdoorAmbient = lightSaved.outdoor
        Lighting.GlobalShadows = lightSaved.shadows
        lightSaved = nil
    end
end

local fogSaved = nil
applyNoFog = function(on)
    if on then
        if not fogSaved then
            fogSaved = { fogEnd = Lighting.FogEnd, fogStart = Lighting.FogStart }
        end
        Lighting.FogEnd = 1e6
        Lighting.FogStart = 0
    elseif fogSaved then
        Lighting.FogEnd = fogSaved.fogEnd
        Lighting.FogStart = fogSaved.fogStart
        fogSaved = nil
    end
end

--==============================================================
--  LOGIC: VEHICLE
--==============================================================
getVehicle = function()
    local hum = getHumanoid()
    local seat = hum and hum.SeatPart
    if seat and seat:IsA("VehicleSeat") then
        return seat.Parent, seat
    end
end

local function isWheelPart(part)
    local n = part.Name:lower()
    if n:find("wheel") or n:find("tire") or n:find("tyre")
        or n:find("koles") then
        return true
    end
    for _, child in ipairs(part:GetChildren()) do
        if child:IsA("HingeConstraint") or child:IsA("CylindricalConstraint") then
            return true
        end
    end
    return false
end

local gripSaved = {}
local gripCar = nil
local gripApplied = 1

local function getGripParts(car)
    local list = {}
    for _, part in ipairs(car:GetDescendants()) do
        if part:IsA("BasePart") and isWheelPart(part) then
            list[#list + 1] = part
        end
    end
    if #list == 0 then
        for _, part in ipairs(car:GetDescendants()) do
            if part:IsA("BasePart") and part.CanCollide then
                list[#list + 1] = part
            end
        end
    end
    return list
end

local function captureGrip(car)
    gripSaved = {}
    for _, part in ipairs(getGripParts(car)) do
        local p = part.CustomPhysicalProperties
        gripSaved[part] = {
            had = p ~= nil,
            density = p and p.Density or 0.7,
            friction = p and p.Friction or 0.5,
            elasticity = p and p.Elasticity or 0.2,
            fw = p and p.FrictionWeight or 1,
            ew = p and p.ElasticityWeight or 1,
        }
    end
end

local function applyGrip(factor)
    if math.abs(factor - gripApplied) < 0.02 then return end
    gripApplied = factor
    for part, saved in pairs(gripSaved) do
        if part.Parent then
            pcall(function()
                part.CustomPhysicalProperties = PhysicalProperties.new(
                    saved.density,
                    math.clamp(saved.friction * factor, 0.02, 2),
                    saved.elasticity,
                    saved.fw,
                    saved.ew
                )
            end)
        end
    end
end

restoreGrip = function()
    for part, saved in pairs(gripSaved) do
        if part.Parent then
            pcall(function()
                if saved.had then
                    part.CustomPhysicalProperties = PhysicalProperties.new(
                        saved.density, saved.friction, saved.elasticity, saved.fw, saved.ew
                    )
                else
                    part.CustomPhysicalProperties = nil
                end
            end)
        end
    end
    gripSaved = {}
    gripApplied = 1
    gripCar = nil
end

local rayParams = RaycastParams.new()
do
    local ok, kind = pcall(function()
        return Enum.RaycastFilterType.Exclude
    end)
    rayParams.FilterType = ok and kind or Enum.RaycastFilterType.Blacklist
end
rayParams.IgnoreWater = true

local wheelCacheCar, wheelCacheAt, wheelCacheList = nil, 0, {}
local function getWheels(car)
    local now = os.clock()
    if wheelCacheCar ~= car or now - wheelCacheAt > 2 then
        wheelCacheList = {}
        for _, part in ipairs(car:GetDescendants()) do
            if part:IsA("BasePart") and isWheelPart(part) then
                wheelCacheList[#wheelCacheList + 1] = part
            end
        end
        wheelCacheCar = car
        wheelCacheAt = now
    end
    return wheelCacheList
end

local trackTimes = {}
local function placeTrack(wheel, forward)
    local result = workspace:Raycast(wheel.Position, Vector3.new(0, -10, 0), rayParams)
    if not result then return end
    local up = result.Normal
    local flat = forward - up * forward:Dot(up)
    if flat.Magnitude < 0.01 then return end
    flat = flat.Unit
    local right = flat:Cross(up)

    local mark = Instance.new("Part")
    mark.Size = Vector3.new(0.55, 0.04, 1.25)
    mark.CFrame = CFrame.fromMatrix(result.Position + up * 0.02, right, up, -flat)
    mark.Anchored = true
    mark.CanCollide = false
    mark.CanQuery = false
    mark.CanTouch = false
    mark.CastShadow = false
    mark.Material = Enum.Material.SmoothPlastic
    mark.Color = Color3.fromRGB(18, 18, 22)
    mark.Transparency = 0.25
    mark.Parent = workspace

    TweenService:Create(
        mark,
        TweenInfo.new(4, Enum.EasingStyle.Linear, Enum.EasingDirection.Out, 0, false, 0.7),
        { Transparency = 1 }
    ):Play()
    Debris:AddItem(mark, 5)
end

local driftBlend = 0
local lastJump = 0
local vehicleWarned = false

connect(RunService.Stepped, function(_, dt)
    dt = math.clamp(dt or 0, 0, 0.1)

    local car, seat = getVehicle()
    if not car or not seat then
        if gripCar then restoreGrip() end
        driftBlend = 0
        return
    end

    local ok, err = pcall(function()
        local root = seat.AssemblyRootPart
            or car.PrimaryPart
            or car:FindFirstChildWhichIsA("BasePart")
        if not root then return end

        local look = seat.CFrame.LookVector
        local fwd = Vector3.new(look.X, 0, look.Z)
        if fwd.Magnitude < 0.05 then
            look = root.CFrame.LookVector
            fwd = Vector3.new(look.X, 0, look.Z)
        end
        if fwd.Magnitude < 0.05 then return end
        fwd = fwd.Unit

        local vel = root.AssemblyLinearVelocity
        local flatVel = Vector3.new(vel.X, 0, vel.Z)
        local speed = flatVel.Magnitude
        local steer = (UIS:IsKeyDown(Enum.KeyCode.D) and 1 or 0)
            - (UIS:IsKeyDown(Enum.KeyCode.A) and 1 or 0)

        if UIS:IsKeyDown(Enum.KeyCode.W) and speed < S.maxSpeed then
            local add = math.min(70 * S.accel * dt, S.maxSpeed - speed)
            vel = vel + fwd * add
            root.AssemblyLinearVelocity = vel
            flatVel = Vector3.new(vel.X, 0, vel.Z)
            speed = flatVel.Magnitude
        end

        if speed > S.maxSpeed then
            local capped = flatVel.Unit * S.maxSpeed
            vel = Vector3.new(capped.X, vel.Y, capped.Z)
            root.AssemblyLinearVelocity = vel
            flatVel = capped
            speed = S.maxSpeed
        end

        local right = Vector3.new(-fwd.Z, 0, fwd.X)
        local fSpeed = flatVel:Dot(fwd)
        local lSpeed = flatVel:Dot(right)

        local drifting = S.drift and speed > 18 and fSpeed > 6 and steer ~= 0
        local targetBlend = drifting and 1 or 0
        driftBlend = driftBlend + (targetBlend - driftBlend)
            * math.min(1, (drifting and 7 or 6) * dt)

        if S.drift then
            if gripCar ~= car then
                if gripCar then restoreGrip() end
                gripCar = car
                captureGrip(car)
                gripApplied = 1
            end
            applyGrip(1 - (1 - S.driftGrip) * driftBlend)
        elseif gripCar then
            restoreGrip()
        end

        if driftBlend > 0.01 and speed > 2 then
            local slipAngle = math.rad(S.driftAngle) * driftBlend
            local desiredLateral = -steer * fSpeed * math.tan(slipAngle)
            local cap = speed * 0.8
            desiredLateral = math.clamp(desiredLateral, -cap, cap)

            local blend = math.min(1, 5 * dt)
            lSpeed = lSpeed + (desiredLateral - lSpeed) * blend
            fSpeed = fSpeed * (1 - math.min(1, 0.2 * dt * driftBlend))

            root.AssemblyLinearVelocity = fwd * fSpeed + right * lSpeed
                + Vector3.new(0, vel.Y, 0)

            local turn = -steer * math.clamp(speed * 0.02, 0.5, 1.5) * driftBlend
            local av = root.AssemblyAngularVelocity
            root.AssemblyAngularVelocity = Vector3.new(
                av.X,
                av.Y + (turn - av.Y) * math.min(1, 10 * dt),
                av.Z
            )
        elseif S.antiDrift and speed > 2 then
            lSpeed = lSpeed * math.clamp(1 - 14 * dt, 0, 1)
            root.AssemblyLinearVelocity = fwd * fSpeed + right * lSpeed
                + Vector3.new(0, vel.Y, 0)

            local av = root.AssemblyAngularVelocity
            root.AssemblyAngularVelocity = Vector3.new(
                av.X,
                av.Y * math.clamp(1 - 10 * dt, 0, 1),
                av.Z
            )
        end

        if S.carFly then
            local y = 0
            if UIS:IsKeyDown(Enum.KeyCode.Space) then
                y = S.carFlySpeed
            elseif UIS:IsKeyDown(Enum.KeyCode.LeftControl) then
                y = -S.carFlySpeed
            end
            local cur = root.AssemblyLinearVelocity
            root.AssemblyLinearVelocity = Vector3.new(cur.X, y, cur.Z)
        end

        local current = root.AssemblyLinearVelocity
        local currentSpeed = Vector3.new(current.X, 0, current.Z).Magnitude

        if S.tracks and currentSpeed > 25 then
            local now = os.clock()
            local filter = { car }
            if LP.Character then filter[#filter + 1] = LP.Character end
            rayParams.FilterDescendantsInstances = filter

            for _, part in ipairs(getWheels(car)) do
                if part:IsDescendantOf(workspace)
                    and now - (trackTimes[part] or 0) > 0.07 then
                    trackTimes[part] = now
                    placeTrack(part, fwd)
                end
            end
        end
    end)

    if not ok and not vehicleWarned then
        vehicleWarned = true
        warn("[Solar] vehicle error: " .. tostring(err))
    end
end)

--==============================================================
--  AUTO FARM
--==============================================================
local farmData = nil
local farmStatAccum = 0
local farmStatTimer = 0

local function clearFarmPlatform()
    if farmData and farmData.parts then
        for _, part in ipairs(farmData.parts) do
            if part and part.Parent then part:Destroy() end
        end
    end
    farmData = nil
end

stopFarm = function()
    if farmData and farmData.root and farmData.root.Parent and farmData.origCF then
        pcall(function()
            farmData.root.CFrame = farmData.origCF
            farmData.root.AssemblyLinearVelocity = Vector3.zero
            farmData.root.AssemblyAngularVelocity = Vector3.zero
        end)
    end
    clearFarmPlatform()
    if farmStatus then
        farmStatus.Text = "Auto farm stopped."
        farmStatus.TextColor3 = C.sub
    end
end

startFarm = function()
    local car, seat = getVehicle()
    if not car or not seat then
        if farmStatus then
            farmStatus.Text = "Get in a car first."
            farmStatus.TextColor3 = C.red
        end
        if Toggles.autoFarm then Toggles.autoFarm.set(false) end
        return
    end

    local root = seat.AssemblyRootPart
        or car.PrimaryPart
        or car:FindFirstChildWhichIsA("BasePart")
    if not root then
        if farmStatus then
            farmStatus.Text = "Car root part not found."
            farmStatus.TextColor3 = C.red
        end
        if Toggles.autoFarm then Toggles.autoFarm.set(false) end
        return
    end

    clearFarmPlatform()

    local base = root.CFrame
    local fwd = Vector3.new(base.LookVector.X, 0, base.LookVector.Z)
    if fwd.Magnitude < 0.1 then fwd = Vector3.new(0, 0, -1) end
    fwd = fwd.Unit

    local origin = Vector3.new(root.Position.X, root.Position.Y + 260, root.Position.Z)
    local cf = CFrame.lookAt(origin, origin + fwd)

    local platform = Instance.new("Part")
    platform.Name = "SolarFarmPlatform"
    platform.Size = Vector3.new(4200, 4, 220)
    platform.CFrame = cf
    platform.Anchored = true
    platform.CanCollide = true
    platform.Material = Enum.Material.SmoothPlastic
    platform.Color = Color3.fromRGB(22, 15, 40)
    platform.TopSurface = Enum.SurfaceType.Smooth
    platform.BottomSurface = Enum.SurfaceType.Smooth
    platform.Parent = workspace

    local glow = Instance.new("Part")
    glow.Name = "SolarFarmGlow"
    glow.Size = Vector3.new(4200, 0.6, 224)
    glow.CFrame = cf * CFrame.new(0, 2.2, 0)
    glow.Anchored = true
    glow.CanCollide = false
    glow.CanQuery = false
    glow.Material = Enum.Material.Neon
    glow.Color = Color3.fromRGB(146, 92, 255)
    glow.Transparency = 0.55
    glow.Parent = workspace

    local startCF = cf * CFrame.new(-1950, 8, 0)
    local origCF = root.CFrame
    root.CFrame = startCF
    root.AssemblyLinearVelocity = Vector3.zero
    root.AssemblyAngularVelocity = Vector3.zero

    farmData = {
        car = car,
        root = root,
        origCF = origCF,
        startCF = startCF,
        startPos = startCF.Position,
        dir = fwd,
        baseY = origin.Y,
        length = 3800,
        lastPos = startCF.Position,
        parts = { platform, glow },
    }

    if farmStatus then
        farmStatus.Text = "Farming: looping at " .. S.farmSpeed .. " studs/s."
        farmStatus.TextColor3 = C.green
    end
end

local function bumpLeaderstats(milesDelta, moneyDelta)
    local folder = LP:FindFirstChild("leaderstats")
    if not folder then return end
    for _, value in ipairs(folder:GetChildren()) do
        local n = value.Name:lower()
        local isMiles = n:find("mile") or n:find("dist") or n:find("km")
        local isMoney = n:find("money") or n:find("cash") or n:find("coin")
            or n:find("dollar") or n:find("balance")
        if (value:IsA("IntValue") or value:IsA("NumberValue")) and (isMiles or isMoney) then
            pcall(function()
                value.Value = value.Value + (isMiles and milesDelta or moneyDelta)
            end)
        end
    end
end

local function bumpPlayerAttribute(milesDelta, moneyDelta)
    for _, name in ipairs({ "Miles", "Money", "Cash", "Distance" }) do
        local ok = pcall(function()
            local current = LP:GetAttribute(name)
            if typeof(current) == "number" then
                local add = (name == "Miles" or name == "Distance") and milesDelta or moneyDelta
                LP:SetAttribute(name, current + add)
            end
        end)
        if not ok then return end
    end
end

connect(RunService.Stepped, function(_, dt)
    if not S.autoFarm or not farmData then return end

    local car = getVehicle()
    if not car or car ~= farmData.car then
        stopFarm()
        if Toggles.autoFarm then Toggles.autoFarm.set(false) end
        return
    end

    local root = farmData.root
    if not root or not root.Parent then
        stopFarm()
        if Toggles.autoFarm then Toggles.autoFarm.set(false) end
        return
    end

    local pos = root.Position
    local moved = (pos - farmData.lastPos).Magnitude
    farmData.lastPos = pos

    S.farmMiles = S.farmMiles + moved / 1000
    S.farmMoney = S.farmMoney + moved * 0.4

    farmStatAccum = farmStatAccum + moved
    farmStatTimer = farmStatTimer + dt
    if farmStatTimer > 0.5 then
        if S.writeStats and farmStatAccum > 0 then
            bumpLeaderstats(farmStatAccum / 1000, farmStatAccum * 0.4)
            bumpPlayerAttribute(farmStatAccum / 1000, farmStatAccum * 0.4)
        end
        farmStatAccum = 0
        farmStatTimer = 0
    end

    local traveled = (pos - farmData.startPos):Dot(farmData.dir)
    if traveled > farmData.length or pos.Y < farmData.baseY - 80 then
        root.CFrame = farmData.startCF
        root.AssemblyLinearVelocity = Vector3.zero
        root.AssemblyAngularVelocity = Vector3.zero
        farmData.lastPos = farmData.startCF.Position
    else
        root.AssemblyAngularVelocity = Vector3.zero
        root.AssemblyLinearVelocity = farmData.dir * S.farmSpeed
            + Vector3.new(0, -18, 0)
        root.CFrame = CFrame.lookAt(pos, pos + farmData.dir)
    end
end)

--==============================================================
--  JUMP
--==============================================================
connect(UIS.InputBegan, function(input)
    if input.KeyCode ~= Enum.KeyCode.Space then return end

    local car, seat = getVehicle()
    if car and seat and S.carJump and not S.carFly then
        local now = os.clock()
        if now - lastJump > 0.5 then
            lastJump = now
            local root = seat.AssemblyRootPart or car.PrimaryPart
            if root then
                local v = root.AssemblyLinearVelocity
                root.AssemblyLinearVelocity = Vector3.new(v.X, S.carJumpPower, v.Z)
            end
        end
        return
    end

    if S.infJump and not car then
        local hum = getHumanoid()
        local hrp = getHRP()
        if hum and hrp and hum.Health > 0 then
            local v = hrp.AssemblyLinearVelocity
            hrp.AssemblyLinearVelocity = Vector3.new(v.X, S.jumpPower, v.Z)
        end
    end
end)

--==============================================================
--  OPEN / CLOSE
--==============================================================
setMenuVisible = function(visible)
    if closing then return end
    menuVisible = visible
    if visible then
        menu.Visible = true
        fadeGroup(menu, 1)
        guiScale.Scale = baseScale * 0.95
        fadeGroup(menu, 0, TweenInfo.new(0.3, Enum.EasingStyle.Quint, Enum.EasingDirection.Out))
        TweenService:Create(guiScale, TweenInfo.new(0.4, Enum.EasingStyle.Back, Enum.EasingDirection.Out), {
            Scale = baseScale,
        }):Play()
        plateHolder.Visible = S.showPlates
    else
        fadeGroup(menu, 1, TweenInfo.new(0.2, Enum.EasingStyle.Quad, Enum.EasingDirection.In))
        TweenService:Create(guiScale, TweenInfo.new(0.2), { Scale = baseScale * 0.95 }):Play()
        plateHolder.Visible = false
        task.delay(0.22, function()
            if not menuVisible and not closing then menu.Visible = false end
        end)
    end
end

closeMenu = function()
    if closing then return end
    closing = true
    fadeGroup(menu, 1, TweenInfo.new(0.26, Enum.EasingStyle.Quad, Enum.EasingDirection.In))
    TweenService:Create(guiScale, TweenInfo.new(0.26), { Scale = baseScale * 0.94 }):Play()
    task.delay(0.3, function()
        if cleanup then cleanup() end
    end)
end

cleanup = function()
    for _, c in ipairs(Connections) do
        pcall(function() c:Disconnect() end)
    end
    Connections = {}
    if stopFarm then stopFarm() end
    if restoreGrip then restoreGrip() end
    if restoreNoclip then restoreNoclip() end
    if lightSaved and applyFullbright then applyFullbright(false) end
    if fogSaved and applyNoFog then applyNoFog(false) end
    local hum = getHumanoid()
    if hum then hum.PlatformStand = false end
    if gui then gui:Destroy() end
    env.SolarCleanup = nil
end
env.SolarCleanup = cleanup

connect(UIS.InputBegan, function(input, processed)
    if processed then return end
    if input.KeyCode == Enum.KeyCode.RightShift then
        setMenuVisible(not menuVisible)
    end
end)

refreshScale()
local cam = workspace.CurrentCamera
if cam then
    connect(cam:GetPropertyChangedSignal("ViewportSize"), refreshScale)
end
connect(workspace:GetPropertyChangedSignal("CurrentCamera"), function()
    local c = workspace.CurrentCamera
    if c then
        c:GetPropertyChangedSignal("ViewportSize"):Connect(refreshScale)
    end
    refreshScale()
end)

playSplash(function()
    menu.Visible = true
    fadeGroup(menu, 1)
    guiScale.Scale = baseScale * 0.9
    fadeGroup(menu, 0, TweenInfo.new(0.45, Enum.EasingStyle.Quint, Enum.EasingDirection.Out))
    TweenService:Create(guiScale, TweenInfo.new(0.55, Enum.EasingStyle.Back, Enum.EasingDirection.Out), {
        Scale = baseScale,
    }):Play()
    plateHolder.Visible = S.showPlates
    plateHolder.Position = UDim2.new(1, -18, 0, 78)
    TweenService:Create(plateHolder, TweenInfo.new(0.5, Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
        Position = UDim2.new(1, -18, 0, 96),
    }):Play()
end)