Reverse Flash

-- Character Ultimate Powers v1
-- Reverse Lumière+, Stop Time+, Quantum Rift+, Astral Form
-- UI, mobile-compatible, respawn-proof

-- ===================== Config =====================
local Config = {
    Reverse = {
        speed = 300,                -- walk speed while Reverse
        afterimageLife = 0.25,
        afterimageInterval = 0.06,
        trailColor = Color3.fromRGB(200,240,255),
    },
    StopTime = {
        toolName = "Time Clicker",
        teleportRange = 3000,
        freezeRadius = 1000,        -- radius around player to freeze (large by default)
        slowEffectDuration = 0.6,
        teleportTrailLife = 0.25,
        teleportTrailColors = {Color3.fromRGB(255,255,200), Color3.fromRGB(255,220,80)},
        shockPulseRadius = 30,
    },
    QuantumRift = {
        color = Color3.fromRGB(180,0,255),
        floatHeight = 2,
        trailRate = 400,
    },
    Astral = {
        speed = 120,
        ghostTransparency = 0.6,
        ghostColor = Color3.fromRGB(120,200,255),
    },
    UI = { width = 300, height = 380, corner = 14 },
    EffectsFolderName = "_CharacterUltimateEffects"
}

-- ===================== Services =====================
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local Debris = game:GetService("Debris")
local UserInputService = game:GetService("UserInputService")
local ContextActionService = game:GetService("ContextActionService")
local Workspace = game:GetService("Workspace")

local LocalPlayer = Players.LocalPlayer

-- safe wait helper
local function safeWait(t) if t and t>0 then task.wait(t) end end

-- ===================== Main initializer (respawn-proof) =====================
local function init()
    -- try/catch style protection
    local ok, err = pcall(function()
        -- Player GUI / Character
        local PlayerGui = LocalPlayer:WaitForChild("PlayerGui")
        local Character = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()
        local Humanoid = Character:WaitForChild("Humanoid")
        local Root = Character:WaitForChild("HumanoidRootPart")

        -- effects folder
        local effectsFolder = Workspace:FindFirstChild(Config.EffectsFolderName)
        if not effectsFolder then
            effectsFolder = Instance.new("Folder")
            effectsFolder.Name = Config.EffectsFolderName
            effectsFolder.Parent = Workspace
        end

        -- ===== state =====
        local reverseOn = false
        local reverseConn = nil
        local reverseTrail = nil

        local stopTimeOn = false
        local frozenEntities = {} -- table to store original state to restore
        local stopTool = nil

        local riftOn = false
        local riftParticle = nil

        local astralOn = false
        local ghost = nil
        local ghostControlConn = nil

        local afterimageTicker = 0

        -- utility: create afterimage of current character (for Reverse)
        local function createAfterimageFor(model, color, life)
            local clone = Instance.new("Model")
            clone.Name = "Afterimage"
            local primaryPart
            for _, part in pairs(model:GetDescendants()) do
                if part:IsA("BasePart") and part.Name ~= "HumanoidRootPart" then
                    local p = Instance.new("Part")
                    p.Size = part.Size
                    p.CFrame = part.CFrame
                    p.Anchored = true
                    p.CanCollide = false
                    p.Material = Enum.Material.Neon
                    p.Color = color
                    p.Transparency = 0.4
                    p.Parent = clone
                end
            end
            clone.Parent = effectsFolder
            Debris:AddItem(clone, life or Config.Reverse.afterimageLife)
        end

        -- ===== Reverse Lumière =====
        local function startReverse()
            if reverseOn then return end
            reverseOn = true
            -- increase speed
            if Humanoid then pcall(function() Humanoid.WalkSpeed = Config.Reverse.speed end) end
            -- trail
            local a0 = Instance.new("Attachment", Root)
            local a1 = Instance.new("Attachment", Root)
            reverseTrail = Instance.new("Trail")
            reverseTrail.Attachment0 = a0
            reverseTrail.Attachment1 = a1
            reverseTrail.Color = ColorSequence.new(Config.Reverse.trailColor)
            reverseTrail.Lifetime = 0.18
            reverseTrail.Parent = Root

            -- afterimages loop
            reverseConn = RunService.Heartbeat:Connect(function(dt)
                afterimageTicker = afterimageTicker + dt
                if afterimageTicker >= Config.Reverse.afterimageInterval then
                    afterimageTicker = 0
                    -- create afterimage (local)
                    pcall(function()
                        createAfterimageFor(Character, Config.Reverse.trailColor, Config.Reverse.afterimageLife)
                    end)
                end
            end)
        end

        local function stopReverse()
            reverseOn = false
            if reverseConn then reverseConn:Disconnect() reverseConn = nil end
            if reverseTrail then reverseTrail:Destroy() reverseTrail = nil end
            if Humanoid then pcall(function() Humanoid.WalkSpeed = 16 end) end
        end

        -- ===== Stop Time =====
        -- store original states and freeze others in range
        local function freezeAround()
            frozenEntities = {}
            local myPos = Root.Position
            -- players
            for _, pl in pairs(Players:GetPlayers()) do
                if pl ~= LocalPlayer and pl.Character and pl.Character:FindFirstChild("HumanoidRootPart") then
                    local c = pl.Character
                    local hp = c:FindFirstChild("Humanoid")
                    local hrp = c:FindFirstChild("HumanoidRootPart")
                    if hrp and hp then
                        local dist = (hrp.Position - myPos).Magnitude
                        if dist <= Config.StopTime.freezeRadius then
                            local entry = {player = pl}
                            -- store properties
                            pcall(function()
                                entry.walkSpeed = hp.WalkSpeed
                                entry.jumpPower = hp.JumpPower
                                entry.platformStand = hp.PlatformStand
                                entry.anchoredParts = {}
                                for _, part in pairs(c:GetDescendants()) do
                                    if part:IsA("BasePart") then
                                        entry.anchoredParts[part] = part.Anchored
                                        part.Anchored = true
                                    end
                                end
                                hp.WalkSpeed = 0
                                hp.JumpPower = 0
                                hp.PlatformStand = true
                            end)
                            table.insert(frozenEntities, entry)
                        end
                    end
                end
            end
            -- NPCs / other humanoids (non-player)
            for _, obj in pairs(Workspace:GetDescendants()) do
                if obj:IsA("Model") and obj:FindFirstChild("Humanoid") and obj:FindFirstChild("HumanoidRootPart") then
                    local ownerPlayer = Players:GetPlayerFromCharacter(obj)
                    if not ownerPlayer then -- not a player
                        local hrp = obj:FindFirstChild("HumanoidRootPart")
                        local hum = obj:FindFirstChild("Humanoid")
                        if hrp and hum then
                            local dist = (hrp.Position - myPos).Magnitude
                            if dist <= Config.StopTime.freezeRadius then
                                local entry = {npc = obj}
                                pcall(function()
                                    entry.walkSpeed = hum.WalkSpeed
                                    entry.platformStand = hum.PlatformStand
                                    entry.anchoredParts = {}
                                    for _, part in pairs(obj:GetDescendants()) do
                                        if part:IsA("BasePart") then
                                            entry.anchoredParts[part] = part.Anchored
                                            part.Anchored = true
                                        end
                                    end
                                    hum.WalkSpeed = 0
                                    hum.PlatformStand = true
                                end)
                                table.insert(frozenEntities, entry)
                            end
                        end
                    end
                end
            end
        end

        local function unfreezeAll()
            for _, entry in pairs(frozenEntities) do
                pcall(function()
                    if entry.player and entry.player.Character and entry.player.Character:FindFirstChild("Humanoid") then
                        local h = entry.player.Character:FindFirstChild("Humanoid")
                        h.WalkSpeed = entry.walkSpeed or 16
                        h.JumpPower = entry.jumpPower or 50
                        h.PlatformStand = entry.platformStand or false
                        for part, wasAnch in pairs(entry.anchoredParts or {}) do
                            if part and part.Parent then
                                part.Anchored = wasAnch
                            end
                        end
                    elseif entry.npc and entry.npc:FindFirstChild("Humanoid") then
                        local nh = entry.npc:FindFirstChild("Humanoid")
                        nh.WalkSpeed = entry.walkSpeed or 0
                        nh.PlatformStand = entry.platformStand or false
                        for part, wasAnch in pairs(entry.anchoredParts or {}) do
                            if part and part.Parent then
                                part.Anchored = wasAnch
                            end
                        end
                    end
                end)
            end
            frozenEntities = {}
        end

        -- teleport trail effect helper
        local function spawnTeleportTrail(fromPos, toPos)
            -- create a part path and small trails along it
            local dir = (toPos - fromPos)
            local length = math.max(1, dir.Magnitude)
            local steps = math.clamp(math.floor(length / 6), 3, 30)
            for i = 0, steps do
                local t = i / steps
                local pos = fromPos:Lerp(toPos, t)
                local p = Instance.new("Part")
                p.Size = Vector3.new(1.5,1.5,1.5)
                p.CFrame = CFrame.new(pos)
                p.Anchored = true
                p.CanCollide = false
                p.Material = Enum.Material.Neon
                p.Color = Config.StopTime.teleportTrailColors[(i%#Config.StopTime.teleportTrailColors)+1]
                p.Transparency = 0.2
                p.Parent = effectsFolder
                Debris:AddItem(p, Config.StopTime.teleportTrailLife)
            end
        end

        -- give teleport tool (Stop Time tool)
        local function giveTeleportTool()
            if LocalPlayer.Backpack:FindFirstChild(Config.StopTime.toolName) then return end
            if LocalPlayer.Character and LocalPlayer.Character:FindFirstChild(Config.StopTime.toolName) then return end

            local tool = Instance.new("Tool")
            tool.Name = Config.StopTime.toolName
            tool.RequiresHandle = false
            tool.CanBeDropped = false

            -- for mobile compatibility we rely on Tool.Activated + Mouse.Hit (works in many environments)
            tool.Activated:Connect(function()
                local mouse = LocalPlayer:GetMouse()
                if not mouse then return end
                local hit = mouse.Hit
                if not hit then return end
                local target = hit.p
                -- limit range
                local dist = (target - Root.Position).Magnitude
                if dist > Config.StopTime.teleportRange then
                    -- clamp to max range towards target
                    target = Root.Position + (target - Root.Position).Unit * Config.StopTime.teleportRange
                end

                -- create teleport trail and sound/effect
                spawnTeleportTrail(Root.Position, target)

                -- teleport and small upward offset to avoid getting stuck
                Root.CFrame = CFrame.new(target + Vector3.new(0, 3, 0))
            end)

            tool.Parent = LocalPlayer.Backpack
            stopTool = tool
        end

        -- Stop Time toggle on
        local function startStopTime()
            if stopTimeOn then return end
            stopTimeOn = true
            -- freeze others in range
            freezeAround()

            -- optional visual: small ring shock at player's feet
            local ring = Instance.new("Part")
            ring.Size = Vector3.new(1,1,1)
            ring.Shape = Enum.PartType.Ball
            ring.Anchored = true
            ring.CanCollide = false
            ring.Material = Enum.Material.Neon
            ring.Color = Color3.fromRGB(255,230,170)
            ring.Transparency = 0.5
            ring.CFrame = Root.CFrame * CFrame.new(0, -2, 0)
            ring.Parent = effectsFolder
            Debris:AddItem(ring, 1)

            -- give teleport tool
            giveTeleportTool()
        end

        local function stopStopTime()
            if not stopTimeOn then return end
            stopTimeOn = false
            unfreezeAll()
            -- remove tool if exists
            if stopTool and stopTool.Parent then
                stopTool:Destroy()
                stopTool = nil
            end
        end

        -- ===== Quantum Rift =====
        local function startRift()
            if riftOn then return end
            riftOn = true
            -- make character parts non-collidable so player can pass through things
            local colChanged = {}
            for _, p in pairs(Character:GetDescendants()) do
                if p:IsA("BasePart") then
                    colChanged[p] = p.CanCollide
                    p.CanCollide = false
                    p.Material = Enum.Material.ForceField
                    p.Color = Config.QuantumRift.color
                    p.Transparency = 0.2
                end
            end
            -- particle emitter on root
            local p = Instance.new("ParticleEmitter")
            p.Name = "RiftParticles"
            p.Texture = "rbxassetid://6880519346"
            p.Color = ColorSequence.new(Config.QuantumRift.color)
            p.Lifetime = NumberRange.new(0.4, 0.9)
            p.Rate = Config.QuantumRift.trailRate
            p.Speed = NumberRange.new(0.5, 2)
            p.Parent = Root
            riftParticle = p

            -- allow normal movement (humanoid control) while parts non-collidable -> can pass through
            -- store colChanged table to restore later
            riftOn = true
            -- save to closure for restoration
            riftOn = {colState = colChanged, particle = p}
        end

        local function stopRift()
            if not riftOn then return end
            local state = riftOn
            riftOn = false
            if state and state.colState then
                for part, was in pairs(state.colState) do
                    if part and part.Parent then
                        part.CanCollide = was
                        part.Material = Enum.Material.Plastic
                        part.Transparency = 0
                    end
                end
            end
            if state and state.particle and state.particle.Parent then
                state.particle:Destroy()
            end
        end

        -- ===== Astral Form =====
        local function createGhost()
            if ghost then ghost:Destroy() ghost = nil end
            ghost = Character:Clone()
            ghost.Name = "AstralGhost"
            ghost.Parent = effectsFolder
            -- remove scripts/humanoids so it won't act like a player character
            for _, obj in pairs(ghost:GetDescendants()) do
                if obj:IsA("Humanoid") then obj:Destroy() end
                if obj:IsA("Script") or obj:IsA("LocalScript") then obj:Destroy() end
                if obj:IsA("BasePart") then
                    obj.CanCollide = false
                    obj.Transparency = Config.Astral.ghostTransparency
                    obj.Material = Enum.Material.Neon
                    obj.Color = Config.Astral.ghostColor
                end
            end
            -- create a simple controller: BodyVelocity on primary
            local hrp = ghost:FindFirstChild("HumanoidRootPart") or ghost.PrimaryPart
            if hrp then
                local bv = Instance.new("BodyVelocity")
                bv.MaxForce = Vector3.new(1e5, 1e5, 1e5)
                bv.Velocity = Vector3.new(0,0,0)
                bv.Parent = hrp
                hrp:SetNetworkOwner(nil) -- try to keep it local-movable (depends on executor)
            end
            -- anchor original character so it remains
            for _, part in pairs(Character:GetDescendants()) do
                if part:IsA("BasePart") then
                    part.Anchored = true
                end
            end
        end

        local function destroyGhostAndReturn()
            if not ghost then return end
            local hrpGhost = ghost:FindFirstChild("HumanoidRootPart") or ghost.PrimaryPart
            if hrpGhost then
                -- put original character near ghost and unanchor
                Character:MoveTo(hrpGhost.Position + Vector3.new(0, 3, 0))
            end
            -- unanchor original
            for _, part in pairs(Character:GetDescendants()) do
                if part:IsA("BasePart") then
                    part.Anchored = false
                end
            end
            ghost:Destroy()
            ghost = nil
        end

        local function startAstral()
            if astralOn then return end
            astralOn = true
            createGhost()
            -- control ghost with WASD / joystick -> use ContextActionService
            local function moveGhost(actionName, inputState, inputObject)
                if not ghost or not ghost.Parent then return end
                local hrp = ghost:FindFirstChild("HumanoidRootPart") or ghost.PrimaryPart
                if not hrp then return end
                -- read movement vector from UserInputService
                local moveVector = Vector3.new(0,0,0)
                local forward = (Workspace.CurrentCamera and Workspace.CurrentCamera.CFrame.LookVector) or Vector3.new(0,0,-1)
                local right = (Workspace.CurrentCamera and Workspace.CurrentCamera.CFrame.RightVector) or Vector3.new(1,0,0)
                -- WASD keys
                if UserInputService:IsKeyDown(Enum.KeyCode.W) then moveVector = moveVector + forward end
                if UserInputService:IsKeyDown(Enum.KeyCode.S) then moveVector = moveVector - forward end
                if UserInputService:IsKeyDown(Enum.KeyCode.D) then moveVector = moveVector + right end
                if UserInputService:IsKeyDown(Enum.KeyCode.A) then moveVector = moveVector - right end
                -- normalize
                if moveVector.Magnitude > 0 then
                    moveVector = moveVector.Unit * Config.Astral.speed
                end
                local bv = hrp:FindFirstChildOfClass("BodyVelocity")
                if bv then bv.Velocity = moveVector end
            end
            ghostControlConn = RunService.Heartbeat:Co