-- ============================================================
-- CYBER RUN V2 | UPGRADED | LocalScript
-- Place in StarterPlayer > StarterPlayerScripts
-- ============================================================

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local TweenService = game:GetService("TweenService")
local UserInputService = game:GetService("UserInputService")

local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
local rootPart = character:WaitForChild("HumanoidRootPart")

-- ============================================================
-- SETTINGS
-- ============================================================
local CONFIG = {
    SPEED_NORMAL           = 16,
    SPEED_BOOST            = 90,
    AFTERIMAGE_INTERVAL    = 0.045,
    AFTERIMAGE_LIFETIME    = 0.55,
    AFTERIMAGE_START_ALPHA = 0.35,   -- Starting transparency (lower = more visible)
    AFTERIMAGE_STEPS       = 20,
    MIN_VELOCITY           = 4,
    FOV_NORMAL             = 70,
    FOV_BOOST              = 88,
    FOV_TWEEN_TIME         = 0.4,
    MAX_AFTERIMAGES        = 40,
    SPARK_INTERVAL         = 0.07,
}

-- ============================================================
-- STATE
-- ============================================================
local cyberActive       = false
local lastAfterimage    = 0
local activeAfterimages = 0
local sparkTimer        = 0
local camera            = workspace.CurrentCamera

-- ============================================================
-- UTILITY
-- ============================================================
local function tweenFOV(target)
    TweenService:Create(
        camera,
        TweenInfo.new(CONFIG.FOV_TWEEN_TIME, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
        { FieldOfView = target }
    ):Play()
end

-- ============================================================
-- AFTER IMAGE SYSTEM (IMPROVED - LOOKS LIKE THE PLAYER)
-- ============================================================
local afterimageFolder = Instance.new("Folder")
afterimageFolder.Name  = "CyberRunAfterimages"
afterimageFolder.Parent = workspace

local function getPartAppearance(part)
    -- Returns a table of appearance data to apply to clone
    local data = {
        color        = part.Color,
        material     = part.Material,
        transparency = part.Transparency,
        size         = part.Size,
        cframe       = part.CFrame,
        castShadow   = false,
        anchored     = true,
        canCollide   = false,
    }
    return data
end

local function copyMeshes(source, target)
    for _, child in ipairs(source:GetChildren()) do
        if child:IsA("SpecialMesh")
        or child:IsA("BlockMesh")
        or child:IsA("CylinderMesh") then
            child:Clone().Parent = target
        end
    end
end

local function copyTextures(source, target)
    for _, child in ipairs(source:GetChildren()) do
        if child:IsA("Texture")
        or child:IsA("Decal") then
            child:Clone().Parent = target
        end
    end
end

local function createAfterImage()
    if activeAfterimages >= CONFIG.MAX_AFTERIMAGES then return end
    activeAfterimages += 1

    local snapshot = {}

    -- Snapshot all parts BEFORE creating anything
    -- This ensures the afterimage matches exact position at that frame
    for _, part in ipairs(character:GetDescendants()) do
        if part:IsA("BasePart") and part.Name ~= "HumanoidRootPart" then
            local baseTransparency = part.Transparency

            -- Skip already invisible parts
            if baseTransparency >= 0.99 then continue end

            table.insert(snapshot, {
                part             = part,
                cframe           = part.CFrame,
                size             = part.Size,
                color            = part.Color,
                material         = part.Material,
                transparency     = math.max(baseTransparency, CONFIG.AFTERIMAGE_START_ALPHA),
                originalTransparency = baseTransparency,
            })
        end
    end

    -- Build the model from snapshot
    local model = Instance.new("Model")
    model.Name  = "Afterimage"
    model.Parent = afterimageFolder

    local clones = {}

    for _, data in ipairs(snapshot) do
        local clone = Instance.new("Part")
        clone.Name         = data.part.Name
        clone.Size         = data.size
        clone.CFrame       = data.cframe
        clone.Anchored     = true
        clone.CanCollide   = false
        clone.CastShadow   = false
        clone.Material     = data.material
        clone.Color        = data.color
        clone.Transparency = data.transparency
        clone.Parent       = model

        -- Copy meshes so accessories and limbs look correct
        copyMeshes(data.part, clone)
        copyTextures(data.part, clone)

        -- Copy shirts/pants surface appearance
        for _, child in ipairs(data.part:GetChildren()) do
            if child:IsA("SurfaceAppearance")
            or child:IsA("WrapLayer")
            or child:IsA("SpecialMesh") then
                pcall(function() child:Clone().Parent = clone end)
            end
        end

        table.insert(clones, { clone = clone, baseTransparency = data.transparency })
    end

    -- Smooth fade using TweenService
    -- Each clone fades to fully transparent over AFTERIMAGE_LIFETIME
    for _, entry in ipairs(clones) do
        local clone = entry.clone
        local tweenInfo = TweenInfo.new(
            CONFIG.AFTERIMAGE_LIFETIME,
            Enum.EasingStyle.Quad,
            Enum.EasingDirection.In
        )
        TweenService:Create(clone, tweenInfo, {
            Transparency = 1
        }):Play()
    end

    -- Destroy after lifetime
    task.delay(CONFIG.AFTERIMAGE_LIFETIME + 0.05, function()
        model:Destroy()
        activeAfterimages = math.max(0, activeAfterimages - 1)
    end)
end

-- ============================================================
-- GROUND SPARKS (Subtle - Cyan/White only)
-- ============================================================
local function spawnGroundSpark()
    if not rootPart then return end

    local sparkColors = {
        Color3.fromRGB(0,   210, 255),
        Color3.fromRGB(180, 230, 255),
        Color3.fromRGB(255, 255, 255),
        Color3.fromRGB(100, 200, 255),
    }

    local count = math.random(1, 3)
    for _ = 1, count do
        local spark = Instance.new("Part")
        spark.Size         = Vector3.new(
            math.random(5, 15) / 100,
            math.random(5, 15) / 100,
            math.random(5, 15) / 100
        )
        spark.Shape        = Enum.PartType.Ball
        spark.Material     = Enum.Material.Neon
        spark.Color        = sparkColors[math.random(1, #sparkColors)]
        spark.Anchored     = false
        spark.CanCollide   = false
        spark.CastShadow   = false
        spark.CFrame       = rootPart.CFrame * CFrame.new(
            math.random(-20, 20) / 10,
            -2.8,
            math.random(-10, 10) / 10
        )
        spark.AssemblyLinearVelocity = Vector3.new(
            math.random(-6, 6),
            math.random(1, 6),
            math.random(-6, 6)
        )
        spark.Parent = workspace

        TweenService:Create(spark, TweenInfo.new(
            math.random(20, 40) / 100,
            Enum.EasingStyle.Quad
        ), {
            Transparency = 1,
            Size = Vector3.new(0.01, 0.01, 0.01)
        }):Play()

        game:GetService("Debris"):AddItem(spark, 0.4)
    end
end

-- ============================================================
-- SPEED LINES (Screen Space)
-- ============================================================
local speedLinesGui = Instance.new("ScreenGui")
speedLinesGui.Name          = "SpeedLinesGui"
speedLinesGui.ResetOnSpawn  = false
speedLinesGui.IgnoreGuiInset = true
speedLinesGui.DisplayOrder  = 5
speedLinesGui.Parent        = player.PlayerGui

local speedLineObjects = {}

for i = 1, 14 do
    local line = Instance.new("Frame")
    line.BackgroundColor3   = Color3.fromRGB(200, 240, 255)
    line.BorderSizePixel    = 0
    line.BackgroundTransparency = 1
    line.ZIndex             = 2
    line.Parent             = speedLinesGui

    local uiCorner = Instance.new("UICorner")
    uiCorner.CornerRadius = UDim.new(1, 0)
    uiCorner.Parent = line

    table.insert(speedLineObjects, line)
end

local function flashSpeedLines()
    for i, line in ipairs(speedLineObjects) do
        local angle   = ((i - 1) / #speedLineObjects) * 360 + math.random(-10, 10)
        local rad     = math.rad(angle)
        local dist    = math.random(90, 210)
        local length  = math.random(50, 160)
        local thick   = math.random(1, 3)

        line.Size     = UDim2.new(0, thick, 0, length)
        line.Position = UDim2.new(
            0.5, math.cos(rad) * dist - thick / 2,
            0.5, math.sin(rad) * dist - length / 2
        )
        line.Rotation             = angle + 90
        line.BackgroundTransparency = math.random(20, 50) / 100

        TweenService:Create(line, TweenInfo.new(0.12, Enum.EasingStyle.Linear), {
            BackgroundTransparency = 1
        }):Play()
    end
end

local function hideSpeedLines()
    for _, line in ipairs(speedLineObjects) do
        line.BackgroundTransparency = 1
    end
end

-- ============================================================
-- BUILD MAIN GUI
-- ============================================================
local screenGui = Instance.new("ScreenGui")
screenGui.Name           = "CyberRunV2Gui"
screenGui.ResetOnSpawn   = false
screenGui.IgnoreGuiInset = true
screenGui.DisplayOrder   = 10
screenGui.Parent         = player.PlayerGui

-- Vignette glow (edge darkening when active)
local vignette = Instance.new("ImageLabel")
vignette.Name               = "Vignette"
vignette.Size               = UDim2.new(1, 0, 1, 0)
vignette.BackgroundTransparency = 1
vignette.Image              = "rbxassetid://7145294030"
vignette.ImageColor3        = Color3.fromRGB(0, 180, 255)
vignette.ImageTransparency  = 1
vignette.ScaleType          = Enum.ScaleType.Stretch
vignette.ZIndex             = 2
vignette.Parent             = screenGui

-- ============================================================
-- BUTTON CONTAINER
-- ============================================================
local buttonContainer = Instance.new("Frame")
buttonContainer.Name                = "ButtonContainer"
buttonContainer.Size                = UDim2.new(0, 230, 0, 82)
buttonContainer.Position            = UDim2.new(0.5, -115, 1, -108)
buttonContainer.BackgroundTransparency = 1
buttonContainer.ZIndex              = 10
buttonContainer.Parent              = screenGui

-- Outer glow image behind button
local glowBehind = Instance.new("ImageLabel")
glowBehind.Size               = UDim2.new(1, 60, 1, 60)
glowBehind.Position           = UDim2.new(0, -30, 0, -30)
glowBehind.BackgroundTransparency = 1
glowBehind.Image              = "rbxassetid://5028857084"
glowBehind.ImageColor3        = Color3.fromRGB(0, 180, 255)
glowBehind.ImageTransparency  = 0.65
glowBehind.ZIndex             = 9
glowBehind.ScaleType          = Enum.ScaleType.Slice
glowBehind.SliceCenter        = Rect.new(24, 24, 276, 276)
glowBehind.Parent             = buttonContainer

-- Main Button
local mainButton = Instance.new("TextButton")
mainButton.Name              = "MainButton"
mainButton.Size              = UDim2.new(1, 0, 1, 0)
mainButton.BackgroundColor3  = Color3.fromRGB(8, 8, 22)
mainButton.BorderSizePixel   = 0
mainButton.Text              = ""
mainButton.AutoButtonColor   = false
mainButton.ZIndex            = 10
mainButton.Parent            = buttonContainer

local mainCorner = Instance.new("UICorner")
mainCorner.CornerRadius = UDim.new(0, 14)
mainCorner.Parent       = mainButton

-- Inner gradient
local innerGradient = Instance.new("UIGradient")
innerGradient.Color = ColorSequence.new({
    ColorSequenceKeypoint.new(0, Color3.fromRGB(18, 18, 45)),
    ColorSequenceKeypoint.new(1, Color3.fromRGB(6,  6,  18)),
})
innerGradient.Rotation = 90
innerGradient.Parent   = mainButton

-- Border stroke
local borderStroke = Instance.new("UIStroke")
borderStroke.Color       = Color3.fromRGB(0, 200, 255)
borderStroke.Thickness   = 2
borderStroke.Transparency = 0
borderStroke.Parent      = mainButton

-- Top highlight line
local topLine = Instance.new("Frame")
topLine.Size              = UDim2.new(0.6, 0, 0, 1)
topLine.Position          = UDim2.new(0.2, 0, 0, 3)
topLine.BackgroundColor3  = Color3.fromRGB(150, 230, 255)
topLine.BorderSizePixel   = 0
topLine.BackgroundTransparency = 0.4
topLine.ZIndex            = 12
topLine.Parent            = mainButton

local topLineCorner = Instance.new("UICorner")
topLineCorner.CornerRadius = UDim.new(1, 0)
topLineCorner.Parent       = topLine

-- Lightning Icon
local iconLabel = Instance.new("TextLabel")
iconLabel.Size               = UDim2.new(0, 36, 0, 36)
iconLabel.Position           = UDim2.new(0, 10, 0.5, -18)
iconLabel.BackgroundTransparency = 1
iconLabel.Text               = "⚡"
iconLabel.TextSize           = 24
iconLabel.Font               = Enum.Font.GothamBold
iconLabel.TextColor3         = Color3.fromRGB(0, 220, 255)
iconLabel.ZIndex             = 11
iconLabel.Parent             = mainButton

-- Divider line between icon and text
local divider = Instance.new("Frame")
divider.Size              = UDim2.new(0, 1, 0.6, 0)
divider.Position          = UDim2.new(0, 50, 0.2, 0)
divider.BackgroundColor3  = Color3.fromRGB(0, 180, 255)
divider.BackgroundTransparency = 0.6
divider.BorderSizePixel   = 0
divider.ZIndex            = 11
divider.Parent            = mainButton

-- Title Text
local titleText = Instance.new("TextLabel")
titleText.Name               = "TitleText"
titleText.Size               = UDim2.new(1, -120, 0, 26)
titleText.Position           = UDim2.new(0, 58, 0, 10)
titleText.BackgroundTransparency = 1
titleText.Text               = "CYBER RUN"
titleText.TextColor3         = Color3.fromRGB(0, 220, 255)
titleText.TextSize           = 17
titleText.Font               = Enum.Font.GothamBold
titleText.TextXAlignment     = Enum.TextXAlignment.Left
titleText.ZIndex             = 11
titleText.Parent             = mainButton

-- Sub text / status
local statusText = Instance.new("TextLabel")
statusText.Name              = "StatusText"
statusText.Size              = UDim2.new(1, -120, 0, 18)
statusText.Position          = UDim2.new(0, 59, 0, 34)
statusText.BackgroundTransparency = 1
statusText.Text              = "V2  ·  OFFLINE"
statusText.TextColor3        = Color3.fromRGB(85, 90, 120)
statusText.TextSize          = 11
statusText.Font              = Enum.Font.Gotham
statusText.TextXAlignment    = Enum.TextXAlignment.Left
statusText.ZIndex            = 11
statusText.Parent            = mainButton

-- V2 Badge
local badge = Instance.new("Frame")
badge.Size             = UDim2.new(0, 30, 0, 17)
badge.Position         = UDim2.new(1, -42, 0, 9)
badge.BackgroundColor3 = Color3.fromRGB(0, 185, 255)
badge.BorderSizePixel  = 0
badge.ZIndex           = 12
badge.Parent           = mainButton

local badgeCorner = Instance.new("UICorner")
badgeCorner.CornerRadius = UDim.new(0, 5)
badgeCorner.Parent = badge

local badgeText = Instance.new("TextLabel")
badgeText.Size               = UDim2.new(1, 0, 1, 0)
badgeText.BackgroundTransparency = 1
badgeText.Text               = "V2"
badgeText.TextColor3         = Color3.fromRGB(0, 0, 10)
badgeText.TextSize           = 10
badgeText.Font               = Enum.Font.GothamBold
badgeText.ZIndex             = 13
badgeText.Parent             = badge

-- Speed Bar background
local speedBarBg = Instance.new("Frame")
speedBarBg.Size             = UDim2.new(1, -20, 0, 4)
speedBarBg.Position         = UDim2.new(0, 10, 1, -11)
speedBarBg.BackgroundColor3 = Color3.fromRGB(18, 18, 38)
speedBarBg.BorderSizePixel  = 0
speedBarBg.ZIndex           = 11
speedBarBg.Parent           = mainButton

local sbbCorner = Instance.new("UICorner")
sbbCorner.CornerRadius = UDim.new(1, 0)
sbbCorner.Parent = speedBarBg

-- Speed Bar fill
local speedBarFill = Instance.new("Frame")
speedBarFill.Name            = "Fill"
speedBarFill.Size            = UDim2.new(0, 0, 1, 0)
speedBarFill.BackgroundColor3 = Color3.fromRGB(0, 200, 255)
speedBarFill.BorderSizePixel = 0
speedBarFill.ZIndex          = 12
speedBarFill.Parent          = speedBarBg

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

local fillGradient = Instance.new("UIGradient")
fillGradient.Color = ColorSequence.new({
    ColorSequenceKeypoint.new(0,   Color3.fromRGB(0,   200, 255)),
    ColorSequenceKeypoint.new(0.5, Color3.fromRGB(80,  120, 255)),
    ColorSequenceKeypoint.new(1,   Color3.fromRGB(160, 0,   255)),
})
fillGradient.Parent = speedBarFill

-- Speed bar glow dot at end
local barDot = Instance.new("Frame")
barDot.Size             = UDim2.new(0, 6, 0, 6)
barDot.AnchorPoint      = Vector2.new(0.5, 0.5)
barDot.Position         = UDim2.new(0, 0, 0.5, 0)
barDot.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
barDot.BorderSizePixel  = 0
barDot.ZIndex           = 13
barDot.Visible          = false
barDot.Parent           = speedBarFill

local dotCorner = Instance.new("UICorner")
dotCorner.CornerRadius = UDim.new(1, 0)
dotCorner.Parent = barDot

-- ============================================================
-- TOGGLE VISUAL STATES
-- ============================================================
local barTween = nil

local function setActiveVisuals(active)
    if active then
        -- Button
        TweenService:Create(mainButton, TweenInfo.new(0.3, Enum.EasingStyle.Quad), {
            BackgroundColor3 = Color3.fromRGB(4, 16, 34)
        }):Play()

        -- Stroke
        TweenService:Create(borderStroke, TweenInfo.new(0.3), {
            Color     = Color3.fromRGB(0, 255, 190),
            Thickness = 2.5
        }):Play()

        -- Glow
        TweenService:Create(glowBehind, TweenInfo.new(0.35), {
            ImageColor3        = Color3.fromRGB(0, 255, 160),
            ImageTransparency  = 0.25
        }):Play()

        -- Title
        TweenService:Create(titleText, TweenInfo.new(0.3), {
            TextColor3 = Color3.fromRGB(0, 255, 200)
        }):Play()

        -- Icon
        TweenService:Create(iconLabel, TweenInfo.new(0.3), {
            TextColor3 = Color3.fromRGB(0, 255, 180)
        }):Play()

        -- Gradient update
        innerGradient.Color = ColorSequence.new({
            ColorSequenceKeypoint.new(0, Color3.fromRGB(0, 22, 45)),
            ColorSequenceKeypoint.new(1, Color3.fromRGB(0, 8,  22)),
        })

        -- Status text
        statusText.Text      = "V2  ·  ONLINE  ⚡"
        statusText.TextColor3 = Color3.fromRGB(0, 230, 160)

        -- Badge color
        TweenService:Create(badge, TweenInfo.new(0.3), {
            BackgroundColor3 = Color3.fromRGB(0, 230, 160)
        }):Play()

        -- Speed bar fill
        barDot.Visible = true
        if barTween then barTween:Cancel() end
        barTween = TweenService:Create(speedBarFill, TweenInfo.new(0.5, Enum.EasingStyle.Back, Enum.EasingDirection.Out), {
            Size = UDim2.new(1, 0, 1, 0)
        })
        barTween:Play()
        barTween.Completed:Connect(function()
            barDot.Position = UDim2.new(1, -3, 0.5, 0)
        end)

        -- Vignette
        TweenService:Create(vignette, TweenInfo.new(0.4), {
            ImageTransparency = 0.82
        }):Play()

        -- Activate FOV
        tweenFOV(CONFIG.FOV_BOOST)

    else
        -- Button
        TweenService:Create(mainButton, TweenInfo.new(0.35, Enum.EasingStyle.Quad), {
            BackgroundColor3 = Color3.fromRGB(8, 8, 22)
        }):Play()

        -- Stroke
        TweenService:Create(borderStroke, TweenInfo.new(0.35), {
            Color     = Color3.fromRGB(0, 200, 255),
            Thickness = 2
        }):Play()

        -- Glow
        TweenService:Create(glowBehind, TweenInfo.new(0.35), {
            ImageColor3       = Color3.fromRGB(0, 180, 255),
            ImageTransparency = 0.65
        }):Play()

        -- Title
        TweenService:Create(titleText, TweenInfo.new(0.35), {
            TextColor3 = Color3.fromRGB(0, 220, 255)
        }):Play()

        -- Icon
        TweenService:Create(iconLabel, TweenInfo.new(0.35), {
            TextColor3 = Color3.fromRGB(0, 220, 255)
        }):Play()

        -- Gradient
        innerGradient.Color = ColorSequence.new({
            ColorSequenceKeypoint.new(0, Color3.fromRGB(18, 18, 45)),
            ColorSequenceKeypoint.new(1, Color3.fromRGB(6,  6,  18)),
        })

        -- Status
        statusText.Text       = "V2  ·  OFFLINE"
        statusText.TextColor3 = Color3.fromRGB(85, 90, 120)

        -- Badge
        TweenService:Create(badge, TweenInfo.new(0.35), {
            BackgroundColor3 = Color3.fromRGB(0, 185, 255)
        }):Play()

        -- Speed bar drain
        barDot.Visible = false
        if barTween then barTween:Cancel() end
        barTween = TweenService:Create(speedBarFill, TweenInfo.new(0.4, Enum.EasingStyle.Quad, Enum.EasingDirection.In), {
            Size = UDim2.new(0, 0, 1, 0)
        })
        barTween:Play()

        -- Vignette off
        TweenService:Create(vignette, TweenInfo.new(0.4), {
            ImageTransparency = 1
        }):Play()

        -- Reset FOV
        tweenFOV(CONFIG.FOV_NORMAL)

        -- Hide speed lines
        hideSpeedLines()
    end
end

-- ============================================================
-- IDLE BORDER PULSE
-- ============================================================
task.spawn(function()
    while true do
        task.wait(1.1)
        if not cyberActive then
            TweenService:Create(borderStroke, TweenInfo.new(0.9, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut), {
                Transparency = 0.65
            }):Play()
            task.wait(0.9)
            TweenService:Create(borderStroke, TweenInfo.new(0.9, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut), {
                Transparency = 0
            }):Play()
        else
            TweenService:Create(borderStroke, TweenInfo.new(0.25, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut), {
                Transparency = 0.55
            }):Play()
            task.wait(0.25)
            TweenService:Create(borderStroke, TweenInfo.new(0.25, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut), {
                Transparency = 0
            }):Play()
            task.wait(0.25)
        end
    end
end)

-- ============================================================
-- TOGGLE FUNCTION
-- ============================================================
local function toggleCyberRun()
    cyberActive = not cyberActive
    humanoid.WalkSpeed = cyberActive and CONFIG.SPEED_BOOST or CONFIG.SPEED_NORMAL
    setActiveVisuals(cyberActive)

    -- Button press bounce
    TweenService:Create(buttonContainer, TweenInfo.new(0.08), {
        Size = UDim2.new(0, 220, 0, 78)
    }):Play()
    task.delay(0.08, function()
        TweenService:Create(buttonContainer, TweenInfo.new(0.18, Enum.EasingStyle.Back, Enum.EasingDirection.Out), {
            Size = UDim2.new(0, 230, 0, 82)
        }):Play()
    end)
end

-- ============================================================
-- BUTTON INTERACTIONS
-- ============================================================
mainButton.MouseButton1Click:Connect(toggleCyberRun)

mainButton.MouseEnter:Connect(function()
    TweenService:Create(glowBehind, TweenInfo.new(0.2), {
        ImageTransparency = cyberActive and 0.2 or 0.5
    }):Play()
    TweenService:Create(buttonContainer, TweenInfo.new(0.15), {
        Size     = UDim2.new(0, 235, 0, 85),
        Position = UDim2.new(0.5, -117, 1, -111)
    }):Play()
end)

mainButton.MouseLeave:Connect(function()
    TweenService:Create(glowBehind, TweenInfo.new(0.2), {
        ImageTransparency = cyberActive and 0.25 or 0.65
    }):Play()
    TweenService:Create(buttonContainer, TweenInfo.new(0.15), {
        Size     = UDim2.new(0, 230, 0, 82),
        Position = UDim2.new(0.5, -115, 1, -108)
    }):Play()
end)

mainButton.MouseButton1Down:Connect(function()
    TweenService:Create(buttonContainer, TweenInfo.new(0.07), {
        Size = UDim2.new(0, 222, 0, 78)
    }):Play()
end)

mainButton.MouseButton1Up:Connect(function()
    TweenService:Create(buttonContainer, TweenInfo.new(0.14, Enum.EasingStyle.Back), {
        Size = UDim2.new(0, 230, 0, 82)
    }):Play()
end)

-- ============================================================
-- KEYBOARD SHORTCUT
-- ============================================================
UserInputService.InputBegan:Connect(function(input, processed)
    if processed then return end
    if input.KeyCode == Enum.KeyCode.R then
        toggleCyberRun()
    end
end)

-- ============================================================
-- MAIN HEARTBEAT LOOP
-- ============================================================
local speedLineTimer = 0

RunService.Heartbeat:Connect(function(dt)
    if not character or not rootPart then return end

    local vel      = rootPart.AssemblyLinearVelocity
    local flatSpeed = Vector3.new(vel.X, 0, vel.Z).Magnitude
    local isMoving  = flatSpeed > CONFIG.MIN_VELOCITY

    if cyberActive then
        local now = tick()

        -- After images
        if isMoving and (now - lastAfterimage) >= CONFIG.AFTERIMAGE_INTERVAL then
            lastAfterimage = now
            task.spawn(createAfterImage)
        end

        -- Sparks
        sparkTimer += dt
        if isMoving and sparkTimer >= CONFIG.SPARK_INTERVAL then
            sparkTimer = 0
            task.spawn(spawnGroundSpark)
        end

        -- Speed lines flash
        speedLineTimer += dt
        if isMoving and speedLineTimer >= 0.18 then
            speedLineTimer = 0
            flashSpeedLines()
        end

        -- Live FOV tracking
        local ratio = math.clamp(flatSpeed / CONFIG.SPEED_BOOST, 0, 1)
        camera.FieldOfView = CONFIG.FOV_NORMAL + (CONFIG.FOV_BOOST - CONFIG.FOV_NORMAL) * ratio

    else
        sparkTimer     = 0
        speedLineTimer = 0
    end
end)

-- ============================================================
-- CHARACTER RESPAWN
-- ============================================================
player.CharacterAdded:Connect(function(newChar)
    character  = newChar
    humanoid   = newChar:WaitForChild("Humanoid")
    rootPart   = newChar:WaitForChild("HumanoidRootPart")
    cyberActive = false

    afterimageFolder:ClearAllChildren()
    activeAfterimages = 0
    setActiveVisuals(false)
end)

-- ============================================================
-- STARTUP HINT
-- ============================================================
task.spawn(function()
    task.wait(1.5)

    local hintGui = Instance.new("ScreenGui")
    hintGui.Name          = "CyberHint"
    hintGui.ResetOnSpawn  = false
    hintGui.DisplayOrder  = 20
    hintGui.Parent        = player.PlayerGui

    local hintFrame = Instance.new("Frame")
    hintFrame.Size               = UDim2.new(0, 270, 0, 38)
    hintFrame.Position           = UDim2.new(0.5, -135, 0, -50)
    hintFrame.BackgroundColor3   = Color3.fromRGB(6, 6, 20)
    hintFrame.BackgroundTransparency = 0.15
    hintFrame.BorderSizePixel    = 0
    hintFrame.Parent             = hintGui

    local hc = Instance.new("UICorner")
    hc.CornerRadius = UDim.new(0, 10)
    hc.Parent = hintFrame

    local hs = Instance.new("UIStroke")
    hs.Color     = Color3.fromRGB(0, 200, 255)
    hs.Thickness = 1.5
    hs.Parent    = hintFrame

    local ht = Instance.new("TextLabel")
    ht.Size               = UDim2.new(1, 0, 1, 0)
    ht.BackgroundTransparency = 1
    ht.Text               = "⚡  Press  [ R ]  or tap the button to activate"
    ht.TextColor3         = Color3.fromRGB(180, 230, 255)
    ht.TextSize           = 13
    ht.Font               = Enum.Font.Gotham
    ht.Parent             = hintFrame

    -- Slide in
    TweenService:Create(hintFrame, TweenInfo.new(0.4, Enum.EasingStyle.Back, Enum.EasingDirection.Out), {
        Position = UDim2.new(0.5, -135, 0, 18)
    }):Play()

    task.wait(3.5)

    -- Slide out
    TweenService:Create(hintFrame, TweenInfo.new(0.35, Enum.EasingStyle.Quad, Enum.EasingDirection.In), {
        Position           = UDim2.new(0.5, -135, 0, -50),
        BackgroundTransparency = 1
    }):Play()
    TweenService:Create(ht, TweenInfo.new(0.35), { TextTransparency = 1 }):Play()
    TweenService:Create(hs, TweenInfo.new(0.35), { Transparency = 1 }):Play()

    task.wait(0.4)
    hintGui:Destroy()
end)