----------------------------------------------------------------
-- INTRO: "K24 HUB" con animacion de escala suave, se cierra y luego abre el menu
----------------------------------------------------------------
local RF
task.spawn(function()
    RF=loadstring(game:HttpGet("https://sirius.menu/rayfield"))() -- se descarga mientras suena la intro
end)

do
    local TS=game:GetService("TweenService")
    local intro=Instance.new("ScreenGui")
    intro.Name="K24Intro";intro.ResetOnSpawn=false;intro.IgnoreGuiInset=true;intro.DisplayOrder=10000
    local ok=pcall(function() intro.Parent=(gethui and gethui()) or game:GetService("CoreGui") end)
    if not ok or not intro.Parent then
        intro.Parent=game:GetService("Players").LocalPlayer:WaitForChild("PlayerGui")
    end

    local box=Instance.new("Frame")
    box.AnchorPoint=Vector2.new(0.5,0.5);box.Position=UDim2.fromScale(0.5,0.5)
    box.Size=UDim2.fromOffset(340,120);box.BackgroundColor3=Color3.fromRGB(14,14,16)
    box.BorderSizePixel=0;box.Parent=intro
    Instance.new("UICorner",box).CornerRadius=UDim.new(0,16)
    local stroke=Instance.new("UIStroke",box)
    stroke.Color=Color3.fromRGB(255,255,255);stroke.Thickness=1.5;stroke.Transparency=0.35
    local scale=Instance.new("UIScale",box);scale.Scale=0

    local lbl=Instance.new("TextLabel")
    lbl.BackgroundTransparency=1;lbl.Size=UDim2.fromScale(1,1)
    lbl.Font=Enum.Font.GothamBlack;lbl.Text="K24 HUB";lbl.TextSize=50
    lbl.TextColor3=Color3.fromRGB(255,255,255);lbl.Parent=box

    local bar=Instance.new("Frame")
    bar.AnchorPoint=Vector2.new(0.5,0);bar.Position=UDim2.new(0.5,0,1,-16)
    bar.Size=UDim2.fromOffset(0,3);bar.BackgroundColor3=Color3.fromRGB(255,255,255)
    bar.BorderSizePixel=0;bar.Parent=box
    Instance.new("UICorner",bar).CornerRadius=UDim.new(1,0)

    -- aparece (escala 0 -> 1 con rebote suave)
    local tin=TS:Create(scale,TweenInfo.new(0.7,Enum.EasingStyle.Back,Enum.EasingDirection.Out),{Scale=1})
    tin:Play()
    task.wait(0.35)
    TS:Create(bar,TweenInfo.new(0.9,Enum.EasingStyle.Quint,Enum.EasingDirection.Out),{Size=UDim2.fromOffset(180,3)}):Play()
    task.wait(1.4)

    -- se cierra (escala 1 -> 0 con desvanecido)
    local tout=TS:Create(scale,TweenInfo.new(0.5,Enum.EasingStyle.Quint,Enum.EasingDirection.In),{Scale=0})
    TS:Create(lbl,TweenInfo.new(0.4,Enum.EasingStyle.Quad),{TextTransparency=1}):Play()
    TS:Create(box,TweenInfo.new(0.5,Enum.EasingStyle.Quad),{BackgroundTransparency=1}):Play()
    TS:Create(stroke,TweenInfo.new(0.4,Enum.EasingStyle.Quad),{Transparency=1}):Play()
    tout:Play()
    tout.Completed:Wait()
    intro:Destroy()
end

local waited=0
while not RF and waited<20 do task.wait(0.1);waited=waited+0.1 end
if not RF then error("Rayfield could not be loaded") end

local PL=game:GetService("Players")
local RS=game:GetService("RunService")
local WS=game:GetService("Workspace")
local UIS=game:GetService("UserInputService")
local LP=PL.LocalPlayer
local CAM=WS.CurrentCamera

local Win=RF:CreateWindow({Name="FATAL FLOORS HUB",LoadingTitle="FATAL FLOORS HUB",LoadingSubtitle="Loading...",ConfigurationSaving={Enabled=false},Discord={Enabled=false},KeySystem=false})
local TMain=Win:CreateTab("Main",nil)
local TESP=Win:CreateTab("ESP",nil)
local TCurr=Win:CreateTab("Currency",nil)
local TSpec=Win:CreateTab("Spectate",nil)
local TExtra=Win:CreateTab("Extras",nil)
local TSet=Win:CreateTab("Settings",nil)

local ORES={"Iron Ore","Copper Ore","Coal","Jade","Amber","Gold","Silver","Diamond","Obsidian","Ruby","Sapphire"}
local CURR={"coin","coins","cash","money","gem","gems","token","tokens","buck","bucks","currency","dollar"}
local SELL_KW={"sellstation","sell_station","sell station","sellingstation","cashier","store"}

local ORE_L={}
for i,n in ipairs(ORES) do ORE_L[i]=string.lower(n) end

local C={
    farm=false,cur=false,ref=true,delay=1,ret=true,
    mESP=false,oESP=false,pESP=false,
    mCol=Color3.fromRGB(255,50,50),
    oCol=Color3.fromRGB(50,200,255),
    pCol=Color3.fromRGB(255,255,50),
    dist=true,names=true,
    noclip=false,fly=false,afk=false,
    -- NUEVO: ajustes de rendimiento y seguridad
    espDist=500,    -- solo se dibuja ESP dentro de esta distancia (studs)
    espMax=8,       -- maximo de objetos con ESP por categoria (Roblox solo dibuja 31 Highlights a la vez)
    espRate=0.25,   -- segundos entre actualizaciones del ESP
    avoid=true,     -- evitar menas con monstruos cerca
    avoidDist=35,
    fb=false,       -- Fullbright
    lockSpd=true,   -- mantiene el WalkSpeed/JumpPower elegido aunque el juego lo cambie
    instant=false,  -- ProximityPrompts instantaneos
    spd=nil,jmp=nil
}

local SLbl,CLbl

----------------------------------------------------------------
-- INDICE DEL MAPA (se escanea UNA vez y luego se mantiene con eventos)
-- Antes: WS:GetDescendants() + string.lower() de todo el mapa en CADA frame.
----------------------------------------------------------------
local OreSet,CurrSet,SellSet,MonSet={}, {}, {}, {}
local PartCache=setmetatable({}, {__mode="k"})
local IndexReady=false

local function OreName(lname)
    for i,l in ipairs(ORE_L) do
        if string.find(lname,l,1,true) then return ORES[i] end
    end
end

local function SameAncestor(set,o,val)
    -- evita registrar dos veces el mismo objeto (modelo + sus partes con el mismo nombre)
    local a=o.Parent
    while a and a~=WS do
        if set[a] and (val==nil or set[a]==val) then return true end
        a=a.Parent
    end
    return false
end

-- PROXIMITY PROMPTS INSTANTANEOS (HoldDuration = 0)
local Prompts={}
local OrigHold=setmetatable({}, {__mode="k"})
local HookedP=setmetatable({}, {__mode="k"})
local function ApplyInstant(p)
    if C.instant then
        if OrigHold[p]==nil then OrigHold[p]=p.HoldDuration end
        if p.HoldDuration~=0 then p.HoldDuration=0 end
        if not HookedP[p] then
            HookedP[p]=true
            -- si el juego intenta devolver el tiempo de espera, se vuelve a poner en 0
            p:GetPropertyChangedSignal("HoldDuration"):Connect(function()
                if C.instant and p.HoldDuration~=0 then p.HoldDuration=0 end
            end)
        end
    elseif OrigHold[p]~=nil then
        p.HoldDuration=OrigHold[p]
        OrigHold[p]=nil
    end
end
local function SetInstant(v)
    C.instant=v
    for p in pairs(Prompts) do
        if p.Parent then pcall(ApplyInstant,p) else Prompts[p]=nil end
    end
end

local function Classify(o)
    if o:IsA("ProximityPrompt") then
        Prompts[o]=true
        if C.instant then pcall(ApplyInstant,o) end
        return
    end
    if o:IsA("Humanoid") then
        local m=o.Parent
        if m and m:IsA("Model") and not PL:GetPlayerFromCharacter(m) then MonSet[m]=true end
        return
    end
    if not (o:IsA("BasePart") or o:IsA("Model")) then return end
    local ln=string.lower(o.Name)
    local on=OreName(ln)
    if on and not SameAncestor(OreSet,o,on) then OreSet[o]=on end
    for _,k in ipairs(CURR) do
        if string.find(ln,k,1,true) then
            if not SameAncestor(CurrSet,o) then CurrSet[o]=true end
            break
        end
    end
    for _,k in ipairs(SELL_KW) do
        if string.find(ln,k,1,true) then SellSet[o]=true;break end
    end
end

local RemESP -- forward
local function Unclassify(o)
    OreSet[o]=nil;CurrSet[o]=nil;SellSet[o]=nil;MonSet[o]=nil;PartCache[o]=nil;Prompts[o]=nil
    RemESP(o)
end

task.spawn(function()
    WS.DescendantAdded:Connect(function(o) pcall(Classify,o) end)
    WS.DescendantRemoving:Connect(function(o) pcall(Unclassify,o) end)
    local list=WS:GetDescendants()
    for i,o in ipairs(list) do
        pcall(Classify,o)
        if i%1500==0 then task.wait() end -- reparte el escaneo para no congelar el juego
    end
    IndexReady=true
end)

local function WaitIndex()
    while not IndexReady do task.wait(0.2) end
end

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

local function IsAlive()
    local ch=LP.Character
    local h=ch and ch:FindFirstChildOfClass("Humanoid")
    return h~=nil and h.Health>0 and Root()~=nil
end

local function GetPos(o)
    if not o or not o.Parent then return nil end
    if o:IsA("Model") then
        local ok,cf=pcall(function() return o:GetPivot() end)
        return ok and cf.Position or nil
    elseif o:IsA("BasePart") then return o.Position end
    return nil
end

local function PartOf(o)
    if o:IsA("BasePart") then return o end
    local c=PartCache[o]
    if c and c.Parent then return c end
    c=nil
    if o:IsA("Model") then
        c=o.PrimaryPart or o:FindFirstChild("HumanoidRootPart") or o:FindFirstChildWhichIsA("BasePart",true)
    end
    PartCache[o]=c
    return c
end

local function FirePx(o)
    if not o then return false end
    for _,d in ipairs(o:GetDescendants()) do
        if d:IsA("ProximityPrompt") then fireproximityprompt(d);return true end
    end
    return false
end

local function MonsterNear(pos,radius)
    for m in pairs(MonSet) do
        if m.Parent then
            local p=GetPos(m)
            if p and (p-pos).Magnitude<=radius then return true end
        else
            MonSet[m]=nil
        end
    end
    return false
end

-- Teletransporte SEGURO:
--  * busca el suelo con un raycast y aterriza encima (no dentro de una pared ni en el vacio)
--  * pone la velocidad en 0 varios frames (evita dano por caida al llegar)
--  * no teletransporta si estas muerto
local RayP=RaycastParams.new()
RayP.FilterType=Enum.RaycastFilterType.Exclude
local function SafeTp(pos)
    if not pos or not IsAlive() then return false end
    local r=Root()
    local ignore={LP.Character}
    for _,p in ipairs(PL:GetPlayers()) do if p.Character then ignore[#ignore+1]=p.Character end end
    for m in pairs(MonSet) do if m.Parent then ignore[#ignore+1]=m end end
    RayP.FilterDescendantsInstances=ignore
    local hit=WS:Raycast(pos+Vector3.new(0,4,0),Vector3.new(0,-40,0),RayP)
    local target=hit and (hit.Position+Vector3.new(0,3.2,0)) or (pos+Vector3.new(0,3.5,0))
    r.AssemblyLinearVelocity=Vector3.zero
    r.AssemblyAngularVelocity=Vector3.zero
    r.CFrame=CFrame.new(target)
    for _=1,6 do
        RS.Heartbeat:Wait()
        if not r.Parent then return false end
        r.AssemblyLinearVelocity=Vector3.zero
    end
    task.wait(0.15)
    return IsAlive()
end

-- Mena mas cercana de un tipo (ignora las ya elegidas y, si esta activo, las que tienen monstruos cerca)
local function NearestOre(name,taken)
    local r=Root()
    local rp=r and r.Position
    local cand={}
    for o,n in pairs(OreSet) do
        if n==name then
            if o.Parent then
                local skip=false
                for _,t in ipairs(taken) do if t==o then skip=true;break end end
                if not skip and not MonSet[o] then
                    local p=GetPos(o)
                    if p then cand[#cand+1]={o=o,p=p,d=rp and (p-rp).Magnitude or 0} end
                end
            else
                OreSet[o]=nil
            end
        end
    end
    table.sort(cand,function(a,b) return a.d<b.d end)
    for _,c in ipairs(cand) do
        if not C.avoid or not MonsterNear(c.p,C.avoidDist) then return c.o end
    end
end

local SellCache
local function FindSell()
    if SellCache and SellCache.Parent then return SellCache end
    local r=Root()
    local rp=r and r.Position
    local best,bd,bestPrompt
    for o in pairs(SellSet) do
        if o.Parent then
            local p=GetPos(o)
            if p then
                local has=false
                for _,d in ipairs(o:GetDescendants()) do
                    if d:IsA("ProximityPrompt") then has=true;break end
                end
                local d=rp and (p-rp).Magnitude or 0
                -- se prefiere el que tiene ProximityPrompt; luego el mas cercano
                if not best or (has and not bestPrompt) or (has==bestPrompt and d<bd) then
                    best,bd,bestPrompt=o,d,has
                end
            end
        end
    end
    SellCache=best
    return best
end

local function EqBP()
    local bp=LP:FindFirstChild("Backpack");local ch=LP.Character
    if not bp or not ch then return false end
    local h=ch:FindFirstChildOfClass("Humanoid")
    if not h then return false end
    for _,t in ipairs(bp:GetChildren()) do if t:IsA("Tool") then h:EquipTool(t);task.wait(0.4);return true end end
    return false
end

local function ApplySpeed(spd,jmp)
    if spd then C.spd=spd end
    if jmp then C.jmp=jmp end
    local ch=LP.Character
    if not ch then return end
    local h=ch:FindFirstChildOfClass("Humanoid")
    if h then
        if spd then h.WalkSpeed=spd end
        if jmp then h.JumpPower=jmp end
    end
end

-- Al reaparecer se vuelven a aplicar velocidad y salto
LP.CharacterAdded:Connect(function()
    task.wait(1)
    if C.spd or C.jmp then ApplySpeed(C.spd,C.jmp) end
end)

-- WALKSPEED BLOQUEADO
-- Cada frame (antes de la fisica) se vuelve a poner el valor elegido en el menu, asi el juego
-- no puede cambiarlo al agacharte, recibir dano, correr, etc.
local LockHum
RS.Stepped:Connect(function()
    if not C.lockSpd or (not C.spd and not C.jmp) then return end
    if not LockHum or not LockHum.Parent then
        local ch=LP.Character
        LockHum=ch and ch:FindFirstChildOfClass("Humanoid")
        if not LockHum then return end
    end
    if C.spd and LockHum.WalkSpeed~=C.spd then LockHum.WalkSpeed=C.spd end
    if C.jmp and LockHum.JumpPower~=C.jmp then LockHum.JumpPower=C.jmp end
end)

----------------------------------------------------------------
-- ESP OPTIMIZADO
-- * Un solo bucle (cada 0.25s) en vez de uno por frame + uno por objeto
-- * Usa el indice (sin recorrer el mapa) y solo dibuja los N objetos mas cercanos
-- * Los Highlights/Billboards viven en una carpeta propia (no dentro del juego)
----------------------------------------------------------------
local ESPTbl={}
local ESPFolder
local function GetFolder()
    if ESPFolder and ESPFolder.Parent then return ESPFolder end
    ESPFolder=Instance.new("Folder")
    ESPFolder.Name="_esp"
    local ok=pcall(function() ESPFolder.Parent=(gethui and gethui()) or game:GetService("CoreGui") end)
    if not ok or not ESPFolder.Parent then ESPFolder.Parent=CAM end
    return ESPFolder
end

RemESP=function(o)
    local e=ESPTbl[o]
    if e then
        pcall(function() e.h:Destroy() end)
        pcall(function() e.b:Destroy() end)
        ESPTbl[o]=nil
    end
end

local function AddESP(o,cat,fc,oc,ft,part)
    local folder=GetFolder()
    local h=Instance.new("Highlight")
    h.FillColor=fc;h.OutlineColor=oc;h.FillTransparency=ft;h.OutlineTransparency=0
    h.DepthMode=Enum.HighlightDepthMode.AlwaysOnTop
    h.Adornee=o;h.Parent=folder
    local bb=Instance.new("BillboardGui")
    bb.AlwaysOnTop=true;bb.Size=UDim2.new(0,120,0,40);bb.StudsOffset=Vector3.new(0,3,0)
    bb.Adornee=part;bb.Parent=folder
    local tl=Instance.new("TextLabel",bb)
    tl.BackgroundTransparency=1;tl.Size=UDim2.new(1,0,1,0)
    tl.TextColor3=oc;tl.TextStrokeTransparency=0.4
    tl.Font=Enum.Font.GothamBold;tl.TextSize=13;tl.Text=""
    ESPTbl[o]={h=h,b=bb,tl=tl,cat=cat}
end

local function ClearESP(cat)
    for o,e in pairs(ESPTbl) do
        if not cat or e.cat==cat then RemESP(o) end
    end
end

local function UpdateESP()
    local camPos=CAM.CFrame.Position
    local want={}

    local function Pick(cat,list,fc,oc,ft)
        table.sort(list,function(a,b) return a.d<b.d end)
        for i=1,math.min(#list,C.espMax) do
            local it=list[i]
            want[it.o]=true
            if not ESPTbl[it.o] then AddESP(it.o,cat,fc,oc,ft,it.part) end
            local e=ESPTbl[it.o]
            if e then
                if C.names then
                    e.tl.Text=C.dist and (it.lbl.."\n["..math.floor(it.d).."m]") or it.lbl
                else
                    e.tl.Text=""
                end
            end
        end
    end

    if C.mESP and IndexReady then
        local list={}
        for m in pairs(MonSet) do
            if m.Parent and not PL:GetPlayerFromCharacter(m) then
                local part=PartOf(m)
                if part then
                    local d=(camPos-part.Position).Magnitude
                    if d<=C.espDist then list[#list+1]={o=m,part=part,d=d,lbl=m.Name} end
                end
            else
                MonSet[m]=nil
            end
        end
        Pick("m",list,C.mCol,Color3.new(1,1,1),0.6)
    end

    if C.oESP and IndexReady then
        local list={}
        for o,n in pairs(OreSet) do
            if o.Parent then
                if not MonSet[o] then
                    local part=PartOf(o)
                    if part then
                        local d=(camPos-part.Position).Magnitude
                        if d<=C.espDist then list[#list+1]={o=o,part=part,d=d,lbl=n} end
                    end
                end
            else
                OreSet[o]=nil
            end
        end
        Pick("o",list,C.oCol,Color3.new(0,0.9,1),0.7)
    end

    if C.pESP then
        local list={}
        for _,p in ipairs(PL:GetPlayers()) do
            local ch=p.Character
            if p~=LP and ch and ch.Parent then
                local part=ch:FindFirstChild("HumanoidRootPart")
                if part then
                    local d=(camPos-part.Position).Magnitude
                    if d<=C.espDist then list[#list+1]={o=ch,part=part,d=d,lbl=p.Name} end
                end
            end
        end
        Pick("p",list,C.pCol,Color3.new(1,1,1),0.6)
    end

    for o in pairs(ESPTbl) do
        if not want[o] or not o.Parent then RemESP(o) end
    end
end

task.spawn(function()
    while true do
        if C.mESP or C.oESP or C.pESP then
            pcall(UpdateESP)
            task.wait(C.espRate)
        else
            task.wait(0.5)
        end
    end
end)

----------------------------------------------------------------
-- AUTOFARM
----------------------------------------------------------------
local function FarmCycle()
    if not IndexReady then SLbl:Set("Indexing map...");task.wait(1);return end
    if not IsAlive() then SLbl:Set("Dead. Waiting respawn...");task.wait(1.5);return end
    local picked={}
    for _,name in ipairs(ORES) do
        if #picked>=2 or not C.farm then break end
        local o=NearestOre(name,picked)
        if o then
            local pos=GetPos(o)
            if pos then
                SLbl:Set("Farming: "..name.." ("..(#picked+1).."/2)")
                if not SafeTp(pos) then task.wait(1);return end
                task.wait(0.3)
                if FirePx(o) then picked[#picked+1]=o end
                task.wait(0.35)
            end
        end
    end
    if not C.farm then return end
    if #picked==0 then SLbl:Set("No safe ores found. Waiting...");task.wait(2);return end
    local st=FindSell()
    if not st then SLbl:Set("SellStation missing!");task.wait(2);return end
    local sp=GetPos(st)
    if not sp then task.wait(1);return end
    SLbl:Set("Going to SellStation...")
    if not SafeTp(sp) then task.wait(1);return end
    task.wait(0.5)
    SLbl:Set("Selling ore 1...");FirePx(st);task.wait(C.delay)
    if #picked>=2 and C.farm then
        SLbl:Set("Equipping ore 2...")
        if EqBP() then
            if not SafeTp(sp) then task.wait(1);return end
            task.wait(0.3);SLbl:Set("Selling ore 2...");FirePx(st);task.wait(C.delay)
        end
    end
    SLbl:Set("Cycle done. Repeating...");task.wait(0.1)
end

----------------------------------------------------------------
-- CURRENCY
----------------------------------------------------------------
local function CurrCycle()
    if not IndexReady then task.wait(1);return end
    if not IsAlive() then task.wait(1.5);return end
    local found={}
    for o in pairs(CurrSet) do
        if o.Parent then found[#found+1]=o else CurrSet[o]=nil end
    end
    if #found==0 then task.wait(2);return end
    local r=Root()
    local sv=r.CFrame
    for _,o in ipairs(found) do
        if not C.cur then break end
        local p=GetPos(o)
        if p then
            if not SafeTp(p) then return end
            FirePx(o);task.wait(0.15)
        end
    end
    local r2=Root()
    if r2 then r2.CFrame=sv end
end

----------------------------------------------------------------
-- MANUAL COLLECT
----------------------------------------------------------------
local function ManCollect(name)
    local r=Root()
    if not r or not IsAlive() then RF:Notify({Title="Error",Content="No character.",Duration=2});return end
    if not IndexReady then RF:Notify({Title="Wait",Content="Map still indexing.",Duration=2});return end
    local sv=r.CFrame
    local o=NearestOre(name,{})
    if not o then RF:Notify({Title="Not Found",Content=name.." not on map (or monsters nearby).",Duration=2});return end
    local pos=GetPos(o);if not pos then return end
    if not SafeTp(pos) then return end
    FirePx(o);task.wait(0.3)
    if C.ret then
        local r2=Root()
        if r2 then r2.CFrame=sv end
    end
    RF:Notify({Title="Collected",Content=name.." collected.",Duration=2})
end

----------------------------------------------------------------
-- NOCLIP
----------------------------------------------------------------
local NocConn
local function SetNoclip(v)
    C.noclip=v
    if v then
        NocConn=RS.Stepped:Connect(function()
            local ch=LP.Character
            if ch then for _,p in ipairs(ch:GetDescendants()) do if p:IsA("BasePart") then p.CanCollide=false end end end
        end)
    else
        if NocConn then NocConn:Disconnect();NocConn=nil end
        local ch=LP.Character
        if ch then for _,p in ipairs(ch:GetDescendants()) do if p:IsA("BasePart") then p.CanCollide=true end end end
    end
end

----------------------------------------------------------------
-- FLY
----------------------------------------------------------------
local FlyC,FlyBV,FlyAt
local function SetFly(v)
    C.fly=v
    if v then
        local ch=LP.Character;local rt=Root()
        if not rt or not ch then return end
        local hm=ch:FindFirstChildOfClass("Humanoid")
        if hm then hm.PlatformStand=true end
        FlyAt=Instance.new("Attachment",rt)
        FlyBV=Instance.new("BodyVelocity",rt)
        FlyBV.MaxForce=Vector3.new(1e5,1e5,1e5);FlyBV.Velocity=Vector3.zero
        FlyC=RS.Heartbeat:Connect(function()
            if not FlyBV or not FlyBV.Parent then SetFly(false);return end
            local cm=CAM.CFrame;local vl=Vector3.zero
            if UIS:IsKeyDown(Enum.KeyCode.W) then vl=vl+cm.LookVector end
            if UIS:IsKeyDown(Enum.KeyCode.S) then vl=vl-cm.LookVector end
            if UIS:IsKeyDown(Enum.KeyCode.A) then vl=vl-cm.RightVector end
            if UIS:IsKeyDown(Enum.KeyCode.D) then vl=vl+cm.RightVector end
            if UIS:IsKeyDown(Enum.KeyCode.Space) then vl=vl+Vector3.new(0,1,0) end
            if UIS:IsKeyDown(Enum.KeyCode.LeftControl) then vl=vl-Vector3.new(0,1,0) end
            FlyBV.Velocity=vl*50
        end)
    else
        if FlyC then FlyC:Disconnect();FlyC=nil end
        if FlyBV then FlyBV:Destroy();FlyBV=nil end
        if FlyAt then FlyAt:Destroy();FlyAt=nil end
        local ch=LP.Character
        if ch then local hm=ch:FindFirstChildOfClass("Humanoid");if hm then hm.PlatformStand=false end end
    end
end

----------------------------------------------------------------
-- ANTI AFK
----------------------------------------------------------------
local AfkT
local function SetAFK(v)
    C.afk=v
    if v then
        AfkT=task.spawn(function()
            while C.afk do
                task.wait(60)
                if not C.afk then break end
                local ch=LP.Character
                if ch then
                    local hm=ch:FindFirstChildOfClass("Humanoid")
                    if hm then hm.Jump=true end
                end
            end
        end)
    else
        if AfkT then task.cancel(AfkT);AfkT=nil end
    end
end

----------------------------------------------------------------
-- FULLBRIGHT (ver en lugares oscuros)
----------------------------------------------------------------
local Lighting=game:GetService("Lighting")
local FB_TARGET={
    Brightness=2,
    ClockTime=14,
    FogEnd=1e5,
    GlobalShadows=false,
    Ambient=Color3.fromRGB(178,178,178),
    OutdoorAmbient=Color3.fromRGB(178,178,178),
}
local FB_ORIG={}
local FB_ATM={}
local FB_HOOKED=false

local function FBAtmo(a)
    if a:IsA("Atmosphere") then
        if not FB_ATM[a] then FB_ATM[a]={a.Density,a.Haze} end
        a.Density=0;a.Haze=0
    end
end

local function SetFullbright(v)
    C.fb=v
    if v then
        for k,val in pairs(FB_TARGET) do
            if FB_ORIG[k]==nil then FB_ORIG[k]=Lighting[k] end
            Lighting[k]=val
        end
        for _,c in ipairs(Lighting:GetChildren()) do FBAtmo(c) end
        if not FB_HOOKED then
            FB_HOOKED=true
            -- si el juego vuelve a oscurecer la iluminacion, se corrige al instante
            for k,val in pairs(FB_TARGET) do
                Lighting:GetPropertyChangedSignal(k):Connect(function()
                    if C.fb and Lighting[k]~=val then Lighting[k]=val end
                end)
            end
            Lighting.ChildAdded:Connect(function(c) if C.fb then FBAtmo(c) end end)
        end
    else
        for k,val in pairs(FB_ORIG) do Lighting[k]=val end
        FB_ORIG={}
        for a,vals in pairs(FB_ATM) do
            if a.Parent then a.Density=vals[1];a.Haze=vals[2] end
        end
        FB_ATM={}
    end
end

----------------------------------------------------------------
-- SPECTATE
----------------------------------------------------------------
local SpecName,SpecDD,SpecLbl
local SpecActive=false

local function PlayerNames()
    local t={}
    for _,p in ipairs(PL:GetPlayers()) do
        if p~=LP then t[#t+1]=p.Name end
    end
    table.sort(t)
    return t
end

local function StopSpectate()
    SpecActive=false
    local cam=WS.CurrentCamera
    local ch=LP.Character
    local h=ch and ch:FindFirstChildOfClass("Humanoid")
    if cam and h then cam.CameraSubject=h end
    if SpecLbl then SpecLbl:Set("Spectating: nobody") end
end

local function StartSpectate()
    local p=SpecName and PL:FindFirstChild(SpecName)
    if not p then
        RF:Notify({Title="Spectate",Content="Select a player first.",Duration=2})
        return
    end
    SpecActive=true
    SpecLbl:Set("Spectating: "..p.Name)
    local h=p.Character and p.Character:FindFirstChildOfClass("Humanoid")
    local cam=WS.CurrentCamera
    if h and cam then cam.CameraSubject=h end
end

-- Si el jugador reaparece o el juego cambia la camara, se vuelve a enfocar; si sale, se deja de espectear
task.spawn(function()
    while true do
        task.wait(0.4)
        if SpecActive then
            local p=SpecName and PL:FindFirstChild(SpecName)
            if not p then
                StopSpectate()
                RF:Notify({Title="Spectate",Content="Player left the server.",Duration=3})
            else
                local h=p.Character and p.Character:FindFirstChildOfClass("Humanoid")
                local cam=WS.CurrentCamera
                if h and cam and cam.CameraSubject~=h then cam.CameraSubject=h end
            end
        end
    end
end)

local function RefreshPlayers()
    if SpecDD then pcall(function() SpecDD:Refresh(PlayerNames()) end) end
end
PL.PlayerAdded:Connect(function() task.wait(0.5);RefreshPlayers() end)
PL.PlayerRemoving:Connect(function(p)
    if p.Name==SpecName and SpecActive then StopSpectate() end
    task.wait(0.2);RefreshPlayers()
end)

----------------------------------------------------------------
-- MAIN TAB
----------------------------------------------------------------
local NocToggle,FlyToggle -- se crean mas abajo (el autofarm los apaga)

TMain:CreateSection("Status")
SLbl=TMain:CreateLabel("Status: Idle")
CLbl=TMain:CreateLabel("Ores on Map: Scanning...")
TMain:CreateSection("Autofarm")
TMain:CreateToggle({Name="Autofarm Ores",CurrentValue=false,Flag="AFarm",Callback=function(v)
    C.farm=v
    if v then
        -- Noclip y Fly hacen que te caigas del mapa o que el TP falle: se apagan al iniciar
        if C.noclip and NocToggle then NocToggle:Set(false) end
        if C.fly and FlyToggle then FlyToggle:Set(false) end
        RF:Notify({Title="Autofarm",Content="Started.",Duration=2})
        task.spawn(function()
            while C.farm do
                pcall(FarmCycle)
                task.wait() -- siempre cede el hilo (evita congelar el juego si un ciclo termina al instante)
            end
            SLbl:Set("Status: Idle")
        end)
    else
        RF:Notify({Title="Autofarm",Content="Stopped.",Duration=2})
    end
end})
TMain:CreateSection("Manual Collect")
for _,n in ipairs(ORES) do
    local nm=n
    TMain:CreateButton({Name=nm,Callback=function() task.spawn(function() ManCollect(nm) end) end})
end

----------------------------------------------------------------
-- ESP TAB
----------------------------------------------------------------
TESP:CreateSection("Monster ESP")
TESP:CreateToggle({Name="Monster ESP",CurrentValue=false,Flag="mESP",Callback=function(v)
    C.mESP=v
    if not v then ClearESP("m") end
end})
TESP:CreateColorPicker({Name="Monster Color",Color=Color3.fromRGB(255,50,50),Flag="mCol",Callback=function(c)
    C.mCol=c
    for _,e in pairs(ESPTbl) do if e.cat=="m" then e.h.FillColor=c end end
end})
TESP:CreateSection("Ore ESP")
TESP:CreateToggle({Name="Ore ESP",CurrentValue=false,Flag="oESP",Callback=function(v)
    C.oESP=v
    if not v then ClearESP("o") end
end})
TESP:CreateColorPicker({Name="Ore Color",Color=Color3.fromRGB(50,200,255),Flag="oCol",Callback=function(c)
    C.oCol=c
    for _,e in pairs(ESPTbl) do if e.cat=="o" then e.h.FillColor=c end end
end})
TESP:CreateSection("Player ESP")
TESP:CreateToggle({Name="Player ESP",CurrentValue=false,Flag="pESP",Callback=function(v)
    C.pESP=v
    if not v then ClearESP("p") end
end})
TESP:CreateColorPicker({Name="Player Color",Color=Color3.fromRGB(255,255,50),Flag="pCol",Callback=function(c)
    C.pCol=c
    for _,e in pairs(ESPTbl) do if e.cat=="p" then e.h.FillColor=c end end
end})
TESP:CreateSection("Options")
TESP:CreateToggle({Name="Show Names",CurrentValue=true,Flag="shN",Callback=function(v) C.names=v end})
TESP:CreateToggle({Name="Show Distance",CurrentValue=true,Flag="shD",Callback=function(v) C.dist=v end})
TESP:CreateSlider({Name="ESP Max Distance",Range={100,3000},Increment=50,Suffix=" studs",CurrentValue=500,Flag="espD",Callback=function(v) C.espDist=v end})
TESP:CreateSlider({Name="Max Targets per ESP",Range={3,12},Increment=1,Suffix="",CurrentValue=8,Flag="espM",Callback=function(v) C.espMax=v end})
TESP:CreateButton({Name="Clear All ESP",Callback=function() ClearESP();RF:Notify({Title="ESP",Content="All cleared.",Duration=2}) end})

----------------------------------------------------------------
-- CURRENCY TAB
----------------------------------------------------------------
TCurr:CreateSection("Auto Currency")
TCurr:CreateToggle({Name="Auto Collect Currency",CurrentValue=false,Flag="ACurr",Callback=function(v)
    C.cur=v
    if v then
        RF:Notify({Title="Currency",Content="Started.",Duration=2})
        task.spawn(function() while C.cur do pcall(CurrCycle);task.wait(1) end end)
    else
        RF:Notify({Title="Currency",Content="Stopped.",Duration=2})
    end
end})
TCurr:CreateButton({Name="Collect Currency Now",Callback=function()
    task.spawn(function() pcall(CurrCycle);RF:Notify({Title="Currency",Content="Done.",Duration=2}) end)
end})
TCurr:CreateSection("Info")
TCurr:CreateLabel("Scans: coins, cash, gems, tokens, bucks")

----------------------------------------------------------------
-- SPECTATE TAB
----------------------------------------------------------------
TSpec:CreateSection("Select Player")
SpecLbl=TSpec:CreateLabel("Spectating: nobody")
SpecDD=TSpec:CreateDropdown({Name="Player",Options=PlayerNames(),CurrentOption={},MultipleOptions=false,Flag="SpecP",Callback=function(opt)
    SpecName=type(opt)=="table" and opt[1] or opt
end})
TSpec:CreateButton({Name="Refresh Player List",Callback=RefreshPlayers})
TSpec:CreateSection("Camera")
TSpec:CreateButton({Name="Spectate",Callback=StartSpectate})
TSpec:CreateButton({Name="Stop Spectating",Callback=function()
    StopSpectate()
    RF:Notify({Title="Spectate",Content="Camera restored.",Duration=2})
end})

----------------------------------------------------------------
-- EXTRAS TAB
----------------------------------------------------------------
TExtra:CreateSection("Movement")
TExtra:CreateSlider({Name="Walk Speed",Range={16,150},Increment=1,Suffix="",CurrentValue=16,Flag="WSpd",Callback=function(v)
    ApplySpeed(v,nil)
end})
TExtra:CreateSlider({Name="Jump Power",Range={50,300},Increment=5,Suffix="",CurrentValue=50,Flag="JmpP",Callback=function(v)
    ApplySpeed(nil,v)
end})
TExtra:CreateToggle({Name="Lock WalkSpeed / JumpPower",CurrentValue=true,Flag="LockSpd",Callback=function(v) C.lockSpd=v end})
TExtra:CreateSection("Interaction")
TExtra:CreateToggle({Name="Instant ProximityPrompt",CurrentValue=false,Flag="InstPP",Callback=function(v)
    SetInstant(v)
    RF:Notify({Title="ProximityPrompt",Content=v and "Instant: ON" or "Instant: OFF",Duration=2})
end})
TExtra:CreateSection("Visual")
TExtra:CreateToggle({Name="Fullbright",CurrentValue=false,Flag="FB",Callback=function(v) SetFullbright(v) end})
TExtra:CreateSection("Character")
NocToggle=TExtra:CreateToggle({Name="Noclip",CurrentValue=false,Flag="Noc",Callback=function(v) SetNoclip(v) end})
FlyToggle=TExtra:CreateToggle({Name="Fly (WASD + Space/Ctrl)",CurrentValue=false,Flag="FlyT",Callback=function(v) SetFly(v) end})
TExtra:CreateSection("Utility")
TExtra:CreateToggle({Name="Anti-AFK",CurrentValue=false,Flag="AFK",Callback=function(v) SetAFK(v) end})
TExtra:CreateButton({Name="Rejoin Server",Callback=function()
    game:GetService("TeleportService"):Teleport(game.PlaceId,LP)
end})
TExtra:CreateButton({Name="Reset Character",Callback=function()
    local ch=LP.Character
    if ch then local h=ch:FindFirstChildOfClass("Humanoid");if h then h.Health=0 end end
end})
TExtra:CreateButton({Name="Teleport to Spawn",Callback=function()
    local r=Root();if not r then return end
    for _,o in ipairs(WS:GetDescendants()) do
        if o:IsA("SpawnLocation") then SafeTp(o.Position);return end
    end
    RF:Notify({Title="Error",Content="No spawn found.",Duration=2})
end})

----------------------------------------------------------------
-- SETTINGS TAB
----------------------------------------------------------------
TSet:CreateSection("Autofarm Speed")
TSet:CreateSlider({Name="Farm Speed (1=Fast 20=Slow)",Range={1,20},Increment=1,Suffix="",CurrentValue=10,Flag="FSpd",Callback=function(v)
    C.delay=v/10
end})
TSet:CreateSection("Safety")
TSet:CreateToggle({Name="Avoid Ores Near Monsters",CurrentValue=true,Flag="Avoid",Callback=function(v) C.avoid=v end})
TSet:CreateSlider({Name="Monster Safe Distance",Range={10,100},Increment=5,Suffix=" studs",CurrentValue=35,Flag="AvoidD",Callback=function(v) C.avoidDist=v end})
TSet:CreateSection("Ore Count Refresh")
TSet:CreateToggle({Name="Auto Refresh Ore Count",CurrentValue=true,Flag="RefT",Callback=function(v) C.ref=v end})
TSet:CreateSection("Manual Collect")
TSet:CreateToggle({Name="Return After Collect",CurrentValue=true,Flag="RetT",Callback=function(v) C.ret=v end})
TSet:CreateSection("Utility")
TSet:CreateButton({Name="Go to SellStation",Callback=function()
    local s=FindSell()
    if s then local p=GetPos(s);if p then SafeTp(p);return end end
    RF:Notify({Title="Error",Content="SellStation not found.",Duration=3})
end})

----------------------------------------------------------------
-- CONTADOR DE MENAS (usa el indice, ya no recorre todo el mapa)
----------------------------------------------------------------
local function RefreshCount()
    local seen,ct={},0
    for o,n in pairs(OreSet) do
        if o.Parent and not seen[n] then seen[n]=true;ct=ct+1 end
    end
    CLbl:Set("Ores on Map: "..ct.." / "..#ORES.." types")
end

task.spawn(function()
    WaitIndex()
    RefreshCount()
    while true do
        task.wait(10)
        if C.ref and not C.farm then
            RefreshCount()
            SLbl:Set("Status: Idle | "..os.date("%H:%M:%S"))
        end
    end
end)

RF:Notify({Title="FATAL FLOORS HUB",Content="Loaded! All systems ready.",Duration=4})