-- ╔══════════════════════════════════════════════════════════╗
-- ║       FORESTO: HUNTING GAME  —  Script v4               ║
-- ║  Fixed: ESP for all animals (spawned + new), aimbot     ║
-- ║  priority system, player ESP, no errors, no lag         ║
-- ╚══════════════════════════════════════════════════════════╝

-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-- SECTION 1 — RAYFIELD LOAD
-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
local Rayfield = loadstring(game:HttpGet("https://sirius.menu/rayfield"))()

-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-- SECTION 2 — SERVICES
-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
local Players          = game:GetService("Players")
local RunService       = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local Workspace        = game:GetService("Workspace")
local LocalPlayer      = Players.LocalPlayer

-- Camera is re-read every frame so it's always current
local function GetCamera()
    return Workspace.CurrentCamera
end

-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-- SECTION 3 — SETTINGS
-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
local S = {
    -- Aimbot
    AnimalAimbot  = false,
    PlayerAimbot  = false,
    -- Priority: "Animal" = prefer animal, "Player" = prefer player, "Closest" = whoever is closer to crosshair
    AimbotPriority = "Closest",
    AimbotFOV     = 150,
    AimbotSmooth  = 0.10,
    AimbotPart    = "Head",
    AimbotKey     = Enum.UserInputType.MouseButton2,
    ShowFOV       = true,

    -- ESP
    AnimalESP     = false,
    PlayerESP     = false,
    ESPBoxes      = true,
    ESPCorner     = false,
    ESPNames      = true,
    ESPDist       = true,
    ESPHealth     = true,
    ESPTracer     = false,
    ESPTracerSrc  = "Bottom",
    ESPMaxDist    = 1500,
    ESPRate       = 2,    -- update every N frames

    -- Colors
    AnimalColor   = Color3.fromRGB(255, 170, 0),
    PlayerColor   = Color3.fromRGB(220, 50,  50),
}

-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-- SECTION 4 — UTILITY
-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

local function SafeCall(fn, ...)
    local ok, err = pcall(fn, ...)
    if not ok then
        -- silently swallow errors so the script never crashes
    end
end

local function GetRoot(model)
    if not model then return nil end
    return model:FindFirstChild("HumanoidRootPart")
        or model:FindFirstChild("UpperTorso")
        or model:FindFirstChild("Torso")
end

local function GetHumanoid(model)
    if not model then return nil end
    return model:FindFirstChildOfClass("Humanoid")
end

local function IsAlive(model)
    if not model or not model.Parent then return false end
    local h = GetHumanoid(model)
    return h ~= nil and h.Health > 0
end

-- World to Screen — returns screenPos (Vector2), onScreen (bool), depth (number)
local function W2S(pos)
    local cam = GetCamera()
    if not cam then return Vector2.new(0, 0), false, -1 end
    local sp, on = cam:WorldToViewportPoint(pos)
    return Vector2.new(sp.X, sp.Y), on, sp.Z
end

local function ScreenMid()
    local cam = GetCamera()
    if not cam then return Vector2.new(960, 540) end
    return Vector2.new(cam.ViewportSize.X / 2, cam.ViewportSize.Y / 2)
end

-- Compute a simple bounding box from root position + estimated height
-- Returns TL, BR, centerX, rootWorldPos  OR  nil if off screen / behind cam
local function GetBounds(model)
    local root = GetRoot(model)
    if not root then return nil end

    local pos  = root.Position
    local hum  = GetHumanoid(model)
    -- HipHeight gives half the standing height; add ~2.5 for upper body
    local half = math.max((hum and hum.HipHeight or 2) + 2.5, 3)

    local topSP, topOn, topZ = W2S(pos + Vector3.new(0,  half * 1.05, 0))
    local botSP, botOn, botZ = W2S(pos - Vector3.new(0,  half * 0.55, 0))

    -- Reject if both off screen or if target is behind camera
    if topZ <= 0 and botZ <= 0 then return nil end
    if not topOn and not botOn  then return nil end

    -- If only one is on screen, mirror from the other
    if not topOn then topSP = Vector2.new(botSP.X, botSP.Y - 2) end
    if not botOn then botSP = Vector2.new(topSP.X, topSP.Y + 2) end

    local height = math.abs(botSP.Y - topSP.Y)
    local width  = math.max(height * 0.5, 16)
    local cx     = topSP.X

    local TL = Vector2.new(cx - width, topSP.Y)
    local BR = Vector2.new(cx + width, botSP.Y)
    return TL, BR, cx, pos
end

-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-- SECTION 5 — ANIMAL REGISTRY
-- Tracks ALL NPC models (not player chars) that have a
-- Humanoid.  Works for already-spawned + newly spawned.
-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

-- Set of all registered animal models  { [model] = true }
local Animals = {}

-- Player character lookup (fast set, updated on char changes)
local PlayerChars = {}

local function RebuildPlayerChars()
    PlayerChars = {}
    for _, p in ipairs(Players:GetPlayers()) do
        if p.Character then
            PlayerChars[p.Character] = true
        end
    end
end
RebuildPlayerChars()

Players.PlayerAdded:Connect(function(p)
    p.CharacterAdded:Connect(function(c)
        PlayerChars[c] = true
        -- Make sure new player char doesn't end up in Animals
        Animals[c] = nil
    end)
    p.CharacterRemoving:Connect(function(c)
        PlayerChars[c] = nil
    end)
end)

-- Also hook existing players
for _, p in ipairs(Players:GetPlayers()) do
    p.CharacterAdded:Connect(function(c)
        PlayerChars[c] = true
        Animals[c] = nil
    end)
    p.CharacterRemoving:Connect(function(c)
        PlayerChars[c] = nil
    end)
end

-- Check if a model qualifies as an animal NPC
local function IsAnimalNPC(model)
    if not model or not model:IsA("Model") then return false end
    if PlayerChars[model] then return false end
    -- Must have a Humanoid
    local h = GetHumanoid(model)
    if not h then return false end
    -- Must have a physical root
    if not GetRoot(model) then return false end
    return true
end

-- Register a model if it qualifies
local function TryAdd(model)
    if not model or Animals[model] then return end
    -- Defer to let the model finish parenting
    task.defer(function()
        if model and model.Parent and IsAnimalNPC(model) then
            Animals[model] = true
        end
    end)
end

-- Initial scan
for _, d in ipairs(Workspace:GetDescendants()) do
    if d:IsA("Model") then TryAdd(d) end
end

-- Watch for new descendants
Workspace.DescendantAdded:Connect(function(d)
    -- When a Model is added directly
    if d:IsA("Model") then
        TryAdd(d)
    end
    -- When a Humanoid is added inside a Model (common for streaming)
    if d:IsA("Humanoid") then
        local parent = d.Parent
        if parent and parent:IsA("Model") then
            TryAdd(parent)
        end
    end
    -- When HumanoidRootPart is added (another streaming trigger)
    if d.Name == "HumanoidRootPart" and d:IsA("BasePart") then
        local parent = d.Parent
        if parent and parent:IsA("Model") then
            TryAdd(parent)
        end
    end
end)

-- Remove from registry when model is destroyed / removed
Workspace.DescendantRemoving:Connect(function(d)
    if d:IsA("Model") then
        Animals[d] = nil
    end
end)

-- Background cleanup: remove dead/gone animals every 3 seconds
task.spawn(function()
    while task.wait(3) do
        for model in pairs(Animals) do
            if not model or not model.Parent then
                Animals[model] = nil
            end
        end
        RebuildPlayerChars()
    end
end)

-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-- SECTION 6 — DRAWING ESP ENGINE
-- Pure Drawing API, no BillboardGui, no Instance overhead
-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

local Pool = {}   -- key -> drawing table

local WHITE  = Color3.fromRGB(255,255,255)
local DARK   = Color3.fromRGB(20,20,20)
local GREEN  = Color3.fromRGB(80,220,60)

local function MakeLine(col, thick)
    local d         = Drawing.new("Line")
    d.Visible       = false
    d.Color         = col or WHITE
    d.Thickness     = thick or 1.5
    d.ZIndex        = 5
    return d
end

local function MakeText(col, sz)
    local d       = Drawing.new("Text")
    d.Visible     = false
    d.Color       = col or WHITE
    d.Size        = sz or 13
    d.Outline     = true
    d.Center      = true
    d.ZIndex      = 6
    return d
end

local function PoolCreate(key, col)
    if Pool[key] then return end
    Pool[key] = {
        -- Box (4 lines)
        bT = MakeLine(col), bB = MakeLine(col),
        bL = MakeLine(col), bR = MakeLine(col),
        -- Tracer
        tr = MakeLine(col, 1.2),
        -- Labels
        nm = MakeText(col, 13),
        ds = MakeText(WHITE, 11),
        hpT = MakeText(GREEN, 11),
        -- HP bar
        hpBg  = MakeLine(DARK, 5),
        hpFg  = MakeLine(GREEN, 3),
    }
end

local function PoolHide(key)
    local e = Pool[key]
    if not e then return end
    e.bT.Visible=false; e.bB.Visible=false
    e.bL.Visible=false; e.bR.Visible=false
    e.tr.Visible=false
    e.nm.Visible=false; e.ds.Visible=false; e.hpT.Visible=false
    e.hpBg.Visible=false; e.hpFg.Visible=false
end

local function PoolDestroy(key)
    local e = Pool[key]
    if not e then return end
    SafeCall(function()
        e.bT:Remove(); e.bB:Remove(); e.bL:Remove(); e.bR:Remove()
        e.tr:Remove()
        e.nm:Remove(); e.ds:Remove(); e.hpT:Remove()
        e.hpBg:Remove(); e.hpFg:Remove()
    end)
    Pool[key] = nil
end

local function PoolClear()
    for k in pairs(Pool) do PoolDestroy(k) end
end

local V2 = Vector2.new

local function DrawBox(e, L,R,T,B, col)
    e.bT.From=V2(L,T); e.bT.To=V2(R,T); e.bT.Color=col; e.bT.Visible=true
    e.bB.From=V2(L,B); e.bB.To=V2(R,B); e.bB.Color=col; e.bB.Visible=true
    e.bL.From=V2(L,T); e.bL.To=V2(L,B); e.bL.Color=col; e.bL.Visible=true
    e.bR.From=V2(R,T); e.bR.To=V2(R,B); e.bR.Color=col; e.bR.Visible=true
end

local CLEN = 0.22  -- corner length fraction

local function DrawCornerBox(e, L,R,T,B, col)
    local cw = (R-L)*CLEN
    local ch = (B-T)*CLEN
    -- Top-left
    e.bT.From=V2(L,T);     e.bT.To=V2(L+cw,T); e.bT.Color=col; e.bT.Visible=true
    e.bL.From=V2(L,T);     e.bL.To=V2(L,T+ch); e.bL.Color=col; e.bL.Visible=true
    -- Bottom-right
    e.bB.From=V2(R-cw,B);  e.bB.To=V2(R,B);    e.bB.Color=col; e.bB.Visible=true
    e.bR.From=V2(R,B-ch);  e.bR.To=V2(R,B);    e.bR.Color=col; e.bR.Visible=true
end

-- Render one ESP entry (called per frame per visible target)
local function RenderEntry(key, model, humanoid, label, col)
    local e = Pool[key]
    if not e then return end

    -- Bounds
    local TL, BR, cx, rootPos = GetBounds(model)
    if not TL then PoolHide(key); return end

    -- Distance check
    local lroot = GetRoot(LocalPlayer.Character)
    local dist  = 0
    if lroot and rootPos then
        dist = math.floor((lroot.Position - rootPos).Magnitude)
    end
    if dist > S.ESPMaxDist then PoolHide(key); return end

    local L, T = TL.X, TL.Y
    local R, B = BR.X, BR.Y

    -- ── BOX
    if S.ESPBoxes then
        if S.ESPCorner then
            DrawCornerBox(e, L,R,T,B, col)
        else
            DrawBox(e, L,R,T,B, col)
        end
    else
        e.bT.Visible=false; e.bB.Visible=false
        e.bL.Visible=false; e.bR.Visible=false
    end

    -- ── TRACER
    if S.ESPTracer then
        local cam = GetCamera()
        local src
        if S.ESPTracerSrc == "Center" then
            src = ScreenMid()
        else
            src = V2(cam.ViewportSize.X/2, cam.ViewportSize.Y)
        end
        e.tr.From=src; e.tr.To=V2(cx, B); e.tr.Color=col; e.tr.Visible=true
    else
        e.tr.Visible=false
    end

    -- ── NAME
    if S.ESPNames then
        e.nm.Text=label; e.nm.Color=col
        e.nm.Position=V2(cx, T-16); e.nm.Visible=true
    else
        e.nm.Visible=false
    end

    -- ── DISTANCE
    if S.ESPDist then
        e.ds.Text=dist.."m"; e.ds.Position=V2(cx, B+3); e.ds.Visible=true
    else
        e.ds.Visible=false
    end

    -- ── HEALTH BAR
    if S.ESPHealth and humanoid then
        local maxHp = math.max(humanoid.MaxHealth, 1)
        local hp    = math.clamp(humanoid.Health / maxHp, 0, 1)
        local bx    = L - 7
        local fillY = T + (B-T)*(1-hp)
        local hcol  = Color3.fromRGB(math.floor(255*(1-hp)), math.floor(255*hp), 0)

        e.hpBg.From=V2(bx,T);    e.hpBg.To=V2(bx,B);     e.hpBg.Visible=true
        e.hpFg.From=V2(bx,fillY);e.hpFg.To=V2(bx,B);
        e.hpFg.Color=hcol;        e.hpFg.Visible=true

        e.hpT.Text=math.floor(hp*100).."%"
        e.hpT.Color=hcol
        e.hpT.Position=V2(bx, T-14); e.hpT.Visible=true
    else
        e.hpBg.Visible=false; e.hpFg.Visible=false; e.hpT.Visible=false
    end
end

-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-- SECTION 7 — FOV CIRCLE
-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

local FovCircle       = Drawing.new("Circle")
FovCircle.Thickness   = 1.5
FovCircle.Color       = WHITE
FovCircle.Filled      = false
FovCircle.NumSides    = 64
FovCircle.Radius      = S.AimbotFOV
FovCircle.Visible     = false

-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-- SECTION 8 — AIMBOT
-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

local function AimHeld()
    local k = S.AimbotKey
    if not k then return false end
    -- pcall to safely handle any enum weirdness
    local ok, result = pcall(function()
        if k.EnumType == Enum.UserInputType then
            return UserInputService:IsMouseButtonPressed(k)
        elseif k.EnumType == Enum.KeyCode then
            return UserInputService:IsKeyDown(k)
        end
        return false
    end)
    return ok and result or false
end

-- Find the closest part to screen center within FOV
-- iterList: list of { part = BasePart }
local function FindBest(candidates)
    local best, bestDist = nil, math.huge
    local mid = ScreenMid()

    for _, cand in ipairs(candidates) do
        local part = cand.part
        if part and part.Parent then
            local sp, on, depth = W2S(part.Position)
            if on and depth > 0 then
                local d = (sp - mid).Magnitude
                if d < S.AimbotFOV and d < bestDist then
                    bestDist = d
                    best = part
                end
            end
        end
    end
    return best
end

-- Build candidate list from animals
local function AnimalCandidates()
    local list = {}
    for model in pairs(Animals) do
        if model and model.Parent and IsAlive(model) then
            local part = model:FindFirstChild(S.AimbotPart)
                      or model:FindFirstChild("Head")
                      or GetRoot(model)
            if part then
                table.insert(list, {part = part})
            end
        end
    end
    return list
end

-- Build candidate list from players
local function PlayerCandidates()
    local list = {}
    for _, p in ipairs(Players:GetPlayers()) do
        if p ~= LocalPlayer and p.Character and IsAlive(p.Character) then
            local char = p.Character
            local part = char:FindFirstChild(S.AimbotPart)
                      or char:FindFirstChild("Head")
                      or GetRoot(char)
            if part then
                table.insert(list, {part = part})
            end
        end
    end
    return list
end

local function SmoothAim(part)
    if not part or not part.Parent then return end
    local cam = GetCamera()
    if not cam then return end
    SafeCall(function()
        local dir  = (part.Position - cam.CFrame.Position).Unit
        local goal = CFrame.new(cam.CFrame.Position, cam.CFrame.Position + dir)
        cam.CFrame = cam.CFrame:Lerp(goal, S.AimbotSmooth)
    end)
end

-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-- SECTION 9 — MAIN LOOP
-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

local frame       = 0
local prevAnKeys  = {}
local prevPlKeys  = {}

RunService.RenderStepped:Connect(function()
    frame = frame + 1
    local doESP = (frame % math.max(S.ESPRate, 1) == 0)

    -- ── FOV Circle
    local eitherAimbot = S.AnimalAimbot or S.PlayerAimbot
    FovCircle.Position = ScreenMid()
    FovCircle.Radius   = S.AimbotFOV
    FovCircle.Visible  = S.ShowFOV and eitherAimbot

    -- ── AIMBOT
    if AimHeld() then
        -- Gather candidates per enabled toggle
        local anCands = S.AnimalAimbot and AnimalCandidates() or {}
        local plCands = S.PlayerAimbot and PlayerCandidates() or {}

        -- Priority logic
        local target = nil
        if S.AimbotPriority == "Animal" then
            -- Try animals first, fall back to players
            target = FindBest(anCands)
            if not target then target = FindBest(plCands) end
        elseif S.AimbotPriority == "Player" then
            -- Try players first, fall back to animals
            target = FindBest(plCands)
            if not target then target = FindBest(anCands) end
        else
            -- "Closest" — merge both lists, pick globally closest
            local merged = {}
            for _, c in ipairs(anCands) do table.insert(merged, c) end
            for _, c in ipairs(plCands) do table.insert(merged, c) end
            target = FindBest(merged)
        end

        SmoothAim(target)
    end

    -- ── ESP (throttled by ESPRate)
    if not doESP then return end

    -- ANIMAL ESP
    local newAnKeys = {}
    if S.AnimalESP then
        for model in pairs(Animals) do
            if model and model.Parent then
                local hum = GetHumanoid(model)
                if hum and hum.Health > 0 then
                    local key = "an_" .. tostring(model)
                    newAnKeys[key] = true
                    if not Pool[key] then
                        PoolCreate(key, S.AnimalColor)
                    end
                    RenderEntry(key, model, hum, model.Name, S.AnimalColor)
                end
            end
        end
    end
    -- Destroy entries for despawned animals
    for key in pairs(prevAnKeys) do
        if not newAnKeys[key] then PoolDestroy(key) end
    end
    prevAnKeys = newAnKeys

    -- PLAYER ESP
    local newPlKeys = {}
    if S.PlayerESP then
        for _, p in ipairs(Players:GetPlayers()) do
            if p ~= LocalPlayer then
                local char = p.Character
                local key  = "pl_" .. tostring(p.UserId)
                newPlKeys[key] = true

                if char and IsAlive(char) then
                    if not Pool[key] then
                        PoolCreate(key, S.PlayerColor)
                    end
                    local hum = GetHumanoid(char)
                    RenderEntry(key, char, hum, p.Name, S.PlayerColor)
                else
                    PoolHide(key)
                end
            end
        end
    end
    -- Destroy entries for players who left
    for key in pairs(prevPlKeys) do
        if not newPlKeys[key] then PoolDestroy(key) end
    end
    prevPlKeys = newPlKeys
end)

-- Cleanup when a player leaves mid-session
Players.PlayerRemoving:Connect(function(p)
    local key = "pl_" .. tostring(p.UserId)
    PoolDestroy(key)
    prevPlKeys[key] = nil
end)

-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-- SECTION 10 — RAYFIELD UI
-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

local Window = Rayfield:CreateWindow({
    Name             = "Foresto Script",
    Icon             = 0,
    LoadingTitle     = "Foresto Script",
    LoadingSubtitle  = "v4 — Fixed & Upgraded",
    Theme            = "DarkBlue",
    DisableRayfieldPrompts = false,
    DisableBuildWarnings   = false,
    ConfigurationSaving    = {
        Enabled    = true,
        FolderName = "ForestoScriptV4",
        FileName   = "Config",
    },
    KeySystem = false,
})

-- ────────────────────────────────────────────────────────
-- TAB: AIMBOT
-- ────────────────────────────────────────────────────────
local TAbimbot = Window:CreateTab("Aimbot", 4483362458)

TAbimbot:CreateSection("Targets")

TAbimbot:CreateToggle({
    Name = "Animal Aimbot",
    CurrentValue = false, Flag = "AnimalAimbot",
    Callback = function(v) S.AnimalAimbot = v end,
})

TAbimbot:CreateToggle({
    Name = "Player Aimbot",
    CurrentValue = false, Flag = "PlayerAimbot",
    Callback = function(v) S.PlayerAimbot = v end,
})

TAbimbot:CreateDropdown({
    Name = "Priority (when both on)",
    Options = {"Closest", "Animal", "Player"},
    CurrentOption = {"Closest"}, MultipleOptions = false, Flag = "AimbotPriority",
    Callback = function(v)
        S.AimbotPriority = v[1] or "Closest"
    end,
})

TAbimbot:CreateSection("Settings")

TAbimbot:CreateSlider({
    Name = "FOV Radius",
    Range = {10, 600}, Increment = 5, Suffix = " px",
    CurrentValue = S.AimbotFOV, Flag = "AimbotFOV",
    Callback = function(v) S.AimbotFOV = v end,
})

TAbimbot:CreateSlider({
    Name = "Smoothing",
    Range = {1, 100}, Increment = 1, Suffix = "%",
    CurrentValue = math.floor(S.AimbotSmooth * 100), Flag = "AimbotSmooth",
    Callback = function(v) S.AimbotSmooth = v / 100 end,
})

TAbimbot:CreateDropdown({
    Name = "Target Part",
    Options = {"Head", "HumanoidRootPart", "UpperTorso", "Torso", "LeftUpperLeg", "RightUpperLeg"},
    CurrentOption = {"Head"}, MultipleOptions = false, Flag = "AimbotPart",
    Callback = function(v) S.AimbotPart = v[1] or "Head" end,
})

TAbimbot:CreateDropdown({
    Name = "Aim Key",
    Options = {"Right Click (RMB)", "Left Click (LMB)", "Q", "E", "LeftShift", "CapsLock"},
    CurrentOption = {"Right Click (RMB)"}, MultipleOptions = false, Flag = "AimbotKey",
    Callback = function(v)
        local opt = v[1] or "Right Click (RMB)"
        local map = {
            ["Right Click (RMB)"] = Enum.UserInputType.MouseButton2,
            ["Left Click (LMB)"]  = Enum.UserInputType.MouseButton1,
            ["Q"]                  = Enum.KeyCode.Q,
            ["E"]                  = Enum.KeyCode.E,
            ["LeftShift"]          = Enum.KeyCode.LeftShift,
            ["CapsLock"]           = Enum.KeyCode.CapsLock,
        }
        S.AimbotKey = map[opt] or Enum.UserInputType.MouseButton2
    end,
})

TAbimbot:CreateToggle({
    Name = "Show FOV Circle",
    CurrentValue = true, Flag = "ShowFOV",
    Callback = function(v) S.ShowFOV = v end,
})

-- ────────────────────────────────────────────────────────
-- TAB: ESP
-- ────────────────────────────────────────────────────────
local TEsp = Window:CreateTab("ESP", 4483362458)

TEsp:CreateSection("Enable")

TEsp:CreateToggle({
    Name = "Animal ESP",
    CurrentValue = false, Flag = "AnimalESP",
    Callback = function(v)
        S.AnimalESP = v
        if not v then
            for key in pairs(prevAnKeys) do PoolHide(key) end
        end
    end,
})

TEsp:CreateToggle({
    Name = "Player ESP",
    CurrentValue = false, Flag = "PlayerESP",
    Callback = function(v)
        S.PlayerESP = v
        if not v then
            for key in pairs(prevPlKeys) do PoolHide(key) end
        end
    end,
})

TEsp:CreateSection("Box")

TEsp:CreateToggle({
    Name = "Show Box",
    CurrentValue = true, Flag = "ESPBoxes",
    Callback = function(v) S.ESPBoxes = v end,
})

TEsp:CreateToggle({
    Name = "Corner Box Style",
    CurrentValue = false, Flag = "ESPCorner",
    Callback = function(v) S.ESPCorner = v end,
})

TEsp:CreateSection("Labels")

TEsp:CreateToggle({
    Name = "Show Names",
    CurrentValue = true, Flag = "ESPNames",
    Callback = function(v) S.ESPNames = v end,
})

TEsp:CreateToggle({
    Name = "Show Distance",
    CurrentValue = true, Flag = "ESPDist",
    Callback = function(v) S.ESPDist = v end,
})

TEsp:CreateToggle({
    Name = "Show Health Bar",
    CurrentValue = true, Flag = "ESPHealth",
    Callback = function(v) S.ESPHealth = v end,
})

TEsp:CreateSection("Tracer")

TEsp:CreateToggle({
    Name = "Tracer Line",
    CurrentValue = false, Flag = "ESPTracer",
    Callback = function(v) S.ESPTracer = v end,
})

TEsp:CreateDropdown({
    Name = "Tracer Origin",
    Options = {"Bottom", "Center"},
    CurrentOption = {"Bottom"}, MultipleOptions = false, Flag = "ESPTracerSrc",
    Callback = function(v) S.ESPTracerSrc = v[1] or "Bottom" end,
})

TEsp:CreateSection("Distance & Performance")

TEsp:CreateSlider({
    Name = "Max Render Distance",
    Range = {100, 5000}, Increment = 100, Suffix = " m",
    CurrentValue = S.ESPMaxDist, Flag = "ESPMaxDist",
    Callback = function(v) S.ESPMaxDist = v end,
})

TEsp:CreateSlider({
    Name = "Update Every N Frames",
    Range = {1, 8}, Increment = 1, Suffix = "f",
    CurrentValue = S.ESPRate, Flag = "ESPRate",
    Callback = function(v) S.ESPRate = v end,
})

-- ────────────────────────────────────────────────────────
-- TAB: MISC
-- ────────────────────────────────────────────────────────
local TMisc = Window:CreateTab("Misc", 4483362458)

TMisc:CreateSection("Actions")

TMisc:CreateButton({
    Name = "Re-Scan Animals",
    Callback = function()
        Animals = {}
        for _, d in ipairs(Workspace:GetDescendants()) do
            if d:IsA("Model") then TryAdd(d) end
        end
        -- Wait a tick for defers to complete
        task.delay(0.2, function()
            local n = 0
            for _ in pairs(Animals) do n = n + 1 end
            Rayfield:Notify({ Title = "Re-Scanned", Content = n .. " animals found.", Duration = 3, Image = 4483362458 })
        end)
    end,
})

TMisc:CreateButton({
    Name = "Clear All ESP",
    Callback = function()
        PoolClear()
        prevAnKeys = {}
        prevPlKeys = {}
        Rayfield:Notify({ Title = "ESP Cleared", Content = "All drawings removed.", Duration = 3, Image = 4483362458 })
    end,
})

TMisc:CreateButton({
    Name = "Disable Everything",
    Callback = function()
        S.AnimalAimbot = false; S.PlayerAimbot = false
        S.AnimalESP    = false; S.PlayerESP    = false
        FovCircle.Visible = false
        for key in pairs(Pool) do PoolHide(key) end
        Rayfield:Notify({ Title = "All Disabled", Content = "Every feature turned off.", Duration = 3, Image = 4483362458 })
    end,
})

TMisc:CreateSection("Info")
TMisc:CreateLabel("Animals: detected via DescendantAdded events")
TMisc:CreateLabel("New spawns auto-detected in real time")
TMisc:CreateLabel("Both aimbots work together with priority system")

-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-- SECTION 11 — LOAD CONFIG & NOTIFY
-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Rayfield:LoadConfiguration()

Rayfield:Notify({
    Title    = "Foresto Script v4",
    Content  = "Loaded! All features fixed.",
    Duration = 5,
    Image    = 4483362458,
})