-- == Gael's Rayfield Menu (ESP unificado + cooldowns + anims arregladas) ==
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local CollectionService = game:GetService("CollectionService")
local RunService = game:GetService("RunService")
local player = Players.LocalPlayer

-- Rayfield
local Rayfield = loadstring(game:HttpGet('https://sirius.menu/rayfield'))()
local Window = Rayfield:CreateWindow({
    Name = "powers",
    LoadingTitle = "sonic.exe the disaster ",
    LoadingSubtitle = "by kaka con keso",
    ConfigurationSaving = { Enabled = true, FolderName = "MyScripts", FileName = "PowersConfig" }
})

-- -------------------- CONFIG & COLORES --------------------
local VIP_NO_COOLDOWN = { enjambrexe = true, holasupsiw8 = true, ytudooq = true }

local characterColors = {
    tails = Color3.fromRGB(255, 165, 0),
    knuckles = Color3.fromRGB(255, 0, 0),
    eggman = Color3.fromRGB(255, 255, 0),
    amy = Color3.fromRGB(255, 105, 180),
    cream = Color3.fromRGB(222, 184, 135),
    sally = Color3.fromRGB(139, 69, 19),
    shadow = Color3.fromRGB(0, 0, 0),
    rouge = Color3.fromRGB(255, 255, 255),
    metalsonic = Color3.fromRGB(0, 0, 255),
    silver = Color3.fromRGB(255, 255, 255),
    blaze = Color3.fromRGB(128, 0, 128),
}

-- -------------------- UTIL --------------------
local function isModelCharacterLike(m)
    if not m or not m:IsA("Model") then return false end
    for _, d in ipairs(m:GetDescendants()) do
        if d:IsA("BasePart") then return true end
    end
    return false
end

local function findCharacterModelInWorkspace(name)
    -- busca modelo con ese nombre en workspace (raro pero útil)
    return workspace:FindFirstChild(name)
end

local function normalizeAnimId(id)
    if not id then return nil end
    local s = tostring(id)
    -- extraer primer número largo
    local num = s:match("(%d+)")
    if not num then return nil end
    return "rbxassetid://"..num
end

-- -------------------- ANIMACIONES (arregladas y cacheadas) --------------------
local animationCache = {}
local function PlayAnimation(animationId)
    local animStr = normalizeAnimId(animationId)
    if not animStr then return end

    local char = player.Character or player.CharacterAdded:Wait()
    local humanoid = char:FindFirstChildOfClass("Humanoid")
    if not humanoid then return end

    -- asegurar Animator
    local animator = humanoid:FindFirstChildOfClass("Animator")
    if not animator then
        animator = Instance.new("Animator")
        animator.Parent = humanoid
    end

    local anim = animationCache[animStr]
    if not anim then
        anim = Instance.new("Animation")
        anim.AnimationId = animStr
        animationCache[animStr] = anim
    end

    -- cargar y reproducir (pcall por si falla)
    local ok, track = pcall(function()
        return animator:LoadAnimation(anim)
    end)
    if ok and track then
        track.Priority = Enum.AnimationPriority.Action
        track:Play()
    end
end

-- -------------------- ESP UNIFICADO (OPTIMIZADO) --------------------
local ESP = {
    master = false,
    exe = false,
    players = false,
    updateTask = nil,
    highlightMap = {} -- [model] = highlightInstance
}

local function clearAllHighlights()
    for model, h in pairs(ESP.highlightMap) do
        if h and h.Parent then pcall(function() h:Destroy() end) end
        ESP.highlightMap[model] = nil
    end
end

local function setHighlight(model, color)
    if not model or not model:IsA("Model") then return end
    -- si ya existe, solo actualizar color
    local existing = ESP.highlightMap[model]
    if existing and existing.Parent then
        pcall(function() existing.OutlineColor = color end)
        return
    end
    -- crear highlight que solo dibuja contorno
    local ok, h = pcall(function()
        local highlight = Instance.new("Highlight")
        highlight.Name = "ESP_Highlight_Gael"
        highlight.FillTransparency = 1
        highlight.OutlineTransparency = 0
        highlight.OutlineColor = color
        highlight.Adornee = model
        highlight.Parent = model
        return highlight
    end)
    if ok and h then
        ESP.highlightMap[model] = h
    end
end

local function buildDesiredHighlights()
    local desired = {} -- model -> color

    -- EXE via CollectionService tags "exe"
    if ESP.exe then
        local tagged = CollectionService:GetTagged("exe")
        for _, obj in ipairs(tagged) do
            if obj and obj:IsA("Model") and isModelCharacterLike(obj) then
                desired[obj] = Color3.fromRGB(255,0,0)
            end
        end
    end

    -- Players via ReplicatedStorage.displayPlayers (si existe)
    if ESP.players and ReplicatedStorage:FindFirstChild("displayPlayers") then
        local folder = ReplicatedStorage.displayPlayers
        for _, child in ipairs(folder:GetChildren()) do
            local stats = child:FindFirstChild("stats")
            if stats and stats:FindFirstChild("character") then
                local modelName = child.Name
                local model = findCharacterModelInWorkspace(modelName)
                if model and model:IsA("Model") and isModelCharacterLike(model) and model ~= player.Character then
                    local characterKey = tostring(stats.character.Value or ""):lower()
                    local color = characterColors[characterKey] or Color3.fromRGB(255,0,0)
                    desired[model] = color
                end
            end
        end
    end

    -- Fallback: buscar modelos en workspace cuyo nombre contenga alguna key (survivor genérico)
    if ESP.players then
        for _, obj in ipairs(workspace:GetDescendants()) do
            if obj:IsA("Model") and isModelCharacterLike(obj) and obj ~= player.Character then
                local low = obj.Name:lower()
                for k, col in pairs(characterColors) do
                    if string.find(low, k) then
                        desired[obj] = col
                        break
                    end
                end
            end
        end
    end

    return desired
end

local function updateESPOnce()
    local desired = buildDesiredHighlights()
    -- quitar highlights que ya no se necesitan
    for model, h in pairs(ESP.highlightMap) do
        if not desired[model] then
            pcall(function() h:Destroy() end)
            ESP.highlightMap[model] = nil
        end
    end
    -- crear/actualizar highlights deseadas
    for model, color in pairs(desired) do
        if model and model.Parent then
            setHighlight(model, color)
        end
    end
end

local function startESPLoop()
    if ESP.updateTask then return end
    ESP.updateTask = task.spawn(function()
        while ESP.master do
            pcall(updateESPOnce)
            task.wait(1) -- refresco cada 1s (ligero)
        end
        ESP.updateTask = nil
    end)
end

local function stopESPLoop()
    ESP.master = false
    if ESP.updateTask then
        ESP.updateTask = nil
    end
    clearAllHighlights()
end

-- -------------------- PODERES (Sonic + Super Jump) --------------------
-- Sonic (botón): boost 68 por 8s, vuelve a 29; cooldown 20s (VIP sin cooldown)
local sonicState = {cool = false}
local function SonicBoost()
    if sonicState.cool and not VIP_NO_COOLDOWN[player.Name:lower()] then return end
    if not player.Character then return end
    sonicState.cool = true

    local char = player.Character
    local humanoid = char:FindFirstChildOfClass("Humanoid")
    local root = char:FindFirstChild("HumanoidRootPart")
    if humanoid then
        humanoid.WalkSpeed = 68
    end
    local particle
    if root then
        particle = Instance.new("ParticleEmitter")
        particle.Color = ColorSequence.new(Color3.fromRGB(0,170,255))
        particle.Texture = "rbxassetid://243098098"
        particle.Size = NumberSequence.new(2)
        particle.Rate = 300
        particle.Lifetime = NumberRange.new(0.3,0.5)
        particle.Speed = NumberRange.new(10,15)
        particle.Parent = root
    end

    task.delay(8, function()
        if humanoid then humanoid.WalkSpeed = 29 end
        if particle and particle.Parent then pcall(function() particle:Destroy() end) end
    end)

    if not VIP_NO_COOLDOWN[player.Name:lower()] then
        task.delay(8 + 20, function() -- 8s duración + 20s cooldown
            sonicState.cool = false
        end)
    else
        -- VIP: no cooldown
        task.delay(8, function() sonicState.cool = false end)
    end
end

-- Super Jump: cooldown 15-20s
local jumpState = {cool = false}
local function SuperJump()
    if jumpState.cool and not VIP_NO_COOLDOWN[player.Name:lower()] then return end
    if not player.Character then return end
    jumpState.cool = true

    local char = player.Character
    local hrp = char:FindFirstChild("HumanoidRootPart")
    if hrp then
        hrp.AssemblyLinearVelocity = Vector3.new(hrp.AssemblyLinearVelocity.X, 110, hrp.AssemblyLinearVelocity.Z)
    end

    local cd = 20
    if VIP_NO_COOLDOWN[player.Name:lower()] then cd = 0 end
    if cd > 0 then
        task.delay(cd, function() jumpState.cool = false end)
    else
        task.delay(1, function() jumpState.cool = false end)
    end
end

-- -------------------- DEBUG (sg123) --------------------
local function createDebugLabelIfMissing()
    -- crea sg123 en CoreGui (igual que tu original)
    local cg = game.CoreGui
    if cg:FindFirstChild("sg123") then return cg.sg123 end
    local SG = Instance.new("ScreenGui", cg)
    SG.Name = "sg123"
    local wa = Instance.new("TextLabel", SG)
    wa.Text = "*Added functionality to the button but it's still lacking"
    wa.Name = "textr"
    wa.Position = UDim2.new(0.5, 0, 0.8, 0)
    wa.TextSize = 14
    wa.TextColor3 = Color3.fromRGB(255, 0, 0)
    wa.Visible = false
    wa.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
    wa.TextStrokeTransparency = 0
    return SG
end

-- -------------------- UI (Rayfield) --------------------
local Tab = Window:CreateTab("⚡ Powers", 78906521958459)

Tab:CreateButton({ Name = "Sonic Boost", Callback = SonicBoost })
Tab:CreateButton({ Name = "Super Jump", Callback = SuperJump })

local EspTab = Window:CreateTab("ESP", 134956083271283)
EspTab:CreateToggle({
    Name = "ESP Master (ON/OFF)",
    CurrentValue = false,
    Flag = "ESP_Master",
    Callback = function(val)
        ESP.master = val
        if ESP.master then
            startESPLoop()
        else
            stopESPLoop()
        end
    end
})
EspTab:CreateToggle({
    Name = "Highlight EXE (CollectionService tag 'exe')",
    CurrentValue = false,
    Flag = "ESP_EXE",
    Callback = function(val)
        ESP.exe = val
        if ESP.master then updateESPOnce() end
    end
})
EspTab:CreateToggle({
    Name = "Highlight Players/Survivors (displayPlayers)",
    CurrentValue = false,
    Flag = "ESP_PLAYERS",
    Callback = function(val)
        ESP.players = val
        if ESP.master then updateESPOnce() end
    end
})

local DebugRayTab = Window:CreateTab("Debug", 101010101)
DebugRayTab:CreateToggle({
    Name = "Toggle Debug HUD (sg123)",
    CurrentValue = false,
    Callback = function(Value)
        createDebugLabelIfMissing()
        -- mostrar/hide en CoreGui
        local cg = game.CoreGui
        if cg:FindFirstChild("sg123") then
            cg.sg123.textr.Visible = Value
        end
        -- intentar mostrar la gui debug del HUD si existe en PlayerGui
        local ok, err = pcall(function()
            local pg = player:WaitForChild("PlayerGui")
            local g = pg:FindFirstChild("gui")
            if g and g:FindFirstChild("hud") and g.hud:FindFirstChild("debug") then
                g.hud.debug.Visible = Value
            end
        end)
    end
})

-- -------------------- TELEPORT / ANIMS TAB --------------------
local TpTab = Window:CreateTab("Teleports", 202020202)
TpTab:CreateButton({ Name = "Teleport to Lobby", Callback = function()
    local hrp = player.Character and player.Character:FindFirstChild("HumanoidRootPart")
    if hrp then hrp.CFrame = CFrame.new(0,1,0) end
end })
TpTab:CreateButton({ Name = "Teleport to Game", Callback = function()
    local hrp = player.Character and player.Character:FindFirstChild("HumanoidRootPart")
    if hrp then hrp.CFrame = CFrame.new(-272,155,-313) end
end })

local AnimTab = Window:CreateTab("Animations", 303030303)
local Animations = {
    { Name = "Sonic.exe 2 Idle", Id = "rbxassetid://137659262960225" },
    { Name = "ID:1", Id = "http://www.roblox.com/asset/?id=180426354" },
    { Name = "Eyes.R", Id = "rbxassetid://110264241144654" },
    { Name = "Tails Cannon", Id = "rbxassetid://138560715967682" },
    { Name = "Tails Glide", Id = "rbxassetid://136705072136812" },
    { Name = "Amy Arm Idle", Id = "rbxassetid://16548210127" },
    { Name = "Cream Heal", Id = "rbxassetid://14472382960" },
    { Name = "Downed 2", Id = "rbxassetid://129121832899238" },
    { Name = "Injured 2", Id = "rbxassetid://116366098474267" }
}

for _, anim in ipairs(Animations) do
    AnimTab:CreateButton({
        Name = anim.Name,
        Callback = function()
            PlayAnimation(anim.Id)
        end
    })
end

-- Final: limpieza segura al cerrar menu (opcional)
Rayfield:OnUnload(function()
    stopESPLoop()
    clearAllHighlights()
end)