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

local LocalPlayer = Players.LocalPlayer
local Camera = Workspace.CurrentCamera

-- // CONFIG
local Config = {
    FlyEnabled = false,
    FlySpeed = 60,
    FlyNoclip = true,
    SpeedEnabled = false,
    SpeedValue = 32,
    SpeedMethod = "WalkSpeed", -- WalkSpeed, CFrame, Hybrid
    -- ESP
    ESPEnabled = false,
    ESPBoxes = true,
    ESPBoxType = "2D", -- 2D, Corner
    ESPNames = true,
    ESPDistance = true,
    ESPHealthBar = true,
    ESPHealthText = false,
    ESPTracers = false,
    ESPTracerOrigin = "Bottom", -- Bottom, Center, Mouse
    ESPTeamCheck = true,
    ESPMaxDistance = 2000,
    ESPUseTeamColor = false,
    ESPBoxColor = Color3.fromRGB(220, 30, 30), -- gamesense lime
    ESPTracerColor = Color3.fromRGB(220, 30, 30),
    ESPTextSize = 13,
    ESPThickness = 1,
    -- Aimbot / Ragebot
    AimbotEnabled = false,
    AimbotFOV = 140,
    AimbotSmoothing = 2, -- 1=instant, higher = smoother
    AimbotTargetPart = "Head",
    AimbotTeamCheck = true,
    AimbotVisibleCheck = true,
    AimbotShowFOV = true,
    AimbotAutoShoot = false,
    AimbotMethod = "Camera",
    AimbotKey = "Mouse2", -- Mouse2 / E / Q
    -- Silent Aim
    SilentAimEnabled = false,
    SilentAimFOV = 220,
    SilentAimHitchance = 100,
    SilentAimTargetPart = "Head",
    SilentAimVisibleCheck = false,
    SilentAimTeamCheck = true,
    SilentAimShowFOV = true,
    -- Hitbox Expander
    HitboxEnabled = false,
    HitboxSize = 14,
    HitboxPart = "HumanoidRootPart",
    HitboxTransparency = 0.7,
    HitboxColor = Color3.fromRGB(220, 30, 30),
    HitboxTeamCheck = true,
    -- Weapon Mods
    NoRecoilEnabled = false,
    NoSpreadEnabled = false,
    InfAmmoEnabled = false,
    RapidFireEnabled = false,
    GodModeEnabled = false,
    -- Movement extra
    NoFallEnabled = false,
    NoFallMethod = "Velocity", -- Velocity, State, Hook
    -- ArrayList
    ArrayListEnabled = true,
    ArrayListSort = true,
}

-- // STATE
local flyConns = {}
local speedConn = nil
local noclipConn = nil
local flyKeys = {
    W = false, A = false, S = false, D = false,
    Space = false, LeftControl = false, LeftShift = false,
}

-- // HELPERS
local function getCharacter()
    return LocalPlayer.Character
end

local function getHumanoid()
    local char = getCharacter()
    return char and char:FindFirstChildOfClass("Humanoid")
end

local function getHRP()
    local char = getCharacter()
    return char and char:FindFirstChild("HumanoidRootPart")
end

-- // FLY LOGIC
local function setNoclip(state)
    if noclipConn then noclipConn:Disconnect() noclipConn = nil end
    if not state then return end
    noclipConn = RunService.Stepped:Connect(function()
        if Config.FlyEnabled then
            local char = getCharacter()
            if char then
                for _, v in ipairs(char:GetDescendants()) do
                    if v:IsA("BasePart") and v.CanCollide then
                        v.CanCollide = false
                    end
                end
            end
        end
    end)
end

local function startFly()
    if #flyConns > 0 then return end
    local bv = Instance.new("BodyVelocity")
    bv.Name = "SkeetFlyBV"
    bv.MaxForce = Vector3.new(9e9, 9e9, 9e9)
    bv.Velocity = Vector3.new(0,0,0)
    local bg = Instance.new("BodyGyro")
    bg.Name = "SkeetFlyBG"
    bg.MaxTorque = Vector3.new(9e9, 9e9, 9e9)
    bg.P = 9e4
    bg.D = 1000

    local function attach()
        local hrp = getHRP()
        local hum = getHumanoid()
        if hrp and hum then
            bv.Parent = hrp
            bg.Parent = hrp
            hum.PlatformStand = true
        end
    end
    attach()

    -- re-attach on respawn
    local charAddedConn
    charAddedConn = LocalPlayer.CharacterAdded:Connect(function()
        task.wait(0.5)
        attach()
    end)
    table.insert(flyConns, charAddedConn)

    local hb = RunService.Heartbeat:Connect(function()
        local hrp = getHRP()
        local hum = getHumanoid()
        if not hrp or not hum then return end
        if not Config.FlyEnabled then return end

        hum.PlatformStand = true
        bg.CFrame = Camera.CFrame

        local moveVec = Vector3.new(0,0,0)
        local camCF = Camera.CFrame

        if flyKeys.W then moveVec += camCF.LookVector end
        if flyKeys.S then moveVec -= camCF.LookVector end
        if flyKeys.A then moveVec -= camCF.RightVector end
        if flyKeys.D then moveVec += camCF.RightVector end
        if flyKeys.Space then moveVec += Vector3.new(0,1,0) end
        if flyKeys.LeftControl or flyKeys.LeftShift then moveVec -= Vector3.new(0,1,0) end

        if moveVec.Magnitude > 0 then
            moveVec = moveVec.Unit * Config.FlySpeed
        end

        -- smooth
        bv.Velocity = bv.Velocity:Lerp(moveVec, 0.2)
    end)
    table.insert(flyConns, hb)

    -- keep HRP parent check
    local bvCheck = RunService.Heartbeat:Connect(function()
        local hrp = getHRP()
        if hrp and bv.Parent ~= hrp then
            bv.Parent = hrp
            bg.Parent = hrp
        end
    end)
    table.insert(flyConns, bvCheck)

    flyConns.BV = bv
    flyConns.BG = bg

    setNoclip(Config.FlyNoclip)
end

local function stopFly()
    for _, c in ipairs(flyConns) do
        if typeof(c) == "RBXScriptConnection" then
            c:Disconnect()
        end
    end
    table.clear(flyConns)
    -- keep BV/BG refs if they were stored as keys
    if flyConns.BV then flyConns.BV:Destroy() end
    if flyConns.BG then flyConns.BG:Destroy() end

    -- fallback destroy if stored differently
    local hrp = getHRP()
    if hrp then
        local bv = hrp:FindFirstChild("SkeetFlyBV")
        local bg = hrp:FindFirstChild("SkeetFlyBG")
        if bv then bv:Destroy() end
        if bg then bg:Destroy() end
    end

    flyConns = {}
    setNoclip(false)
    local hum = getHumanoid()
    if hum then
        hum.PlatformStand = false
    end
end

local function setFly(state)
    Config.FlyEnabled = state
    if state then
        startFly()
    else
        stopFly()
    end
end

-- // SPEED LOGIC (FIXED - 3 methods to bypass FortLine anticheat)
local speedHookConns = {}
local function hookWalkSpeed(hum)
    if not hum then return end
    local c = hum:GetPropertyChangedSignal("WalkSpeed"):Connect(function()
        if Config.SpeedEnabled and Config.SpeedMethod ~= "CFrame" then
            if hum.WalkSpeed ~= Config.SpeedValue then
                hum.WalkSpeed = Config.SpeedValue
            end
        end
    end)
    table.insert(speedHookConns, c)
end

local function startSpeed()
    if speedConn then speedConn:Disconnect() end
    for _,c in ipairs(speedHookConns) do pcall(function() c:Disconnect() end) end
    speedHookConns = {}

    hookWalkSpeed(getHumanoid())

    -- heartbeat loop - handles all 3 methods
    speedConn = RunService.Heartbeat:Connect(function(dt)
        if not Config.SpeedEnabled then return end
        local hum = getHumanoid()
        local hrp = getHRP()
        local char = getCharacter()
        if not hum or not hrp or not char then return end
        if hum:GetState() == Enum.HumanoidStateType.Dead then return end

        -- Method 1 & 3: keep WalkSpeed forced (FortLine resets it often)
        if Config.SpeedMethod == "WalkSpeed" or Config.SpeedMethod == "Hybrid" then
            if hum.WalkSpeed ~= Config.SpeedValue then
                hum.WalkSpeed = Config.SpeedValue
            end
        end

        -- Method 2 & 3: CFrame translation (bypasses WalkSpeed checks entirely)
        -- Only moves when player is trying to move (WASD)
        if Config.SpeedMethod == "CFrame" or Config.SpeedMethod == "Hybrid" then
            local moveDir = hum.MoveDirection
            if moveDir.Magnitude > 0 then
                -- Hybrid: let WalkSpeed do most work, we add a little extra
                -- CFrame only: we do all the movement
                local multiplier = 1
                if Config.SpeedMethod == "CFrame" then
                    -- CFrame needs to fully replace WalkSpeed (16 is normal)
                    -- scale so slider 16-200 feels similar
                    multiplier = Config.SpeedValue / 16
                    -- invert WalkSpeed so game doesn't detect it, keep it 16
                    if hum.WalkSpeed ~= 16 then hum.WalkSpeed = 16 end
                    hrp.CFrame = hrp.CFrame + moveDir * (16 * multiplier * dt * 1.2)
                else -- Hybrid
                    -- small boost on top of WalkSpeed, less detectable at low values
                    if moveDir.Magnitude > 0 and Config.SpeedValue > 16 then
                        local extra = (Config.SpeedValue - 16) * 0.55
                        hrp.CFrame = hrp.CFrame + moveDir * extra * dt
                    end
                end
            end
        end
    end)

    -- also hook future humanoids
    local caConn = LocalPlayer.CharacterAdded:Connect(function(char)
        task.wait(0.6)
        local hum = char:WaitForChild("Humanoid", 5)
        if hum then hookWalkSpeed(hum) end
        if Config.SpeedEnabled and hum then
            task.wait(0.1)
            if Config.SpeedMethod ~= "CFrame" then
                hum.WalkSpeed = Config.SpeedValue
            end
        end
    end)
    table.insert(speedHookConns, caConn)
end

local function stopSpeed()
    if speedConn then speedConn:Disconnect() speedConn = nil end
    for _,c in ipairs(speedHookConns) do pcall(function() c:Disconnect() end) end
    speedHookConns = {}
    local hum = getHumanoid()
    if hum then
        hum.WalkSpeed = 16
    end
end

local function setSpeed(state)
    Config.SpeedEnabled = state
    if state then startSpeed() else stopSpeed() end
end

-- // ESP & TRACERS (Clean, skeet style)
local ESPObjects = {} -- [player] = { drawings... }
local ESPEnabled = false
local hasDrawing = false
do
    local ok = pcall(function() local d = Drawing.new("Line") d:Remove() end)
    hasDrawing = ok
end

local function getTeamColor(plr)
    if plr.Team and plr.Team.TeamColor then
        return plr.Team.TeamColor.Color
    end
    return Color3.fromRGB(220, 30, 30)
end

local function shouldShowPlayer(plr)
    if plr == LocalPlayer then return false end
    if not plr.Character then return false end
    if not plr.Character:FindFirstChild("HumanoidRootPart") then return false end
    local hum = plr.Character:FindFirstChildOfClass("Humanoid")
    if not hum or hum.Health  Config.ESPMaxDistance then return false end
    end
    return true
end

-- Drawing ESP
local function createDrawingESP(plr)
    if ESPObjects[plr] then return ESPObjects[plr] end
    local objs = {}

    -- Box outline (black)
    objs.BoxOutline = Drawing.new("Square")
    objs.BoxOutline.Visible = false
    objs.BoxOutline.Color = Color3.fromRGB(0,0,0)
    objs.BoxOutline.Thickness = 3
    objs.BoxOutline.Transparency = 1
    objs.BoxOutline.Filled = false

    -- Box main
    objs.Box = Drawing.new("Square")
    objs.Box.Visible = false
    objs.Box.Color = Config.ESPBoxColor
    objs.Box.Thickness = Config.ESPThickness
    objs.Box.Transparency = 1
    objs.Box.Filled = false

    -- Health bar bg
    objs.HealthBG = Drawing.new("Square")
    objs.HealthBG.Visible = false
    objs.HealthBG.Color = Color3.fromRGB(0,0,0)
    objs.HealthBG.Thickness = 1
    objs.HealthBG.Transparency = 0.7
    objs.HealthBG.Filled = true

    -- Health bar
    objs.HealthBar = Drawing.new("Square")
    objs.HealthBar.Visible = false
    objs.HealthBar.Filled = true
    objs.HealthBar.Transparency = 1
    objs.HealthBar.Color = Color3.fromRGB(120,255,120)
    objs.HealthBar.Thickness = 1

    -- Health outline
    objs.HealthOutline = Drawing.new("Square")
    objs.HealthOutline.Visible = false
    objs.HealthOutline.Color = Color3.fromRGB(0,0,0)
    objs.HealthOutline.Thickness = 1
    objs.HealthOutline.Transparency = 1
    objs.HealthOutline.Filled = false

    -- Name
    objs.Name = Drawing.new("Text")
    objs.Name.Visible = false
    objs.Name.Color = Color3.fromRGB(255,255,255)
    objs.Name.Size = Config.ESPTextSize
    objs.Name.Center = true
    objs.Name.Outline = true
    objs.Name.OutlineColor = Color3.fromRGB(0,0,0)
    objs.Name.Font = 2 -- UI

    -- Distance
    objs.Distance = Drawing.new("Text")
    objs.Distance.Visible = false
    objs.Distance.Color = Color3.fromRGB(180,180,180)
    objs.Distance.Size = 12
    objs.Distance.Center = true
    objs.Distance.Outline = true
    objs.Distance.OutlineColor = Color3.fromRGB(0,0,0)
    objs.Distance.Font = 2

    -- Tracer outline
    objs.TracerOutline = Drawing.new("Line")
    objs.TracerOutline.Visible = false
    objs.TracerOutline.Color = Color3.fromRGB(0,0,0)
    objs.TracerOutline.Thickness = 3
    objs.TracerOutline.Transparency = 0.6

    -- Tracer
    objs.Tracer = Drawing.new("Line")
    objs.Tracer.Visible = false
    objs.Tracer.Color = Config.ESPTracerColor
    objs.Tracer.Thickness = 1.5
    objs.Tracer.Transparency = 1

    ESPObjects[plr] = objs
    return objs
end

local function removeDrawingESP(plr)
    local objs = ESPObjects[plr]
    if not objs then return end
    for _,v in pairs(objs) do pcall(function() v:Remove() end) end
    ESPObjects[plr] = nil
end

local function hideDrawingESP(plr)
    local objs = ESPObjects[plr]
    if not objs then return end
    for _,v in pairs(objs) do v.Visible = false end
end

-- Fallback ESP (Highlight + Billboard) for executors without Drawing
local fallbackFolder = Instance.new("Folder")
fallbackFolder.Name = "SkeetESP_Fallback"
pcall(function() fallbackFolder.Parent = game.Players.LocalPlayer:FindFirstChild("PlayerGui") end)
if not fallbackFolder.Parent then fallbackFolder.Parent = game.Players.LocalPlayer:FindFirstChild("PlayerGui") or Workspace
end

local FallbackObjects = {}

local function createFallbackESP(plr)
    if FallbackObjects[plr] then return FallbackObjects[plr] end
    local char = plr.Character
    if not char then return nil end
    local objs = {}

    local hl = Instance.new("Highlight")
    hl.Name = "SkeetESP_HL_"..plr.Name
    hl.Adornee = char
    hl.FillTransparency = 0.7
    hl.OutlineTransparency = 0
    hl.FillColor = Config.ESPBoxColor
    hl.OutlineColor = Color3.fromRGB(0,0,0)
    hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    hl.Parent = fallbackFolder

    local bb = Instance.new("BillboardGui")
    bb.Name = "SkeetESP_BB_"..plr.Name
    bb.Adornee = char:FindFirstChild("Head") or char:FindFirstChild("HumanoidRootPart")
    bb.Size = UDim2.new(0,120,0,40)
    bb.StudsOffset = Vector3.new(0,3,0)
    bb.AlwaysOnTop = true
    bb.Parent = fallbackFolder

    local nameLabel = Instance.new("TextLabel")
    nameLabel.Size = UDim2.new(1,0,0.5,0)
    nameLabel.BackgroundTransparency = 1
    nameLabel.Font = Enum.Font.Code
    nameLabel.TextSize = 12
    nameLabel.TextColor3 = Color3.fromRGB(255,255,255)
    nameLabel.TextStrokeTransparency = 0
    nameLabel.TextStrokeColor3 = Color3.fromRGB(0,0,0)
    nameLabel.Text = plr.Name
    nameLabel.Parent = bb

    local distLabel = Instance.new("TextLabel")
    distLabel.Size = UDim2.new(1,0,0.5,0)
    distLabel.Position = UDim2.new(0,0,0.5,0)
    distLabel.BackgroundTransparency = 1
    distLabel.Font = Enum.Font.Code
    distLabel.TextSize = 11
    distLabel.TextColor3 = Color3.fromRGB(180,180,180)
    distLabel.TextStrokeTransparency = 0
    distLabel.TextStrokeColor3 = Color3.fromRGB(0,0,0)
    distLabel.Text = ""
    distLabel.Parent = bb

    objs.Highlight = hl
    objs.Billboard = bb
    objs.NameLabel = nameLabel
    objs.DistLabel = distLabel

    FallbackObjects[plr] = objs
    return objs
end

local function removeFallbackESP(plr)
    local objs = FallbackObjects[plr]
    if not objs then return end
    pcall(function() objs.Highlight:Destroy() end)
    pcall(function() objs.Billboard:Destroy() end)
    FallbackObjects[plr] = nil
end

-- Main update loop
local espConn = nil
local function updateESP()
    for _, plr in ipairs(Players:GetPlayers()) do
        if plr == LocalPlayer then continue end
        local show = Config.ESPEnabled and shouldShowPlayer(plr)
        local char = plr.Character
        if not char then
            if hasDrawing then hideDrawingESP(plr) end
            continue
        end
        local hrp = char:FindFirstChild("HumanoidRootPart")
        local head = char:FindFirstChild("Head")
        local hum = char:FindFirstChildOfClass("Humanoid")
        if not hrp or not hum then continue end

        if hasDrawing then
            local objs = ESPObjects[plr] or createDrawingESP(plr)
            if not show then
                for _,v in pairs(objs) do v.Visible = false end
                continue
            end

            -- 3D to 2D bounding box
            local minX, minY = math.huge, math.huge
            local maxX, maxY = -math.huge, -math.huge
            local onScreen = false

            -- Use GetBoundingBox for size, or approximate from HRP + head
            local cf, size = char:GetBoundingBox()
            -- corners of bounding box
            local corners = {
                cf * CFrame.new(size.X/2, size.Y/2, size.Z/2),
                cf * CFrame.new(-size.X/2, size.Y/2, size.Z/2),
                cf * CFrame.new(size.X/2, -size.Y/2, size.Z/2),
                cf * CFrame.new(-size.X/2, -size.Y/2, size.Z/2),
                cf * CFrame.new(size.X/2, size.Y/2, -size.Z/2),
                cf * CFrame.new(-size.X/2, size.Y/2, -size.Z/2),
                cf * CFrame.new(size.X/2, -size.Y/2, -size.Z/2),
                cf * CFrame.new(-size.X/2, -size.Y/2, -size.Z/2),
            }

            for _, c in ipairs(corners) do
                local pos, vis = Camera:WorldToViewportPoint(c.Position)
                if vis then onScreen = true end
                minX = math.min(minX, pos.X)
                minY = math.min(minY, pos.Y)
                maxX = math.max(maxX, pos.X)
                maxY = math.max(maxY, pos.Y)
            end

            if not onScreen then
                for _,v in pairs(objs) do v.Visible = false end
                continue
            end

            local boxW = maxX - minX
            local boxH = maxY - minY
            local boxX = minX
            local boxY = minY

            -- Clamp a bit
            boxX = math.clamp(boxX, 0, Camera.ViewportSize.X)
            boxY = math.clamp(boxY, 0, Camera.ViewportSize.Y)

            local col = Config.ESPUseTeamColor and getTeamColor(plr) or Config.ESPBoxColor
            local tracerCol = Config.ESPTracerColor
            if Config.ESPUseTeamColor then tracerCol = col end

            -- Box
            if Config.ESPBoxes then
                objs.Box.Visible = true
                objs.BoxOutline.Visible = true
                objs.Box.Color = col
                objs.Box.Thickness = Config.ESPThickness
                objs.Box.Size = Vector2.new(boxW, boxH)
                objs.Box.Position = Vector2.new(boxX, boxY)
                objs.BoxOutline.Size = Vector2.new(boxW, boxH)
                objs.BoxOutline.Position = Vector2.new(boxX, boxY)

                -- Health bar (left side)
                if Config.ESPHealthBar then
                    local hpPct = math.clamp(hum.Health / hum.MaxHealth, 0, 1)
                    local barH = boxH * hpPct
                    local barW = 3
                    local barX = boxX - 6
                    local barY = boxY + boxH - barH

                    objs.HealthBG.Visible = true
                    objs.HealthBG.Position = Vector2.new(boxX - 6, boxY)
                    objs.HealthBG.Size = Vector2.new(barW, boxH)

                    objs.HealthBar.Visible = true
                    objs.HealthBar.Position = Vector2.new(barX, barY)
                    objs.HealthBar.Size = Vector2.new(barW, barH)
                    -- green to red
                    local r = math.floor(255 * (1 - hpPct))
                    local g = math.floor(255 * hpPct)
                    objs.HealthBar.Color = Color3.fromRGB(r, g, 70)

                    objs.HealthOutline.Visible = false
                else
                    objs.HealthBG.Visible = false
                    objs.HealthBar.Visible = false
                    objs.HealthOutline.Visible = false
                end
            else
                objs.Box.Visible = false
                objs.BoxOutline.Visible = false
                objs.HealthBG.Visible = false
                objs.HealthBar.Visible = false
                objs.HealthOutline.Visible = false
            end

            -- Name & Distance
            local myHRP = getHRP()
            local dist = myHRP and math.floor((hrp.Position - myHRP.Position).Magnitude) or 0
            local headPos, headVis = Camera:WorldToViewportPoint(head and head.Position or hrp.Position + Vector3.new(0,2,0))

            if Config.ESPNames and headVis then
                objs.Name.Visible = true
                objs.Name.Position = Vector2.new(headPos.X, boxY - 16)
                objs.Name.Text = plr.Name
                objs.Name.Color = Color3.fromRGB(255,255,255)
                objs.Name.Size = Config.ESPTextSize
                -- health text inline if enabled
                if Config.ESPHealthText then
                    objs.Name.Text = string.format("%s [%d/%d]", plr.Name, math.floor(hum.Health+0.5), hum.MaxHealth)
                    if hum.Health / hum.MaxHealth < 0.5 then
                        objs.Name.Color = Color3.fromRGB(255, 90, 90)
                    end
                end
            else
                objs.Name.Visible = false
            end

            if Config.ESPDistance and headVis then
                objs.Distance.Visible = true
                objs.Distance.Position = Vector2.new(headPos.X, boxY + boxH + 2)
                objs.Distance.Text = string.format("%dm", dist)
            else
                objs.Distance.Visible = false
            end

            -- Tracers
            if Config.ESPTracers and headVis then
                local from = Vector2.new(Camera.ViewportSize.X/2, Camera.ViewportSize.Y)
                if Config.ESPTracerOrigin == "Center" then
                    from = Vector2.new(Camera.ViewportSize.X/2, Camera.ViewportSize.Y/2)
                elseif Config.ESPTracerOrigin == "Top" then
                    from = Vector2.new(Camera.ViewportSize.X/2, 0)
                elseif Config.ESPTracerOrigin == "Mouse" then
                    local m = UserInputService:GetMouseLocation()
                    from = Vector2.new(m.X, m.Y)
                end
                local to = Vector2.new(boxX + boxW/2, boxY + boxH)
                objs.Tracer.Visible = true
                objs.TracerOutline.Visible = true
                objs.Tracer.Color = tracerCol
                objs.Tracer.From = from
                objs.Tracer.To = to
                objs.TracerOutline.From = from
                objs.TracerOutline.To = to
            else
                objs.Tracer.Visible = false
                objs.TracerOutline.Visible = false
            end
        else
            -- fallback mode
            local objs = FallbackObjects[plr] or createFallbackESP(plr)
            if not objs then continue end
            local showFallback = Config.ESPEnabled and Config.ESPBoxes and shouldShowPlayer(plr)
            -- need to recreate if character changed
            if objs.Highlight.Adornee ~= char then
                removeFallbackESP(plr)
                objs = createFallbackESP(plr)
            end
            if showFallback then
                objs.Highlight.Enabled = true
                objs.Highlight.FillColor = Config.ESPUseTeamColor and getTeamColor(plr) or Config.ESPBoxColor
                objs.Billboard.Enabled = Config.ESPNames or Config.ESPDistance
                if objs.Billboard.Enabled then
                    local myHRP = getHRP()
                    local dist = myHRP and math.floor((hrp.Position - myHRP.Position).Magnitude) or 0
                    objs.NameLabel.Text = Config.ESPNames and plr.Name or ""
                    objs.DistLabel.Text = Config.ESPDistance and string.format("%dm | %d HP", dist, math.floor(hum.Health+0.5)) or ""
                    objs.Billboard.Adornee = head or hrp
                end
            else
                if objs.Highlight then objs.Highlight.Enabled = false end
                if objs.Billboard then objs.Billboard.Enabled = false end
            end
            -- tracers can't be done cleanly without Drawing, we use simple Frame lines if needed
            -- skip tracer in fallback for cleanliness (or could add)
        end
    end
end

local function setESP(state)
    Config.ESPEnabled = state
    if state then
        if espConn then espConn:Disconnect() end
        espConn = RunService.RenderStepped:Connect(updateESP)
        -- init for existing players
        for _,plr in ipairs(Players:GetPlayers()) do
            if hasDrawing then createDrawingESP(plr) else createFallbackESP(plr) end
        end
        -- handle new players
        Players.PlayerAdded:Connect(function(plr)
            task.wait(0.5)
            if hasDrawing then createDrawingESP(plr) else createFallbackESP(plr) end
        end)
        Players.PlayerRemoving:Connect(function(plr)
            if hasDrawing then removeDrawingESP(plr) else removeFallbackESP(plr) end
        end)
    else
        if espConn then espConn:Disconnect() espConn = nil end
        for plr,_ in pairs(ESPObjects) do hideDrawingESP(plr) end
        for plr,_ in pairs(FallbackObjects) do
            local o = FallbackObjects[plr]
            if o then
                if o.Highlight then o.Highlight.Enabled = false end
                if o.Billboard then o.Billboard.Enabled = false end
            end
        end
    end
end

-- auto cleanup on char reset for fallback
Players.PlayerAdded:Connect(function(plr)
    plr.CharacterAdded:Connect(function()
        task.wait(0.5)
        if FallbackObjects[plr] then
            removeFallbackESP(plr)
            if Config.ESPEnabled then createFallbackESP(plr) end
        end
    end)
end)

-- // ================= COMBAT SYSTEMS =================
-- Helpers for combat (visible check, get closest)
local RaycastParamsNew = RaycastParams.new()
RaycastParamsNew.FilterType = Enum.RaycastFilterType.Blacklist

local function isVisible(targetPart)
    if not Config.AimbotVisibleCheck and not Config.SilentAimVisibleCheck then return true end
    local char = LocalPlayer.Character
    if not char or not targetPart then return false end
    RaycastParamsNew.FilterDescendantsInstances = {char, Workspace.CurrentCamera}
    local origin = Camera.CFrame.Position
    local dir = targetPart.Position - origin
    local ray = Workspace:Raycast(origin, dir, RaycastParamsNew)
    if not ray then return true end
    -- if ray hits the target's character, it's visible
    return ray.Instance and ray.Instance:IsDescendantOf(targetPart.Parent)
end

local function getTargetPart(char, partName)
    if partName == "Random" then
        local c = {"Head","HumanoidRootPart","UpperTorso","LowerTorso"}
        partName = c[math.random(1,#c)]
    end
    return char:FindFirstChild(partName) or char:FindFirstChild("HumanoidRootPart") or char:FindFirstChild("Head")
end

local function getClosestPlayer(fov, targetPartName, teamCheck, visibleCheck)
    local closest = nil
    local closestDist = fov
    local closestPart = nil
    local mousePos = UserInputService:GetMouseLocation()
    -- adjust for GuiInset
    local inset = GuiService:GetGuiInset()
    mousePos = Vector2.new(mousePos.X, mousePos.Y - inset.Y)

    for _, plr in ipairs(Players:GetPlayers()) do
        if plr == LocalPlayer then continue end
        if teamCheck and plr.Team == LocalPlayer.Team and plr.Team ~= nil then continue end
        local char = plr.Character
        if not char then continue end
        local hum = char:FindFirstChildOfClass("Humanoid")
        if not hum or hum.Health  Config.ESPMaxDistance then continue end

        local pos, onScreen = Camera:WorldToViewportPoint(part.Position)
        if not onScreen then continue end
        local dist = (Vector2.new(pos.X, pos.Y) - mousePos).Magnitude
        if dist > closestDist then continue end
        if visibleCheck and not isVisible(part) then continue end

        closest = plr
        closestDist = dist
        closestPart = part
    end
    return closest, closestPart, closestDist
end

-- // FOV CIRCLES (Drawing)
local AimFOVCircle = nil
local SilentFOVCircle = nil
if hasDrawing then
    pcall(function()
        AimFOVCircle = Drawing.new("Circle")
        AimFOVCircle.Visible = false
        AimFOVCircle.Radius = Config.AimbotFOV
        AimFOVCircle.Color = Color3.fromRGB(220, 30, 30) -- gamesense lime
        AimFOVCircle.Thickness = 1.8
        AimFOVCircle.NumSides = 72
        AimFOVCircle.Filled = false
        AimFOVCircle.Transparency = 1

        SilentFOVCircle = Drawing.new("Circle")
        SilentFOVCircle.Visible = false
        SilentFOVCircle.Radius = Config.SilentAimFOV
        SilentFOVCircle.Color = Color3.fromRGB(150, 18, 220) -- darker lime for silent
        SilentFOVCircle.Thickness = 1.4
        SilentFOVCircle.NumSides = 64
        SilentFOVCircle.Filled = false
        SilentFOVCircle.Transparency = 0.7
    end)
end

RunService.RenderStepped:Connect(function()
    local mousePos = UserInputService:GetMouseLocation()
    if AimFOVCircle then
        AimFOVCircle.Position = mousePos
        AimFOVCircle.Radius = Config.AimbotFOV
        AimFOVCircle.Visible = Config.AimbotEnabled and Config.AimbotShowFOV
        AimFOVCircle.Color = Config.AimbotEnabled and Color3.fromRGB(220, 30, 30) or Color3.fromRGB(90,90,90)
    end
    if SilentFOVCircle then
        SilentFOVCircle.Position = mousePos
        SilentFOVCircle.Radius = Config.SilentAimFOV
        SilentFOVCircle.Visible = Config.SilentAimEnabled and Config.SilentAimShowFOV
    end
end)

-- // AIMBOT / RAGEBOT
local aimbotConn = nil
local aimbotActive = false

local function isAimbotKeyDown()
    if Config.AimbotKey == "Mouse2" then
        return UserInputService:IsMouseButtonPressed(Enum.UserInputType.MouseButton2)
    elseif Config.AimbotKey == "E" then
        return UserInputService:IsKeyDown(Enum.KeyCode.E)
    elseif Config.AimbotKey == "Q" then
        return UserInputService:IsKeyDown(Enum.KeyCode.Q)
    elseif Config.AimbotKey == "Always" then
        return true
    end
    return UserInputService:IsMouseButtonPressed(Enum.UserInputType.MouseButton2)
end

local function aimbotThink()
    if not Config.AimbotEnabled then return end
    if not isAimbotKeyDown() and Config.AimbotKey ~= "Always" then return end
    local plr, part = getClosestPlayer(Config.AimbotFOV, Config.AimbotTargetPart, Config.AimbotTeamCheck, Config.AimbotVisibleCheck)
    if not plr or not part then return end

    local camPos = Camera.CFrame.Position
    local targetPos = part.Position
    -- prediction: add velocity * ping compensation (simple)
    pcall(function()
        local hum = part.Parent:FindFirstChildOfClass("Humanoid")
        if hum and part.AssemblyLinearVelocity then
            targetPos = targetPos + part.AssemblyLinearVelocity * 0.12
        end
    end)

    if Config.AimbotMethod == "Camera" then
        local smooth = math.clamp(Config.AimbotSmoothing, 1, 10)
        if smooth  Config.SilentAimHitchance then return nil end
    local plr, part = getClosestPlayer(Config.SilentAimFOV, Config.SilentAimTargetPart, Config.SilentAimTeamCheck, Config.SilentAimVisibleCheck)
    if plr and part then
        -- prediction
        local pos = part.Position
        pcall(function()
            if part.AssemblyLinearVelocity then
                pos = pos + part.AssemblyLinearVelocity * 0.135
            end
        end)
        return plr, part, pos
    end
    return nil
end

local function tryHookSilentAim()
    if silentHooked then return end
    local ok, hook = pcall(function() return hookmetamethod end)
    if not ok or not hook then
        warn("[skeet] hookmetamethod not supported - silent aim will use aimbot fallback")
        return
    end
    local getname = getnamecallmethod or get_namecall_method
    if not getname then return end

    oldNamecall = hookmetamethod(game, "__namecall", function(self, ...)
        local method = getname()
        local args = {...}

        -- Silent aim for Raycast / FindPartOnRay (works for many games including FortLine shoot tracers)
        if Config.SilentAimEnabled and (method == "Raycast" or method == "FindPartOnRay" or method == "FindPartOnRayWithIgnoreList" or method == "FindPartOnRayWithWhitelist" or method == "RaycastParams") then
            local plr, part, pos = getSilentTarget()
            if plr and part and pos then
                -- This is a generic hook: if the ray originates near camera and goes forward, redirect
                -- We check if self == Workspace
                if self == Workspace then
                    -- args[1]=origin, args[2]=direction (for Raycast)
                    if method == "Raycast" and typeof(args[1]) == "Vector3" and typeof(args[2]) == "Vector3" then
                        local origin = args[1]
                        -- only redirect if shooting (distance > 10 and not too close)
                        local dir = (pos - origin)
                        -- keep magnitude similar to original to avoid detection
                        local origMag = args[2].Magnitude
                        if origMag > 5 then
                            args[2] = dir.Unit * origMag
                            return oldNamecall(self, unpack(args))
                        end
                    elseif (method == "FindPartOnRay" or method == "FindPartOnRayWithIgnoreList") and typeof(args[1]) == "Ray" then
                        local ray = args[1]
                        local origin = ray.Origin
                        local dir = (pos - origin).Unit * ray.Direction.Magnitude
                        local newRay = Ray.new(origin, dir)
                        args[1] = newRay
                        return oldNamecall(self, unpack(args))
                    end
                end
            end
        end

        -- Hook FireServer on shooting remotes (FortLine uses RemoteEvents for hit registration)
        if Config.SilentAimEnabled and method == "FireServer" then
            -- FortLine remotes often named: Shoot, Hit, Damage, Fire, etc.
            -- We detect any RemoteEvent that is fired with a Vector3/CFrame target
            local plr, part, pos = getSilentTarget()
            if plr and part and pos then
                -- Check if args contain a Vector3 that looks like a hit position (near target)
                -- We replace the first Vector3/CFrame argument that is far from origin
                for i, v in ipairs(args) do
                    if typeof(v) == "Vector3" then
                        -- if it's a hit position (far from local hrp), replace
                        local myHRP = getHRP()
                        if myHRP and (v - myHRP.Position).Magnitude > 20 then
                            args[i] = pos
                            break
                        end
                    elseif typeof(v) == "CFrame" then
                        local p = v.Position
                        local myHRP = getHRP()
                        if myHRP and (p - myHRP.Position).Magnitude > 20 then
                            args[i] = CFrame.new(pos)
                            break
                        end
                    end
                end
                if #args > 0 then
                    -- only hook shooting remotes, not other remotes like movement
                    local remoteName = tostring(self.Name):lower()
                    if remoteName:find("shoot") or remoteName:find("fire") or remoteName:find("hit") or remoteName:find("damage") or remoteName:find("bullet") or remoteName:find("gun") or self:IsA("RemoteEvent") then
                        return oldNamecall(self, unpack(args))
                    end
                end
            end
        end

        return oldNamecall(self, ...)
    end)
    silentHooked = true
    print("[skeet] silent aim hooked")
end

local function setSilentAim(state)
    Config.SilentAimEnabled = state
    if state then
        tryHookSilentAim()
    end
    if SilentFOVCircle then
        SilentFOVCircle.Visible = state and Config.SilentAimShowFOV
    end
end

-- // HITBOX EXPANDER (Rage)
local hitboxConn = nil
local originalSizes = {} -- [player -> {part, size, transparency}]

local function resetHitbox(plr)
    local data = originalSizes[plr]
    if not data then return end
    for part, info in pairs(data) do
        if part and part.Parent then
            pcall(function()
                part.Size = info.Size
                part.Transparency = info.Transparency
                part.CanCollide = info.CanCollide
                part.Massless = info.Massless
            end)
        end
    end
    originalSizes[plr] = nil
end

local function expandHitbox()
    for _, plr in ipairs(Players:GetPlayers()) do
        if plr == LocalPlayer then continue end
        if Config.HitboxTeamCheck and plr.Team == LocalPlayer.Team and plr.Team ~= nil then
            resetHitbox(plr)
            continue
        end
        local char = plr.Character
        if not char then continue end
        local hum = char:FindFirstChildOfClass("Humanoid")
        if not hum or hum.Health <= 0 then continue end

        local parts = {}
        if Config.HitboxPart == "HumanoidRootPart" then
            local p = char:FindFirstChild("HumanoidRootPart")
            if p then table.insert(parts, p) end
        elseif Config.HitboxPart == "Head" then
            local p = char:FindFirstChild("Head")
            if p then table.insert(parts, p) end
        elseif Config.HitboxPart == "Torso" then
            local p = char:FindFirstChild("UpperTorso") or char:FindFirstChild("Torso")
            if p then table.insert(parts, p) end
        elseif Config.HitboxPart == "All" then
            for _,v in ipairs(char:GetChildren()) do
                if v:IsA("BasePart") and (v.Name=="Head" or v.Name=="HumanoidRootPart" or v.Name=="UpperTorso" or v.Name=="LowerTorso") then
                    table.insert(parts, v)
                end
            end
        end

        for _, part in ipairs(parts) do
            if not originalSizes[plr] then originalSizes[plr] = {} end
            if not originalSizes[plr][part] then
                originalSizes[plr][part] = {Size=part.Size, Transparency=part.Transparency, CanCollide=part.CanCollide, Massless=part.Massless}
            end
            pcall(function()
                part.Size = Vector3.new(Config.HitboxSize, Config.HitboxSize, Config.HitboxSize)
                part.Transparency = Config.HitboxTransparency
                part.CanCollide = false
                part.Massless = true
                -- color for visibility (optional, not changing material to stay clean)
                if part:FindFirstChild("SkeetHitboxColor") == nil then
                    -- we don't change color to keep legit looking, but store
                end
            end)
        end
    end
end

local function setHitbox(state)
    Config.HitboxEnabled = state
    if state then
        if hitboxConn then hitboxConn:Disconnect() end
        hitboxConn = RunService.Heartbeat:Connect(expandHitbox)
    else
        if hitboxConn then hitboxConn:Disconnect() hitboxConn=nil end
        for plr,_ in pairs(originalSizes) do resetHitbox(plr) end
        originalSizes = {}
    end
end

Players.PlayerRemoving:Connect(function(plr)
    if originalSizes[plr] then originalSizes[plr]=nil end
end)

-- // WEAPON MODS - No Recoil / No Spread / Inf Ammo / Rapid Fire
local recoilConn = nil
local ammoConn = nil

-- No Recoil: hook camera recoil by resetting Camera CFrame offset and disabling gun recoil values
local function applyNoRecoil()
    -- Method 1: If FortLine gun tools have recoil values, zero them
    local char = getCharacter()
    if char then
        for _, tool in ipairs(char:GetChildren()) do
            if tool:IsA("Tool") then
                -- search for recoil/spread values inside tool
                for _, v in ipairs(tool:GetDescendants()) do
                    if v:IsA("NumberValue") or v:IsA("IntValue") or v:IsA("NumberRange") then
                        local n = v.Name:lower()
                        if Config.NoRecoilEnabled and (n:find("recoil") or n:find("kick") or n:find("shake")) then
                            pcall(function() if v:IsA("ValueBase") then v.Value = 0 end end)
                        end
                        if Config.NoSpreadEnabled and (n:find("spread") or n:find("accuracy") or n:find("bloom")) then
                            pcall(function() if v:IsA("ValueBase") then v.Value = 0 end end)
                        end
                    end
                    -- also check for modules that control recoil (often ModuleScript with recoil table)
                    if v:IsA("ModuleScript") and (v.Name:lower():find("recoil") or v.Name:lower():find("gun") or v.Name:lower():find("config")) then
                        -- can't easily edit module, hook fallback via camera
                    end
                end
            end
        end
        -- also check ReplicatedStorage gun configs (sometimes FortLine stores there)
        pcall(function()
            local rs = game:GetService("ReplicatedStorage")
            for _, v in ipairs(rs:GetDescendants()) do
                if v:IsA("NumberValue") and Config.NoRecoilEnabled and v.Name:lower():find("recoil") then
                    v.Value = 0
                end
            end
        end)
    end
    -- Method 2: Camera nudge compensation (FortLine viewmodel recoil pushes camera)
    -- We can't fully cancel without hooking, but we can reduce by lerping camera back
end

local function setNoRecoil(state)
    Config.NoRecoilEnabled = state
    if state then
        if recoilConn then recoilConn:Disconnect() end
        recoilConn = RunService.Heartbeat:Connect(applyNoRecoil)
    else
        if recoilConn then recoilConn:Disconnect() recoilConn=nil end
    end
end

local function setNoSpread(state)
    Config.NoSpreadEnabled = state
    if state and not recoilConn then
        recoilConn = RunService.Heartbeat:Connect(applyNoRecoil)
    elseif not state and not Config.NoRecoilEnabled then
        if recoilConn then recoilConn:Disconnect() recoilConn=nil end
    end
end

-- Inf Ammo: continuously refill ammo values in tool
local function applyInfAmmo()
    if not Config.InfAmmoEnabled then return end
    local char = getCharacter()
    if not char then return end
    for _, tool in ipairs(char:GetChildren()) do
        if tool:IsA("Tool") then
            for _, v in ipairs(tool:GetDescendants()) do
                if v:IsA("IntValue") or v:IsA("NumberValue") then
                    local n = v.Name:lower()
                    if n:find("ammo") or n:find("mag") or n:find("bullet") or n:find("reserve") or n:find("clip") then
                        pcall(function()
                            if v.Value < 999 then
                                v.Value = 999
                            end
                        end)
                    end
                end
                -- also StringValue ammo display
                if v:IsA("IntValue") and v.Parent and v.Parent.Name:lower():find("ammo") then
                    pcall(function() v.Value = 999 end)
                end
            end
            -- also check tool attributes (new FortLine uses Attributes)
            pcall(function()
                for _, attr in ipairs({"Ammo","MagAmmo","ReserveAmmo","Clip","Bullets"}) do
                    if tool:GetAttribute(attr) ~= nil then
                        tool:SetAttribute(attr, 999)
                    end
                end
                -- workspace check for ammo GUI
            end)
        end
    end
    -- also check PlayerGui ammo display
    pcall(function()
        local pg = LocalPlayer:FindFirstChild("PlayerGui")
        if pg then
            for _, v in ipairs(pg:GetDescendants()) do
                if v:IsA("TextLabel") and v.Text:match("%d+/%d+") then
                    -- don't modify display, just ammo values
                end
            end
        end
    end)
end

local function setInfAmmo(state)
    Config.InfAmmoEnabled = state
    if state then
        if ammoConn then ammoConn:Disconnect() end
        ammoConn = RunService.Heartbeat:Connect(applyInfAmmo)
        -- also hook FireServer to not consume ammo (if hook available)
        if hookmetamethod and not silentHooked then
            tryHookSilentAim()
        end
        -- hook __newindex on ammo values to block decreases
        pcall(function()
            -- generic hook for ValueBase
        end)
    else
        if ammoConn then ammoConn:Disconnect() ammoConn=nil end
    end
end

-- Rapid Fire: hook FireServer cooldown
local rapidHooked = false
local function setRapidFire(state)
    Config.RapidFireEnabled = state
    if state and not rapidHooked then
        pcall(function()
            local oldTick = tick()
            -- Many FortLine guns have a Cooldown value in tool, we set it to 0
            RunService.Heartbeat:Connect(function()
                if not Config.RapidFireEnabled then return end
                local char = getCharacter()
                if char then
                    for _, tool in ipairs(char:GetChildren()) do
                        if tool:IsA("Tool") then
                            for _, v in ipairs(tool:GetDescendants()) do
                                if v:IsA("NumberValue") or v:IsA("IntValue") then
                                    local n = v.Name:lower()
                                    if n:find("cooldown") or n:find("firerate") or n:find("fire") and n:find("rate") or n:find("delay") then
                                        pcall(function() v.Value = 0.02 end)
                                    end
                                end
                            end
                            pcall(function()
                                if tool:GetAttribute("Cooldown") ~= nil then tool:SetAttribute("Cooldown", 0.02) end
                                if tool:GetAttribute("FireRate") ~= nil then tool:SetAttribute("FireRate", 30) end
                                if tool:GetAttribute("Firerate") ~= nil then tool:SetAttribute("Firerate", 30) end
                            end)
                        end
                    end
                end
            end)
        end)
        rapidHooked = true
    end
end

-- // GOD MODE
local godConn = nil
local godHooked = false
local oldGodIndex = nil

local function applyGodMode()
    local hum = getHumanoid()
    local hrp = getHRP()
    if not hum then return end
    -- keep health at max
    if hum.Health < hum.MaxHealth then
        hum.Health = hum.MaxHealth
    end
    -- prevent death state
    pcall(function()
        hum:SetStateEnabled(Enum.HumanoidStateType.Dead, false)
    end)
    -- also keep WalkSpeed/JumpPower normal (anti ragdoll)
    if hum:GetState() == Enum.HumanoidStateType.Dead then
        hum:ChangeState(Enum.HumanoidStateType.GettingUp)
    end
end

local function hookGodMode()
    if godHooked then return end
    local ok, hm = pcall(function() return hookmetamethod end)
    if not ok or not hm then return end
    local getRaw = getrawmetatable
    if not getRaw then return end
    pcall(function()
        local mt = getRaw(game)
        if mt and mt.__newindex then
            -- hook humanoid health changes
            oldGodIndex = hookmetamethod(game, "__newindex", function(self, k, v)
                if Config.GodModeEnabled and self:IsA("Humanoid") and self.Parent == getCharacter() and (k == "Health" or k == "MaxHealth") then
                    if k == "Health" and v < self.MaxHealth then
                        v = self.MaxHealth
                    end
                    -- block death
                    if k == "Health" and v <= 0 then
                        return
                    end
                end
                return oldGodIndex(self, k, v)
            end)
        end
    end)
    godHooked = true
end

local function setGodMode(state)
    Config.GodModeEnabled = state
    if state then
        hookGodMode()
        if godConn then godConn:Disconnect() end
        godConn = RunService.Heartbeat:Connect(applyGodMode)
        -- also make char take no damage via Humanoid properties
        local hum = getHumanoid()
        if hum then
            pcall(function()
                hum.MaxHealth = math.huge
                hum.Health = math.huge
                -- break joints on death false
                hum.BreakJointsOnDeath = false
                hum.RequiresNeck = false
            end)
        end
        LocalPlayer.CharacterAdded:Connect(function(char)
            task.wait(0.5)
            if Config.GodModeEnabled then
                local h = char:FindFirstChildOfClass("Humanoid")
                if h then
                    pcall(function()
                        h.MaxHealth = math.huge
                        h.Health = math.huge
                        h.BreakJointsOnDeath = false
                    end)
                end
            end
        end)
    else
        if godConn then godConn:Disconnect() godConn=nil end
        local hum = getHumanoid()
        if hum then
            pcall(function()
                hum.MaxHealth = 100
                hum.Health = 100
                hum.BreakJointsOnDeath = true
            end)
        end
    end
end

-- // NO FALL (anti fall damage - velocity clamp + state hook)
local noFallConn = nil
local noFallHooked = false
local oldFallIndex = nil

local function applyNoFall(dt)
    if not Config.NoFallEnabled then return end
    local char = getCharacter()
    local hum = getHumanoid()
    local hrp = getHRP()
    if not hum or not hrp or not char then return end

    if Config.NoFallMethod == "Velocity" or Config.NoFallMethod == "Hybrid" then
        -- clamp extreme fall velocity before impact
        -- when falling fast and close to ground, dampen Y
        local vel = hrp.AssemblyLinearVelocity
        if vel.Y  soften landing
                hrp.AssemblyLinearVelocity = Vector3.new(vel.X, -6, vel.Z)
                -- also add tiny upward impulse to cancel fall damage calc (FortLine uses velocity)
                pcall(function()
                    hrp.Velocity = Vector3.new(vel.X, -6, vel.Z)
                end)
            elseif vel.Y < -80 then
                -- still high up but falling too fast, slight clamp to avoid threshold
                hrp.AssemblyLinearVelocity = Vector3.new(vel.X, math.max(vel.Y, -65), vel.Z)
            end
        end
    end

    if Config.NoFallMethod == "State" or Config.NoFallMethod == "Hybrid" then
        -- keep humanoid from entering ragdoll / freefall damage state
        local state = hum:GetState()
        if state == Enum.HumanoidStateType.Freefall or state == Enum.HumanoidStateType.FallingDown then
            -- FortLine fall damage triggers on Landed after Freefall, we reset state timer by briefly setting to Running
            -- Only if velocity is high
            if hrp.AssemblyLinearVelocity.Y < -30 then
                hum:ChangeState(Enum.HumanoidStateType.Running)
            end
        end
        -- disable FallenDown state entirely while nofall on
        pcall(function()
            hum:SetStateEnabled(Enum.HumanoidStateType.FallenDown, false)
            hum:SetStateEnabled(Enum.HumanoidStateType.Ragdoll, false)
        end)
    end
end

local function hookNoFall()
    if noFallHooked then return end
    local ok, hm = pcall(function() return hookmetamethod end)
    if not ok or not hm then return end
    pcall(function()
        -- Hook TakeDamage / FireServer for fall damage remote if FortLine uses one
        local old
        old = hookmetamethod(game, "__namecall", function(self, ...)
            local method = getnamecallmethod and getnamecallmethod() or ""
            local args = {...}
            if Config.NoFallEnabled and method == "FireServer" then
                local n = tostring(self.Name):lower()
                if n:find("fall") or n:find("damage") or n:find("landed") then
                    -- block fall damage remote
                    -- heuristic: if first arg is number (damage) and velocity-related, block
                    -- if nofall on, drop the call
                    return nil
                end
                -- also block Humanoid:TakeDamage calls that are fall damage (damage ~ 10-50 and velocity high)
                if self:IsA("RemoteEvent") and n:find("take") then
                    local hrp = getHRP()
                    if hrp and hrp.AssemblyLinearVelocity.Y < -40 then
                        return nil
                    end
                end
            end
            if method == "TakeDamage" and Config.NoFallEnabled then
                -- self is Humanoid, block fall damage if falling
                local hrp = getHRP()
                if hrp and hrp.AssemblyLinearVelocity.Y < -35 then
                    return nil
                end
            end
            return old(self, ...)
        end)
        oldFallIndex = old
    end)
    noFallHooked = true
end

local function setNoFall(state)
    Config.NoFallEnabled = state
    if state then
        hookNoFall()
        if noFallConn then noFallConn:Disconnect() end
        noFallConn = RunService.Heartbeat:Connect(applyNoFall)
        -- also listen for Humanoid StateChanged to catch landed
        local hum = getHumanoid()
        if hum then
            pcall(function()
                hum:SetStateEnabled(Enum.HumanoidStateType.FallenDown, false)
            end)
            hum.StateChanged:Connect(function(_, new)
                if Config.NoFallEnabled and new == Enum.HumanoidStateType.Landed then
                    -- small delay then ensure health not lost
                    task.wait(0.05)
                    local h = getHumanoid()
                    if h and h.Health < h.MaxHealth then
                        -- if health dropped exactly on landing, assume fall damage and restore 15 HP typical
                        -- we only restore if we were falling fast before
                    end
                end
            end)
        end
        LocalPlayer.CharacterAdded:Connect(function(char)
            task.wait(0.6)
            if Config.NoFallEnabled then
                local h = char:FindFirstChildOfClass("Humanoid")
                if h then
                    pcall(function() h:SetStateEnabled(Enum.HumanoidStateType.FallenDown, false) end)
                end
            end
        end)
    else
        if noFallConn then noFallConn:Disconnect() noFallConn=nil end
        local hum = getHumanoid()
        if hum then
            pcall(function()
                hum:SetStateEnabled(Enum.HumanoidStateType.FallenDown, true)
                hum:SetStateEnabled(Enum.HumanoidStateType.Ragdoll, true)
            end)
        end
    end
end

-- // INPUT FOR FLY KEYS
UserInputService.InputBegan:Connect(function(input, gpe)
    if gpe then return end
    local key = input.KeyCode
    if key == Enum.KeyCode.W then flyKeys.W = true end
    if key == Enum.KeyCode.A then flyKeys.A = true end
    if key == Enum.KeyCode.S then flyKeys.S = true end
    if key == Enum.KeyCode.D then flyKeys.D = true end
    if key == Enum.KeyCode.Space then flyKeys.Space = true end
    if key == Enum.KeyCode.LeftControl then flyKeys.LeftControl = true end
    if key == Enum.KeyCode.LeftShift then flyKeys.LeftShift = true end

    -- toggle UI with Insert
    if key == Enum.KeyCode.Insert then
        local gui = GuiService:FindFirstChild("SkeetGui") or game.CoreGui:FindFirstChild("SkeetGui")
        -- handled below via reference
    end
end)

UserInputService.InputEnded:Connect(function(input)
    local key = input.KeyCode
    if key == Enum.KeyCode.W then flyKeys.W = false end
    if key == Enum.KeyCode.A then flyKeys.A = false end
    if key == Enum.KeyCode.S then flyKeys.S = false end
    if key == Enum.KeyCode.D then flyKeys.D = false end
    if key == Enum.KeyCode.Space then flyKeys.Space = false end
    if key == Enum.KeyCode.LeftControl then flyKeys.LeftControl = false end
    if key == Enum.KeyCode.LeftShift then flyKeys.LeftShift = false end
end)

-- // NEW CLEAN INTERFACE - minimal, no sidebar, top tabs, purple 186,33,255
local function makeCorner(p,r) local c=Instance.new("UICorner") c.CornerRadius=UDim.new(0,r or 6) c.Parent=p return c end
local function makeStroke(p,c,t) local s=Instance.new("UIStroke") s.Color=c or Color3.fromRGB(50,50,50) s.Thickness=t or 1 s.ApplyStrokeMode=Enum.ApplyStrokeMode.Border s.Parent=p return s end

local function createGui()
	local g=Instance.new("ScreenGui") g.Name="FortLineUI" g.ResetOnSpawn=false g.ZIndexBehavior=Enum.ZIndexBehavior.Sibling g.IgnoreGuiInset=true
	repeat task.wait() until game.Players.LocalPlayer and game.Players.LocalPlayer:FindFirstChild("PlayerGui")
	local pg=game.Players.LocalPlayer:FindFirstChild("PlayerGui")
	pcall(function() if gethui then local h=gethui() if h then pg=h end end end)
	g.Parent=pg
	return g
end
local gui=createGui()
local TweenService=game:GetService("TweenService")
local UIS=game:GetService("UserInputService")
local RS=game:GetService("RunService")

-- Watermark small top-left
local watermark=Instance.new("Frame") watermark.Size=UDim2.new(0,200,0,22) watermark.Position=UDim2.new(0,10,0,10) watermark.BackgroundColor3=Color3.fromRGB(18,18,18) watermark.Parent=gui makeCorner(watermark,4) makeStroke(watermark,Color3.fromRGB(40,40,40),1)
local wGrad=Instance.new("Frame") wGrad.Size=UDim2.new(1,0,0,2) wGrad.BackgroundColor3=Color3.fromRGB(186,33,255) wGrad.Parent=watermark makeCorner(wGrad,4)
local wLabel=Instance.new("TextLabel") wLabel.BackgroundTransparency=1 wLabel.Size=UDim2.new(1,-10,1,0) wLabel.Position=UDim2.new(0,10,0,0) wLabel.Font=Enum.Font.Code wLabel.TextSize=11 wLabel.TextColor3=Color3.fromRGB(210,210,210) wLabel.TextXAlignment=Enum.TextXAlignment.Left wLabel.Text="FortLine | v1.4" wLabel.Parent=watermark
RS.RenderStepped:Connect(function(dt) local fps=math.floor(1/dt+0.5) wLabel.Text=string.format("FortLine | %d fps | %s", math.clamp(fps,0,999), game.Players.LocalPlayer.Name) end)

-- Main window - simple 560x360, centered, draggable
local main=Instance.new("Frame") main.Name="Main" main.Size=UDim2.new(0,560,0,360) main.Position=UDim2.new(0.5,-280,0.5,-180) main.BackgroundColor3=Color3.fromRGB(16,16,16) main.BorderSizePixel=0 main.Active=true main.Draggable=true main.Parent=gui makeCorner(main,5) makeStroke(main,Color3.fromRGB(35,35,35),1)
local top=Instance.new("Frame") top.Size=UDim2.new(1,0,0,28) top.BackgroundColor3=Color3.fromRGB(20,20,20) top.Parent=main makeCorner(top,5)
local topFix=Instance.new("Frame") topFix.Size=UDim2.new(1,0,0,6) topFix.Position=UDim2.new(0,0,1,-6) topFix.BackgroundColor3=Color3.fromRGB(20,20,20) topFix.BorderSizePixel=0 topFix.Parent=top
local title=Instance.new("TextLabel") title.BackgroundTransparency=1 title.Position=UDim2.new(0,12,0,0) title.Size=UDim2.new(1,-100,1,0) title.Font=Enum.Font.GothamBold title.TextSize=12 title.TextXAlignment=Enum.TextXAlignment.Left title.TextColor3=Color3.fromRGB(235,235,235) title.Text="FortLine" title.Parent=top
local sub=Instance.new("TextLabel") sub.BackgroundTransparency=1 sub.Position=UDim2.new(0,70,0,0) sub.Size=UDim2.new(1,-100,1,0) sub.Font=Enum.Font.Code sub.TextSize=10 sub.TextXAlignment=Enum.TextXAlignment.Left sub.TextColor3=Color3.fromRGB(120,120,120) sub.Text="v1.4 | new clean UI" sub.Parent=top
local closeBtn=Instance.new("TextButton") closeBtn.Size=UDim2.new(0,22,0,18) closeBtn.Position=UDim2.new(1,-28,0,5) closeBtn.BackgroundColor3=Color3.fromRGB(30,30,30) closeBtn.Text="×" closeBtn.Font=Enum.Font.GothamBold closeBtn.TextSize=14 closeBtn.TextColor3=Color3.fromRGB(180,180,180) closeBtn.Parent=top makeCorner(closeBtn,4) makeStroke(closeBtn,Color3.fromRGB(45,45,45),1) closeBtn.MouseButton1Click:Connect(function() main.Visible=not main.Visible end)

-- Tabs top
local tabNames={"Movement","Visuals","Combat","Misc"}
local tabBtns={} local activeTab="Movement"
local tabBar=Instance.new("Frame") tabBar.Size=UDim2.new(1,-12,0,26) tabBar.Position=UDim2.new(0,6,0,34) tabBar.BackgroundColor3=Color3.fromRGB(22,22,22) tabBar.Parent=main makeCorner(tabBar,4) makeStroke(tabBar,Color3.fromRGB(30,30,30),1)
local tabLayout=Instance.new("UIListLayout") tabLayout.FillDirection=Enum.FillDirection.Horizontal tabLayout.Padding=UDim.new(0,6) tabLayout.HorizontalAlignment=Enum.HorizontalAlignment.Center tabLayout.VerticalAlignment=Enum.VerticalAlignment.Center tabLayout.Parent=tabBar
local content=Instance.new("Frame") content.Size=UDim2.new(1,-12,1,-68) content.Position=UDim2.new(0,6,0,64) content.BackgroundTransparency=1 content.Parent=main
local pages={}
for _,n in ipairs(tabNames) do
	local p=Instance.new("ScrollingFrame") p.Name=n p.Size=UDim2.new(1,0,1,0) p.BackgroundTransparency=1 p.BorderSizePixel=0 p.Visible=(n==activeTab) p.Parent=content p.CanvasSize=UDim2.new(0,0,0,0) p.AutomaticCanvasSize=Enum.AutomaticSize.Y p.ScrollBarThickness=3 p.ScrollBarImageColor3=Color3.fromRGB(60,60,60) p.VerticalScrollBarInset=Enum.ScrollBarInset.None
	pages[n]=p
	local layout=Instance.new("UIListLayout") layout.Padding=UDim.new(0,10) layout.Parent=p
	local pad=Instance.new("UIPadding") pad.PaddingTop=UDim.new(0,4) pad.PaddingBottom=UDim.new(0,4) pad.Parent=p
	local b=Instance.new("TextButton") b.Name=n b.Size=UDim2.new(0,120,0,18) b.BackgroundColor3=(n==activeTab and Color3.fromRGB(32,32,32) or Color3.fromRGB(22,22,22)) b.Text=n b.Font=Enum.Font.Code b.TextSize=11 b.TextColor3=(n==activeTab and Color3.fromRGB(186,33,255) or Color3.fromRGB(140,140,140)) b.Parent=tabBar makeCorner(b,4) makeStroke(b, (n==activeTab and Color3.fromRGB(186,33,255) or Color3.fromRGB(30,30,30)),1)
	tabBtns[n]=b
	b.MouseButton1Click:Connect(function()
		activeTab=n
		for k,pg in pairs(pages) do pg.Visible=(k==n) end
		for k,btn in pairs(tabBtns) do
			local a=(k==n)
			btn.BackgroundColor3=a and Color3.fromRGB(32,32,32) or Color3.fromRGB(22,22,22)
			btn.TextColor3=a and Color3.fromRGB(186,33,255) or Color3.fromRGB(140,140,140)
			local st=btn:FindFirstChildOfClass("UIStroke") if st then st.Color=a and Color3.fromRGB(186,33,255) or Color3.fromRGB(30,30,30) end
		end
	end)
end

local function section(parent, titleText)
	local sec=Instance.new("Frame") sec.Size=UDim2.new(1,0,0,0) sec.AutomaticSize=Enum.AutomaticSize.Y sec.BackgroundColor3=Color3.fromRGB(20,20,20) sec.Parent=parent makeCorner(sec,4) makeStroke(sec,Color3.fromRGB(30,30,30),1)
	local lbl=Instance.new("TextLabel") lbl.Size=UDim2.new(1,-12,0,18) lbl.Position=UDim2.new(0,8,0,4) lbl.BackgroundTransparency=1 lbl.Font=Enum.Font.GothamSemibold lbl.TextSize=11 lbl.TextXAlignment=Enum.TextXAlignment.Left lbl.TextColor3=Color3.fromRGB(220,220,220) lbl.Text=titleText lbl.Parent=sec
	local line=Instance.new("Frame") line.Size=UDim2.new(1,-16,0,1) line.Position=UDim2.new(0,8,0,20) line.BackgroundColor3=Color3.fromRGB(30,30,30) line.Parent=sec
	local inner=Instance.new("Frame") inner.Name="Inner" inner.Size=UDim2.new(1,-16,0,0) inner.Position=UDim2.new(0,8,0,24) inner.BackgroundTransparency=1 inner.AutomaticSize=Enum.AutomaticSize.Y inner.Parent=sec
	local ly=Instance.new("UIListLayout") ly.Padding=UDim.new(0,8) ly.SortOrder=Enum.SortOrder.LayoutOrder ly.Parent=inner
	local pad=Instance.new("UIPadding") pad.PaddingBottom=UDim.new(0,8) pad.Parent=inner
	return inner
end

local function toggle(parent, text, default, cb)
	local h=Instance.new("Frame") h.Size=UDim2.new(1,0,0,18) h.BackgroundTransparency=1 h.Parent=parent
	local box=Instance.new("Frame") box.Size=UDim2.new(0,14,0,14) box.Position=UDim2.new(0,0,0,2) box.BackgroundColor3=default and Color3.fromRGB(186,33,255) or Color3.fromRGB(30,30,30) box.Parent=h makeCorner(box,2) makeStroke(box, default and Color3.fromRGB(150,18,220) or Color3.fromRGB(45,45,50),1)
	local chk=Instance.new("Frame") chk.Size=UDim2.new(0,8,0,8) chk.Position=UDim2.new(0.5,-4,0.5,-4) chk.BackgroundColor3=Color3.fromRGB(20,20,20) chk.BackgroundTransparency=default and 0 or 1 chk.Parent=box makeCorner(chk,1)
	local lbl=Instance.new("TextLabel") lbl.Size=UDim2.new(1,-20,1,0) lbl.Position=UDim2.new(0,18,0,0) lbl.BackgroundTransparency=1 lbl.Font=Enum.Font.Gotham lbl.TextSize=11 lbl.TextXAlignment=Enum.TextXAlignment.Left lbl.TextColor3=Color3.fromRGB(200,200,200) lbl.Text=text lbl.Parent=h
	local btn=Instance.new("TextButton") btn.Size=UDim2.new(1,0,1,0) btn.BackgroundTransparency=1 btn.Text="" btn.Parent=h
	local state=default
	local function set(v) state=v chk.BackgroundTransparency=v and 0 or 1 box.BackgroundColor3=v and Color3.fromRGB(186,33,255) or Color3.fromRGB(30,30,30) local s=box:FindFirstChildOfClass("UIStroke") if s then s.Color=v and Color3.fromRGB(150,18,220) or Color3.fromRGB(45,45,50) end if cb then cb(v) end end
	btn.MouseButton1Click:Connect(function() set(not state) end)
	return {Set=set}
end

local function slider(parent, text, min, max, default, cb)
	local h=Instance.new("Frame") h.Size=UDim2.new(1,0,0,30) h.BackgroundTransparency=1 h.Parent=parent
	local lbl=Instance.new("TextLabel") lbl.Size=UDim2.new(0.6,0,0,12) lbl.BackgroundTransparency=1 lbl.Font=Enum.Font.Gotham lbl.TextSize=10 lbl.TextColor3=Color3.fromRGB(170,170,170) lbl.Text=text lbl.Parent=h
	local valLbl=Instance.new("TextLabel") valLbl.Size=UDim2.new(0,40,0,12) valLbl.Position=UDim2.new(1,-40,0,0) valLbl.BackgroundTransparency=1 valLbl.Font=Enum.Font.Code valLbl.TextSize=10 valLbl.TextColor3=Color3.fromRGB(186,33,255) valLbl.TextXAlignment=Enum.TextXAlignment.Right valLbl.Text=tostring(default) valLbl.Parent=h
	local track=Instance.new("Frame") track.Size=UDim2.new(1,0,0,4) track.Position=UDim2.new(0,0,0,16) track.BackgroundColor3=Color3.fromRGB(30,30,30) track.Parent=h makeCorner(track,2)
	local fill=Instance.new("Frame") fill.Size=UDim2.new((default-min)/(max-min),0,1,0) fill.BackgroundColor3=Color3.fromRGB(186,33,255) fill.Parent=track makeCorner(fill,2)
	local dragging=false
	local function upd(inp)
		local pct=math.clamp((inp.Position.X - track.AbsolutePosition.X)/track.AbsoluteSize.X,0,1)
		local v=math.floor(min + (max-min)*pct + 0.5)
		fill.Size=UDim2.new(pct,0,1,0) valLbl.Text=tostring(v) if cb then cb(v) end
	end
	track.InputBegan:Connect(function(i) if i.UserInputType==Enum.UserInputType.MouseButton1 then dragging=true upd(i) end end)
	UIS.InputChanged:Connect(function(i) if dragging and i.UserInputType==Enum.UserInputType.MouseMovement then upd(i) end end)
	UIS.InputEnded:Connect(function(i) if i.UserInputType==Enum.UserInputType.MouseButton1 then dragging=false end end)
	return h
end

local function dropdown(parent, text, opts, default, cb)
	local h=Instance.new("Frame") h.Size=UDim2.new(1,0,0,32) h.BackgroundTransparency=1 h.Parent=parent
	local lbl=Instance.new("TextLabel") lbl.Size=UDim2.new(1,0,0,10) lbl.BackgroundTransparency=1 lbl.Font=Enum.Font.Gotham lbl.TextSize=9 lbl.TextColor3=Color3.fromRGB(140,140,140) lbl.Text=text lbl.Parent=h
	local btn=Instance.new("TextButton") btn.Size=UDim2.new(1,0,0,18) btn.Position=UDim2.new(0,0,0,12) btn.BackgroundColor3=Color3.fromRGB(28,28,28) btn.Text=default.." ▾" btn.Font=Enum.Font.Code btn.TextSize=10 btn.TextColor3=Color3.fromRGB(200,200,200) btn.Parent=h makeCorner(btn,3) makeStroke(btn,Color3.fromRGB(40,40,40),1)
	local open=false local lst=nil
	btn.MouseButton1Click:Connect(function()
		open=not open
		if open then
			lst=Instance.new("Frame") lst.Size=UDim2.new(1,0,0,#opts*18+4) lst.Position=UDim2.new(0,0,1,2) lst.BackgroundColor3=Color3.fromRGB(28,28,28) lst.ZIndex=10 lst.Parent=btn makeCorner(lst,3) makeStroke(lst,Color3.fromRGB(45,45,50),1)
			local ly=Instance.new("UIListLayout") ly.Padding=UDim.new(0,1) ly.Parent=lst
			local pad=Instance.new("UIPadding") pad.PaddingTop=UDim.new(0,2) pad.PaddingBottom=UDim.new(0,2) pad.PaddingLeft=UDim.new(0,2) pad.PaddingRight=UDim.new(0,2) pad.Parent=lst
			for _,o in ipairs(opts) do
				local b=Instance.new("TextButton") b.Size=UDim2.new(1,0,0,16) b.BackgroundColor3=Color3.fromRGB(35,35,40) b.Text=o b.Font=Enum.Font.Code b.TextSize=10 b.TextColor3=Color3.fromRGB(200,200,200) b.ZIndex=11 b.Parent=lst makeCorner(b,2)
				b.MouseButton1Click:Connect(function() btn.Text=o.." ▾" open=false if lst then lst:Destroy() lst=nil end if cb then cb(o) end end)
			end
		else if lst then lst:Destroy() lst=nil end end
	end)
	return h
end

local function build()
	-- Movement
	local s1=section(pages["Movement"], "Fly")
	toggle(s1, "Enable Fly [WASD+Space/Ctrl]", Config.FlyEnabled, function(v) setFly(v) end)
	slider(s1, "Fly Speed", 10, 250, Config.FlySpeed, function(v) Config.FlySpeed=v end)
	toggle(s1, "Noclip", Config.FlyNoclip, function(v) Config.FlyNoclip=v; setNoclip(v and Config.FlyEnabled) end)
	local s2=section(pages["Movement"], "Speed / NoFall")
	toggle(s2, "Enable Speed", Config.SpeedEnabled, function(v) setSpeed(v) end)
	dropdown(s2, "Speed Method", {"WalkSpeed","CFrame","Hybrid"}, Config.SpeedMethod, function(v) Config.SpeedMethod=v end)
	slider(s2, "Speed Value", 16, 200, Config.SpeedValue, function(v) Config.SpeedValue=v end)
	toggle(s2, "NoFall", Config.NoFallEnabled, function(v) setNoFall(v) end)
	dropdown(s2, "NoFall Method", {"Velocity","State","Hybrid"}, Config.NoFallMethod, function(v) Config.NoFallMethod=v end)

	-- Visuals
	local s3=section(pages["Visuals"], "ESP")
	toggle(s3, "Enable ESP", Config.ESPEnabled, function(v) setESP(v) end)
	toggle(s3, "Box", Config.ESPBoxes, function(v) Config.ESPBoxes=v end)
	toggle(s3, "Names", Config.ESPNames, function(v) Config.ESPNames=v end)
	toggle(s3, "Distance", Config.ESPDistance, function(v) Config.ESPDistance=v end)
	toggle(s3, "Health Bar", Config.ESPHealthBar, function(v) Config.ESPHealthBar=v end)
	slider(s3, "Text Size", 10, 20, Config.ESPTextSize, function(v) Config.ESPTextSize=v end)
	local s4=section(pages["Visuals"], "Tracers / ArrayList")
	toggle(s4, "Enable Tracers", Config.ESPTracers, function(v) Config.ESPTracers=v end)
	dropdown(s4, "Tracer Origin", {"Bottom","Center","Top","Mouse"}, Config.ESPTracerOrigin, function(v) Config.ESPTracerOrigin=v end)
	toggle(s4, "ArrayList (right)", Config.ArrayListEnabled, function(v) Config.ArrayListEnabled=v end)

	-- Combat
	local s5=section(pages["Combat"], "Aimbot")
	toggle(s5, "Enable Aimbot", Config.AimbotEnabled, function(v) setAimbot(v) end)
	dropdown(s5, "Aim Key", {"Mouse2","Always","E","Q"}, Config.AimbotKey, function(v) Config.AimbotKey=v end)
	dropdown(s5, "Target Part", {"Head","HumanoidRootPart","UpperTorso","Random"}, Config.AimbotTargetPart, function(v) Config.AimbotTargetPart=v end)
	slider(s5, "FOV", 30, 600, Config.AimbotFOV, function(v) Config.AimbotFOV=v end)
	slider(s5, "Smoothing", 1, 10, Config.AimbotSmoothing, function(v) Config.AimbotSmoothing=v end)
	toggle(s5, "Show FOV", Config.AimbotShowFOV, function(v) Config.AimbotShowFOV=v end)
	toggle(s5, "Auto Shoot", Config.AimbotAutoShoot, function(v) Config.AimbotAutoShoot=v end)
	local s6=section(pages["Combat"], "Silent & Hitbox")
	toggle(s6, "Silent Aim", Config.SilentAimEnabled, function(v) setSilentAim(v) end)
	slider(s6, "Silent FOV", 30, 600, Config.SilentAimFOV, function(v) Config.SilentAimFOV=v end)
	slider(s6, "Hit Chance", 10, 100, Config.SilentAimHitchance, function(v) Config.SilentAimHitchance=v end)
	toggle(s6, "Hitbox Expander", Config.HitboxEnabled, function(v) setHitbox(v) end)
	slider(s6, "Hitbox Size", 5, 30, Config.HitboxSize, function(v) Config.HitboxSize=v end)

	-- Misc
	local s7=section(pages["Misc"], "Weapon Mods")
	toggle(s7, "No Recoil", Config.NoRecoilEnabled, function(v) setNoRecoil(v) end)
	toggle(s7, "No Spread", Config.NoSpreadEnabled, function(v) setNoSpread(v) end)
	toggle(s7, "Infinite Ammo", Config.InfAmmoEnabled, function(v) setInfAmmo(v) end)
	toggle(s7, "Rapid Fire", Config.RapidFireEnabled, function(v) setRapidFire(v) end)
	local s8=section(pages["Misc"], "Player")
	toggle(s8, "God Mode", Config.GodModeEnabled, function(v) setGodMode(v) end)
end

build()

-- ArrayList (clean, right side, purple accent) - already created earlier as arrayList Frame with updateArrayList, keep it
-- Ensure arrayList uses new UI colors (already purple)

UIS.InputBegan:Connect(function(i,gpe) if not gpe and i.KeyCode==Enum.KeyCode.Insert then main.Visible=not main.Visible end end)
print("[FortLine] new clean UI loaded | 560x360 | purple 186,33,255 | INSERT to toggle")