local RunService = game:GetService("RunService")
local Players = game:GetService("Players")
local Workspace = game:GetService("Workspace")
local CollectionService = game:GetService("CollectionService")
local CoreGui = game:GetService("CoreGui")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Global Cleanup / Reload Handling
if _G.TraversalHubCleanup then
    pcall(_G.TraversalHubCleanup)
end

local cleanupFns = {}
local function registerCleanup(fn)
    table.insert(cleanupFns, fn)
end

local isRunning = true
local function fullCleanup()
    isRunning = false
    for _, fn in ipairs(cleanupFns) do
        pcall(fn)
    end
    cleanupFns = {}
    _G.TraversalHubCleanup = nil
end
_G.TraversalHubCleanup = fullCleanup

if typeof(STATE) == "table" and STATE.onCleanup then
    STATE.onCleanup(fullCleanup)
end

-- BridgeNet Setup for Healing
local BridgeNet
pcall(function()
    local modules = ReplicatedStorage:FindFirstChild("Modules")
    if modules and modules:FindFirstChild("BridgeNet") then
        BridgeNet = require(modules.BridgeNet)
    end
end)
local healingBridge = BridgeNet and BridgeNet.CreateBridge("healingEvent")

-- Configuration & State
local Config = {
    GodMode = true,
    InfStamina = true,
    AutoParry = {
        Enabled = true,
        Distance = 16,
        SmartDelay = true,
        CustomDelay = 0.25,
        AutoFace = true,
        Cooldown = 0.35,
    },
    ESP = {
        Enabled = true,
        Boxes = true,
        Names = true,
        Distances = true,
        Health = true,
        Tracers = false,
        Chams = true,
        EnemiesOnly = false,
        IncludeCorpses = false,
        MaxDistance = 2500,
        BoxColor = Color3.fromRGB(255, 65, 65),
        TextColor = Color3.fromRGB(255, 255, 255),
        TracerColor = Color3.fromRGB(255, 100, 100),
        ChamsColor = Color3.fromRGB(255, 40, 40),
        ChamsOutlineColor = Color3.fromRGB(255, 255, 255),
    }
}

-- Load WindUI
local WindUI
local success, res = pcall(function()
    return loadstring(game:HttpGet("https://github.com/Footagesus/WindUI/releases/latest/download/main.lua"))()
end)

if not success or not res then
    warn("[Traversal Hub] Failed to load WindUI:", res)
    return
end
WindUI = res

-- Create Window
local Window = WindUI:CreateWindow({
    Title = "TRAVERSAL HUB",
    Icon = "shield-alert",
    Author = "by someone",
    Folder = "TraversalHub",
    Size = UDim2.fromOffset(580, 460),
    Transparent = true,
    Theme = "Dark",
    Resizable = true,
    SideBarWidth = 175,
    HideSearchBar = true,
    ScrollBarEnabled = false,
    Acrylic = true,
    ToggleKey = Enum.KeyCode.RightShift,
})

registerCleanup(function()
    pcall(function()
        if Window and Window.Destroy then
            Window:Destroy()
        end
    end)
end)


-- ==================== GOD MODE (INVINCIBILITY) ====================
local function maintainHealth()
    if not Config.GodMode then return end
    
    local char = LocalPlayer.Character
    if not char then return end
    local hum = char:FindFirstChildOfClass("Humanoid")
    if not hum then return end
    
    if hum.Health < hum.MaxHealth or hum.Health < 100 then
        if healingBridge then
            pcall(function()
                healingBridge:Fire(hum, 100)
            end)
        end
        hum.Health = math.max(hum.MaxHealth, 100)
        
        -- Sync Health Bar HUD
        local pgui = LocalPlayer:FindFirstChild("PlayerGui")
        local hud = pgui and pgui:FindFirstChild("VisibilityHud")
        local bar = hud and hud:FindFirstChild("Frame") and hud.Frame:FindFirstChild("HealthBar") and hud.Frame.HealthBar:FindFirstChild("Bar")
        if bar then
            bar.Size = UDim2.fromScale(1, 1)
        end
    end
end

-- Health changed instant reaction
local healthConn
local function hookCharacterHealth(char)
    if healthConn then healthConn:Disconnect() end
    if not char then return end
    local hum = char:WaitForChild("Humanoid", 3)
    if hum then
        healthConn = hum.HealthChanged:Connect(function(hp)
            if Config.GodMode and hp < hum.MaxHealth then
                maintainHealth()
            end
        end)
    end
end
hookCharacterHealth(LocalPlayer.Character)

local charAddedConn = LocalPlayer.CharacterAdded:Connect(function(char)
    task.wait(0.5)
    hookCharacterHealth(char)
end)
registerCleanup(function()
    if healthConn then healthConn:Disconnect() end
    charAddedConn:Disconnect()
end)

local lastHealthCheck = 0
local godModeHeartbeat = RunService.Heartbeat:Connect(function()
    local now = tick()
    if now - lastHealthCheck > 0.05 then
        lastHealthCheck = now
        maintainHealth()
    end
end)
registerCleanup(function()
    godModeHeartbeat:Disconnect()
end)


-- ==================== UNIVERSAL NPC DETECTION ENGINE ====================
local trackedNPCs = {}
local enemyConnections = {}

local function cleanNPCConnections(model)
    if enemyConnections[model] then
        for _, conn in ipairs(enemyConnections[model]) do
            pcall(function() conn:Disconnect() end)
        end
        enemyConnections[model] = nil
    end
end

local function getEnemyWeapon(model)
    for _, child in ipairs(model:GetChildren()) do
        if child:IsA("Model") then
            local name = child.Name
            if name == "Axe" or name == "Chainsaw" or name == "Knife" or name == "Machete" or name == "Katana" or name == "Bat" or name == "Crowbar" then
                return name
            end
        end
    end
    return "Fist"
end

local function getNPCRootPart(model)
    if not model then return nil end
    return model:FindFirstChild("HumanoidRootPart")
        or model:FindFirstChild("Torso")
        or model:FindFirstChild("UpperTorso")
        or model:FindFirstChild("LowerTorso")
        or model:FindFirstChild("Head")
        or model.PrimaryPart
        or model:FindFirstChildWhichIsA("BasePart")
end

local function getOptimalParryDelay(model)
    if not Config.AutoParry.SmartDelay then
        return Config.AutoParry.CustomDelay
    end
    
    local weapon = getEnemyWeapon(model)
    if weapon == "Axe" then
        return 0.36
    elseif weapon == "Chainsaw" then
        return 0.35
    elseif weapon == "Bat" then
        return 0.30
    elseif weapon == "Crowbar" then
        return 0.25
    elseif weapon == "Machete" then
        return 0.22
    elseif weapon == "Katana" then
        return 0.18
    elseif weapon == "Knife" then
        return 0.12
    else
        return 0.20
    end
end

local function registerNPC(model)
    if not model or not model:IsA("Model") then return end
    if model == LocalPlayer.Character or Players:GetPlayerFromCharacter(model) then return end
    
    local hum = model:FindFirstChildOfClass("Humanoid")
    local isEnemyTagged = CollectionService:HasTag(model, "Enemy") or model.Name == "Enemy" or (model.Parent and model.Parent.Name == "Enemies")
    
    if not hum and not isEnemyTagged then return end
    
    local root = getNPCRootPart(model)
    if not root then return end
    
    if not trackedNPCs[model] then
        trackedNPCs[model] = {
            Model = model,
            Humanoid = hum,
            Root = root,
            IsEnemy = isEnemyTagged,
            Weapon = getEnemyWeapon(model),
        }
        
        local conns = {}
        
        local attrConn = model:GetAttributeChangedSignal("Attacking"):Connect(function()
            if Config.AutoParry.Enabled and model:GetAttribute("Attacking") == true then
                _G.TraversalHubScheduleParry(model)
            end
        end)
        table.insert(conns, attrConn)
        
        local ancConn = model.AncestryChanged:Connect(function(_, parent)
            if not parent then
                cleanNPCConnections(model)
                trackedNPCs[model] = nil
            end
        end)
        table.insert(conns, ancConn)
        
        if hum then
            local diedConn = hum.Died:Connect(function()
                if not Config.ESP.IncludeCorpses then
                    cleanNPCConnections(model)
                    trackedNPCs[model] = nil
                end
            end)
            table.insert(conns, diedConn)
        end
        
        enemyConnections[model] = conns
    else
        local entry = trackedNPCs[model]
        if not entry.Root or not entry.Root.Parent then
            entry.Root = root
        end
        if not entry.Humanoid then
            entry.Humanoid = hum
        end
        entry.Weapon = getEnemyWeapon(model)
    end
end

local function scanAllNPCs()
    for _, desc in ipairs(Workspace:GetDescendants()) do
        if desc:IsA("Model") then
            registerNPC(desc)
        end
    end
end
scanAllNPCs()

local descAddedConn = Workspace.DescendantAdded:Connect(function(desc)
    if desc:IsA("Model") then
        task.spawn(function()
            task.wait(0.2)
            registerNPC(desc)
        end)
    elseif desc:IsA("Humanoid") and desc.Parent and desc.Parent:IsA("Model") then
        task.spawn(function()
            task.wait(0.1)
            registerNPC(desc.Parent)
        end)
    end
end)
registerCleanup(function() descAddedConn:Disconnect() end)

local taggedAddedConn = CollectionService:GetInstanceAddedSignal("Enemy"):Connect(function(inst)
    if inst:IsDescendantOf(Workspace) and inst:IsA("Model") then
        registerNPC(inst)
    end
end)
registerCleanup(function() taggedAddedConn:Disconnect() end)

task.spawn(function()
    while isRunning do
        task.wait(1.5)
        scanAllNPCs()
        
        for model, data in pairs(trackedNPCs) do
            if not model.Parent or (data.Humanoid and data.Humanoid.Health <= 0 and not Config.ESP.IncludeCorpses) then
                cleanNPCConnections(model)
                trackedNPCs[model] = nil
            end
        end
    end
end)

registerCleanup(function()
    for model, _ in pairs(enemyConnections) do
        cleanNPCConnections(model)
    end
    trackedNPCs = {}
end)


-- ==================== INFINITE STAMINA LOGIC ====================
local function maintainStamina()
    if not Config.InfStamina then return end
    
    local char = LocalPlayer.Character
    if not char then return end
    
    local clientCode = char:FindFirstChild("ClientCode")
    if clientCode then
        local successEnv, senv = pcall(getsenv, clientCode)
        if successEnv and senv and senv.primaryAttack then
            pcall(function()
                setupvalue(senv.primaryAttack, 3, 100)
            end)
        end
    end
    
    local pgui = LocalPlayer:FindFirstChild("PlayerGui")
    local hud = pgui and pgui:FindFirstChild("VisibilityHud")
    local bar = hud and hud:FindFirstChild("Frame") and hud.Frame:FindFirstChild("StaminaBar") and hud.Frame.StaminaBar:FindFirstChild("Bar")
    if bar and bar.Size.X.Scale < 1 then
        bar.Size = UDim2.fromScale(1, 1)
    end
end

local lastStaminaCheck = 0
local staminaHeartbeat = RunService.Heartbeat:Connect(function()
    local now = tick()
    if now - lastStaminaCheck > 0.1 then
        lastStaminaCheck = now
        maintainStamina()
    end
end)
registerCleanup(function()
    staminaHeartbeat:Disconnect()
end)


-- ==================== SMART AUTO PARRY SYSTEM (NO NOTIFICATIONS) ====================
local lastParryTime = 0
local pendingParries = {}

local function executeParry(attackerModel)
    local char = LocalPlayer.Character
    if not char then return end
    
    local hrp = char:FindFirstChild("HumanoidRootPart")
    local clientCode = char:FindFirstChild("ClientCode")
    if not hrp or not clientCode then return end
    
    local senv = getsenv(clientCode)
    if not senv or not senv.handleAction then return end
    
    -- Auto Face attacker
    if Config.AutoParry.AutoFace and attackerModel then
        local targetRoot = getNPCRootPart(attackerModel)
        if targetRoot then
            pcall(function()
                local targetPos = targetRoot.Position
                hrp.CFrame = CFrame.lookAt(hrp.Position, Vector3.new(targetPos.X, hrp.Position.Y, targetPos.Z))
            end)
        end
    end
    
    -- Point target variable (u275) to attacker
    pcall(function()
        setupvalue(senv.handleAction, 45, attackerModel)
    end)
    
    -- Trigger Block action
    pcall(function()
        senv.handleAction("Block", Enum.UserInputState.Begin)
    end)
end

_G.TraversalHubScheduleParry = function(attackerModel)
    if not isRunning or not Config.AutoParry.Enabled then return end
    if pendingParries[attackerModel] then return end
    
    local char = LocalPlayer.Character
    if not char then return end
    local myHRP = char:FindFirstChild("HumanoidRootPart")
    local myHum = char:FindFirstChildOfClass("Humanoid")
    if not myHRP or not myHum or myHum.Health <= 0 then return end
    
    local root = getNPCRootPart(attackerModel)
    if not root then return end
    
    local dist = (myHRP.Position - root.Position).Magnitude
    if dist > Config.AutoParry.Distance then return end
    
    pendingParries[attackerModel] = true
    local delayTime = getOptimalParryDelay(attackerModel)
    
    task.delay(delayTime, function()
        pendingParries[attackerModel] = nil
        if not isRunning or not Config.AutoParry.Enabled then return end
        
        local curChar = LocalPlayer.Character
        local curHRP = curChar and curChar:FindFirstChild("HumanoidRootPart")
        local curHum = curChar and curChar:FindFirstChildOfClass("Humanoid")
        if not curHRP or not curHum or curHum.Health <= 0 then return end
        
        if attackerModel.Parent and root.Parent then
            local currentDist = (curHRP.Position - root.Position).Magnitude
            if currentDist <= Config.AutoParry.Distance + 2 then
                local now = tick()
                if now - lastParryTime >= Config.AutoParry.Cooldown then
                    lastParryTime = now
                    executeParry(attackerModel)
                end
            end
        end
    end)
end

local lastAnimCheck = 0
local autoParryHeartbeat = RunService.Heartbeat:Connect(function()
    if not isRunning or not Config.AutoParry.Enabled then return end
    
    local now = tick()
    if now - lastAnimCheck < 0.05 then return end
    lastAnimCheck = now
    
    local char = LocalPlayer.Character
    if not char then return end
    local myHRP = char:FindFirstChild("HumanoidRootPart")
    local myHum = char:FindFirstChildOfClass("Humanoid")
    if not myHRP or not myHum or myHum.Health <= 0 then return end
    
    local myPos = myHRP.Position
    local maxDist = Config.AutoParry.Distance
    
    for model, data in pairs(trackedNPCs) do
        if not pendingParries[model] then
            local root = data.Root
            local hum = data.Humanoid
            if root and root.Parent and model.Parent then
                local isAlive = not hum or hum.Health > 0
                if isAlive then
                    local dist = (myPos - root.Position).Magnitude
                    if dist <= maxDist then
                        if model:GetAttribute("Attacking") == true or CollectionService:HasTag(model, "Attacking") then
                            _G.TraversalHubScheduleParry(model)
                        elseif hum then
                            local animator = hum:FindFirstChildOfClass("Animator")
                            if animator then
                                local tracks = animator:GetPlayingAnimationTracks()
                                for _, track in ipairs(tracks) do
                                    local name = string.lower(track.Name)
                                    if string.find(name, "attack") or string.find(name, "swing") or string.find(name, "slash") or string.find(name, "combo") or string.find(name, "hit") or string.find(name, "counter") then
                                        _G.TraversalHubScheduleParry(model)
                                        break
                                    end
                                end
                            end
                        end
                    end
                end
            end
        end
    end
end)

registerCleanup(function()
    autoParryHeartbeat:Disconnect()
end)


-- ==================== HIGH-PERFORMANCE ESP SYSTEM ====================
local espEntries = {}

local function createESPObject(npcModel)
    local entry = {
        Model = npcModel,
        Box = Drawing.new("Square"),
        BoxOutline = Drawing.new("Square"),
        NameText = Drawing.new("Text"),
        DistText = Drawing.new("Text"),
        HealthText = Drawing.new("Text"),
        HealthBar = Drawing.new("Square"),
        HealthBarOutline = Drawing.new("Square"),
        Tracer = Drawing.new("Line"),
        Highlight = nil,
    }
    
    entry.Box.Thickness = 1.5
    entry.Box.Filled = false
    entry.Box.Transparency = 1
    entry.Box.Visible = false
    entry.Box.ZIndex = 2
    
    entry.BoxOutline.Thickness = 3
    entry.BoxOutline.Filled = false
    entry.BoxOutline.Transparency = 0.7
    entry.BoxOutline.Color = Color3.new(0, 0, 0)
    entry.BoxOutline.Visible = false
    entry.BoxOutline.ZIndex = 1
    
    entry.NameText.Size = 14
    entry.NameText.Center = true
    entry.NameText.Outline = true
    entry.NameText.OutlineColor = Color3.new(0, 0, 0)
    entry.NameText.Visible = false
    entry.NameText.ZIndex = 3
    
    entry.DistText.Size = 12
    entry.DistText.Center = true
    entry.DistText.Outline = true
    entry.DistText.OutlineColor = Color3.new(0, 0, 0)
    entry.DistText.Visible = false
    entry.DistText.ZIndex = 3
    
    entry.HealthText.Size = 12
    entry.HealthText.Center = false
    entry.HealthText.Outline = true
    entry.HealthText.OutlineColor = Color3.new(0, 0, 0)
    entry.HealthText.Visible = false
    entry.HealthText.ZIndex = 3
    
    entry.HealthBar.Filled = true
    entry.HealthBar.Visible = false
    entry.HealthBar.ZIndex = 2
    
    entry.HealthBarOutline.Filled = true
    entry.HealthBarOutline.Color = Color3.new(0, 0, 0)
    entry.HealthBarOutline.Transparency = 0.8
    entry.HealthBarOutline.Visible = false
    entry.HealthBarOutline.ZIndex = 1
    
    entry.Tracer.Thickness = 1.5
    entry.Tracer.Transparency = 0.8
    entry.Tracer.Visible = false
    entry.Tracer.ZIndex = 2
    
    local hl = Instance.new("Highlight")
    hl.Name = "ESP_Highlight"
    hl.FillColor = Config.ESP.ChamsColor
    hl.OutlineColor = Config.ESP.ChamsOutlineColor
    hl.FillTransparency = 0.5
    hl.OutlineTransparency = 0.1
    hl.Adornee = npcModel
    hl.Enabled = false
    pcall(function()
        hl.Parent = CoreGui
    end)
    if not hl.Parent then
        hl.Parent = npcModel
    end
    entry.Highlight = hl
    
    return entry
end

local function destroyESPObject(entry)
    if not entry then return end
    pcall(function() entry.Box:Remove() end)
    pcall(function() entry.BoxOutline:Remove() end)
    pcall(function() entry.NameText:Remove() end)
    pcall(function() entry.DistText:Remove() end)
    pcall(function() entry.HealthText:Remove() end)
    pcall(function() entry.HealthBar:Remove() end)
    pcall(function() entry.HealthBarOutline:Remove() end)
    pcall(function() entry.Tracer:Remove() end)
    if entry.Highlight then
        pcall(function() entry.Highlight:Destroy() end)
    end
end

registerCleanup(function()
    for _, entry in pairs(espEntries) do
        destroyESPObject(entry)
    end
    espEntries = {}
end)

local espRenderLoop = RunService.RenderStepped:Connect(function()
    if not isRunning then return end
    
    local cam = Workspace.CurrentCamera
    if not cam then return end
    local viewportSize = cam.ViewportSize
    local myRoot = LocalPlayer.Character and getNPCRootPart(LocalPlayer.Character)
    local myPos = myRoot and myRoot.Position or cam.CFrame.Position
    
    for model, data in pairs(trackedNPCs) do
        if not espEntries[model] and model.Parent then
            espEntries[model] = createESPObject(model)
        end
    end
    
    for model, entry in pairs(espEntries) do
        local data = trackedNPCs[model]
        if not data or not model.Parent or not Config.ESP.Enabled or (Config.ESP.EnemiesOnly and not data.IsEnemy) then
            entry.Box.Visible = false
            entry.BoxOutline.Visible = false
            entry.NameText.Visible = false
            entry.DistText.Visible = false
            entry.HealthText.Visible = false
            entry.HealthBar.Visible = false
            entry.HealthBarOutline.Visible = false
            entry.Tracer.Visible = false
            if entry.Highlight then entry.Highlight.Enabled = false end
            if not data or not model.Parent then
                destroyESPObject(entry)
                espEntries[model] = nil
            end
            continue
        end
        
        local hum = data.Humanoid
        local root = data.Root or getNPCRootPart(model)
        
        if not root or not root.Parent then
            entry.Box.Visible = false
            entry.BoxOutline.Visible = false
            entry.NameText.Visible = false
            entry.DistText.Visible = false
            entry.HealthText.Visible = false
            entry.HealthBar.Visible = false
            entry.HealthBarOutline.Visible = false
            entry.Tracer.Visible = false
            if entry.Highlight then entry.Highlight.Enabled = false end
            continue
        end
        
        local isDead = hum and hum.Health <= 0
        if isDead and not Config.ESP.IncludeCorpses then
            entry.Box.Visible = false
            entry.BoxOutline.Visible = false
            entry.NameText.Visible = false
            entry.DistText.Visible = false
            entry.HealthText.Visible = false
            entry.HealthBar.Visible = false
            entry.HealthBarOutline.Visible = false
            entry.Tracer.Visible = false
            if entry.Highlight then entry.Highlight.Enabled = false end
            continue
        end
        
        local rootPos = root.Position
        local distance = (myPos - rootPos).Magnitude
        
        if distance > Config.ESP.MaxDistance then
            entry.Box.Visible = false
            entry.BoxOutline.Visible = false
            entry.NameText.Visible = false
            entry.DistText.Visible = false
            entry.HealthText.Visible = false
            entry.HealthBar.Visible = false
            entry.HealthBarOutline.Visible = false
            entry.Tracer.Visible = false
            if entry.Highlight then entry.Highlight.Enabled = false end
            continue
        end
        
        local rootScreen, onScreen = cam:WorldToViewportPoint(rootPos)
        
        if entry.Highlight then
            entry.Highlight.Enabled = Config.ESP.Chams
            entry.Highlight.FillColor = Config.ESP.ChamsColor
            entry.Highlight.OutlineColor = Config.ESP.ChamsOutlineColor
        end
        
        if not onScreen then
            entry.Box.Visible = false
            entry.BoxOutline.Visible = false
            entry.NameText.Visible = false
            entry.DistText.Visible = false
            entry.HealthText.Visible = false
            entry.HealthBar.Visible = false
            entry.HealthBarOutline.Visible = false
            entry.Tracer.Visible = false
            continue
        end
        
        local topPos = rootPos + Vector3.new(0, 2.8, 0)
        local botPos = rootPos - Vector3.new(0, 3.2, 0)
        local topScreen = cam:WorldToViewportPoint(topPos)
        local botScreen = cam:WorldToViewportPoint(botPos)
        
        local boxHeight = math.abs(botScreen.Y - topScreen.Y)
        local boxWidth = boxHeight * 0.62
        local boxTopLeft = Vector2.new(rootScreen.X - boxWidth / 2, topScreen.Y)
        
        if Config.ESP.Boxes then
            entry.Box.Size = Vector2.new(boxWidth, boxHeight)
            entry.Box.Position = boxTopLeft
            entry.Box.Color = Config.ESP.BoxColor
            entry.Box.Visible = true
            
            entry.BoxOutline.Size = Vector2.new(boxWidth, boxHeight)
            entry.BoxOutline.Position = boxTopLeft
            entry.BoxOutline.Visible = true
        else
            entry.Box.Visible = false
            entry.BoxOutline.Visible = false
        end
        
        if Config.ESP.Names then
            local weaponTag = (data.Weapon and data.Weapon ~= "Fist") and (" [" .. data.Weapon .. "]") or ""
            entry.NameText.Text = model.Name .. weaponTag
            entry.NameText.Position = Vector2.new(rootScreen.X, boxTopLeft.Y - 16)
            entry.NameText.Color = Config.ESP.TextColor
            entry.NameText.Visible = true
        else
            entry.NameText.Visible = false
        end
        
        if Config.ESP.Distances then
            entry.DistText.Text = string.format("[%d m]", math.floor(distance))
            entry.DistText.Position = Vector2.new(rootScreen.X, boxTopLeft.Y + boxHeight + 2)
            entry.DistText.Color = Color3.fromRGB(200, 200, 200)
            entry.DistText.Visible = true
        else
            entry.DistText.Visible = false
        end
        
        if Config.ESP.Health and hum then
            local healthPercent = math.clamp(hum.Health / math.max(hum.MaxHealth, 1), 0, 1)
            local barWidth = 3
            local barHeight = boxHeight * healthPercent
            local barPos = Vector2.new(boxTopLeft.X - barWidth - 4, boxTopLeft.Y + (boxHeight - barHeight))
            
            entry.HealthBarOutline.Size = Vector2.new(barWidth + 2, boxHeight + 2)
            entry.HealthBarOutline.Position = Vector2.new(boxTopLeft.X - barWidth - 5, boxTopLeft.Y - 1)
            entry.HealthBarOutline.Visible = true
            
            local healthColor = Color3.fromRGB(
                math.floor(255 * (1 - healthPercent)),
                math.floor(255 * healthPercent),
                0
            )
            entry.HealthBar.Size = Vector2.new(barWidth, barHeight)
            entry.HealthBar.Position = barPos
            entry.HealthBar.Color = healthColor
            entry.HealthBar.Visible = true
            
            entry.HealthText.Text = string.format("%d HP", math.floor(hum.Health))
            entry.HealthText.Position = Vector2.new(boxTopLeft.X - barWidth - 8 - entry.HealthText.TextBounds.X, boxTopLeft.Y + boxHeight/2 - 6)
            entry.HealthText.Color = healthColor
            entry.HealthText.Visible = true
        else
            entry.HealthBar.Visible = false
            entry.HealthBarOutline.Visible = false
            entry.HealthText.Visible = false
        end
        
        if Config.ESP.Tracers then
            entry.Tracer.From = Vector2.new(viewportSize.X / 2, viewportSize.Y)
            entry.Tracer.To = Vector2.new(rootScreen.X, botScreen.Y)
            entry.Tracer.Color = Config.ESP.TracerColor
            entry.Tracer.Visible = true
        else
            entry.Tracer.Visible = false
        end
    end
end)

registerCleanup(function()
    espRenderLoop:Disconnect()
end)


-- ==================== UI SETUP (WINDUI) ====================

-- Combat / Main Tab
local CombatTab = Window:Tab({
    Title = "Combat & Defense",
    Icon = "shield-check",
})

CombatTab:Section({
    Title = "Player Invincibility",
    Icon = "heart",
})

CombatTab:Toggle({
    Title = "God Mode (Invincible)",
    Desc = "Locks health to max & triggers instant heal when damaged",
    Icon = "shield",
    Value = Config.GodMode,
    Callback = function(state)
        Config.GodMode = state
        if state then
            maintainHealth()
            WindUI:Notify({
                Title = "Defense",
                Content = "God Mode ENABLED",
                Duration = 2.5,
                Icon = "shield-check",
            })
        else
            WindUI:Notify({
                Title = "Defense",
                Content = "God Mode DISABLED",
                Duration = 2.5,
                Icon = "shield-off",
            })
        end
    end
})

CombatTab:Toggle({
    Title = "Infinite Stamina",
    Desc = "Continuously locks stamina to max & prevents exhaustion",
    Icon = "battery-charging",
    Value = Config.InfStamina,
    Callback = function(state)
        Config.InfStamina = state
        if state then
            maintainStamina()
        end
    end
})

CombatTab:Button({
    Title = "Replenish Health & Stamina",
    Desc = "Instantly restore 100% HP and 100% Stamina",
    Icon = "refresh-cw",
    Callback = function()
        maintainHealth()
        maintainStamina()
        WindUI:Notify({
            Title = "Status",
            Content = "Health & Stamina fully restored!",
            Duration = 2,
            Icon = "check-circle",
        })
    end
})

CombatTab:Section({
    Title = "Auto Parry",
    Icon = "swords",
})

CombatTab:Toggle({
    Title = "Auto Parry / Auto Block",
    Desc = "Automatically blocks and counters incoming NPC attacks",
    Icon = "shield-alert",
    Value = Config.AutoParry.Enabled,
    Callback = function(state)
        Config.AutoParry.Enabled = state
    end
})

CombatTab:Toggle({
    Title = "Smart Weapon Delay",
    Desc = "Auto-adjusts parry timing (e.g. 0.36s for heavy Axe, 0.12s for Knife)",
    Icon = "clock",
    Value = Config.AutoParry.SmartDelay,
    Callback = function(state)
        Config.AutoParry.SmartDelay = state
    end
})

CombatTab:Slider({
    Title = "Manual Parry Delay (s)",
    Desc = "Used if Smart Delay is disabled (0.00s to 0.80s)",
    Value = {
        Min = 0,
        Max = 80,
        Default = math.floor(Config.AutoParry.CustomDelay * 100),
    },
    Callback = function(val)
        Config.AutoParry.CustomDelay = val / 100
    end
})

CombatTab:Slider({
    Title = "Parry Trigger Range",
    Value = {
        Min = 5,
        Max = 30,
        Default = Config.AutoParry.Distance,
    },
    Callback = function(val)
        Config.AutoParry.Distance = val
    end
})

CombatTab:Toggle({
    Title = "Auto Face Attacker",
    Desc = "Instantly snaps view/character to face attacking NPC",
    Icon = "crosshair",
    Value = Config.AutoParry.AutoFace,
    Callback = function(state)
        Config.AutoParry.AutoFace = state
    end
})

-- Visuals / ESP Tab
local VisualsTab = Window:Tab({
    Title = "Visuals (ESP)",
    Icon = "eye",
})

VisualsTab:Section({
    Title = "ESP Master & Filters",
    Icon = "sliders",
})

VisualsTab:Toggle({
    Title = "Master ESP Toggle",
    Desc = "Enable or disable all visuals",
    Icon = "scan",
    Value = Config.ESP.Enabled,
    Callback = function(state)
        Config.ESP.Enabled = state
    end
})

VisualsTab:Toggle({
    Title = "Enemies Only",
    Desc = "Filter only aggressive enemies vs all NPC models",
    Icon = "skull",
    Value = Config.ESP.EnemiesOnly,
    Callback = function(state)
        Config.ESP.EnemiesOnly = state
    end
})

VisualsTab:Toggle({
    Title = "Include Corpses",
    Desc = "Display downed / dead enemy bodies",
    Icon = "skull",
    Value = Config.ESP.IncludeCorpses,
    Callback = function(state)
        Config.ESP.IncludeCorpses = state
    end
})

VisualsTab:Slider({
    Title = "Max Render Distance",
    Value = {
        Min = 100,
        Max = 4000,
        Default = Config.ESP.MaxDistance,
    },
    Callback = function(val)
        Config.ESP.MaxDistance = val
    end
})

VisualsTab:Section({
    Title = "Visual Elements",
    Icon = "layers",
})

VisualsTab:Toggle({
    Title = "2D Boxes",
    Desc = "Bounding box around NPC",
    Icon = "square",
    Value = Config.ESP.Boxes,
    Callback = function(state)
        Config.ESP.Boxes = state
    end
})

VisualsTab:Toggle({
    Title = "3D Highlight Chams",
    Desc = "Glow silhouette through walls",
    Icon = "sun",
    Value = Config.ESP.Chams,
    Callback = function(state)
        Config.ESP.Chams = state
    end
})

VisualsTab:Toggle({
    Title = "Name & Weapon Tags",
    Desc = "Display NPC model name and equipped weapon",
    Icon = "type",
    Value = Config.ESP.Names,
    Callback = function(state)
        Config.ESP.Names = state
    end
})

VisualsTab:Toggle({
    Title = "Distance Indicator",
    Desc = "Display distance in meters",
    Icon = "navigation",
    Value = Config.ESP.Distances,
    Callback = function(state)
        Config.ESP.Distances = state
    end
})

VisualsTab:Toggle({
    Title = "Health Bar & Text",
    Desc = "Dynamic health bar and HP count",
    Icon = "heart",
    Value = Config.ESP.Health,
    Callback = function(state)
        Config.ESP.Health = state
    end
})

VisualsTab:Toggle({
    Title = "Tracers",
    Desc = "Draw line from bottom screen to NPC",
    Icon = "trending-up",
    Value = Config.ESP.Tracers,
    Callback = function(state)
        Config.ESP.Tracers = state
    end
})

-- Settings Tab
local SettingsTab = Window:Tab({
    Title = "Settings",
    Icon = "settings",
})

SettingsTab:Section({
    Title = "UI & Management",
    Icon = "tool",
})

SettingsTab:Button({
    Title = "Force Rescan NPCs",
    Desc = "Force a complete scan of all workspace subfolders",
    Icon = "refresh-ccw",
    Callback = function()
        scanAllNPCs()
        local count = 0
        for _ in pairs(trackedNPCs) do count = count + 1 end
        WindUI:Notify({
            Title = "Scanner",
            Content = string.format("Found %d NPCs in workspace!", count),
            Duration = 2.5,
            Icon = "check",
        })
    end
})

SettingsTab:Button({
    Title = "Unload Script",
    Desc = "Remove all ESP drawings, listeners, and close UI",
    Icon = "trash-2",
    Callback = function()
        fullCleanup()
        WindUI:Notify({
            Title = "Unloaded",
            Content = "Traversal Hub has been completely unloaded.",
            Duration = 3,
            Icon = "x-circle",
        })
    end
})

-- Initial Notification
WindUI:Notify({
    Title = "Traversal Hub Loaded",
    Content = "God Mode, Auto Parry, Stamina & ESP Active! (Press Right Shift to toggle UI)",
    Duration = 4,
    Icon = "check-check",
})

print("[Traversal Hub] God Mode Edition Loaded YIPIEEEEEE!")