local PlayersService = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")

local settings = {
    ToggleKey = Enum.KeyCode.Insert,
    ModKey = Enum.KeyCode.Delete,
    FillTransparency = 0.7,
    OutlineTransparency = 0.2,
    HealthOffset = Vector3.new(0, 2.8, 0),
    ItemBaseOffset = Vector3.new(0, 3.8, 0),
    ItemRowSpacing = 1.1,
    HealthFontSize = 13,
    ItemFontSize = 11,
    InventoryDebounce = 0.15,
    TeammateColor = Color3.new(0, 1, 0),
    TeamColors = {
        Innocent = Color3.new(1, 1, 1),
        Juggernaut = Color3.new(0, 0.5, 0),
        Rebels = Color3.new(1, 1, 0),
        Traitor = Color3.new(1, 0, 0),
        FEAR = Color3.new(0.5, 0.5, 0.5),
        BD_Fighters = Color3.new(1, 0.5, 0.8),
        ["TRIPLE T"] = Color3.new(0.55, 0.27, 0.07),
        Fighter = Color3.new(0.5, 0.5, 0.5)
    }
}

local function fullCleanup()
    local toDestroy = {}
    for _, obj in ipairs(workspace:GetDescendants()) do
        if obj:IsA("Highlight") and (obj.Name == "PlayerESP" or obj.Name == "LootESP") then
            table.insert(toDestroy, obj)
        elseif obj:IsA("BillboardGui") and (obj.Name == "HealthESP" or obj.Name == "ItemESP") then
            table.insert(toDestroy, obj)
        end
    end
    for _, obj in ipairs(toDestroy) do
        pcall(function() obj:Destroy() end)
    end
end
fullCleanup()

local modsActive = true
local savedGunStats = {}

local function deepCopy(original)
    local copy = {}
    for k, v in next, original do
        if type(v) == "table" then
            copy[k] = deepCopy(v)
        else
            copy[k] = v
        end
    end
    return copy
end

local function applyGunMods(module, enable)
    local ok, data = pcall(require, module)
    if not ok or type(data) ~= "table" then return end
    if not savedGunStats[module] then
        savedGunStats[module] = deepCopy(data)
    end
    local original = savedGunStats[module]
    if enable then
        data.spread = 0.001
        data.ads_spread_mult = 0.001
        data.ads_cam_recoil_mult = 0.001
        data.ads_vm_recoil_mult = 0.001
        if type(data.recoil) == "table" then
            data.recoil.shake_1 = 0.001
            data.recoil.shake_2 = -0.001
            data.recoil.shake_delay = 0.001
            if type(data.recoil.side_shake) == "table" then
                data.recoil.side_shake = {-0.001, 0.001}
            end
        end
        if type(data.vm_recoil) == "table" then
            data.vm_recoil.PY = 0.001
            data.vm_recoil.PZ = 0.001
            data.vm_recoil.RY = 0.001
            if type(data.vm_recoil.PX) == "table" then
                data.vm_recoil.PX = {min = -0.001, max = 0.001}
            end
            if type(data.vm_recoil.RX) == "table" then
                data.vm_recoil.RX = {min = -0.001, max = 0.001}
            end
            if type(data.vm_recoil.RZ) == "table" then
                data.vm_recoil.RZ = {min = -0.001, max = 0.001}
            end
        end
    else
        data.spread = original.spread
        data.ads_spread_mult = original.ads_spread_mult
        data.ads_cam_recoil_mult = original.ads_cam_recoil_mult
        data.ads_vm_recoil_mult = original.ads_vm_recoil_mult
        if type(original.recoil) == "table" and type(data.recoil) == "table" then
            data.recoil.shake_1 = original.recoil.shake_1
            data.recoil.shake_2 = original.recoil.shake_2
            data.recoil.shake_delay = original.recoil.shake_delay
            if type(data.recoil.side_shake) == "table" and type(original.recoil.side_shake) == "table" then
                data.recoil.side_shake = original.recoil.side_shake
            end
        end
        if type(original.vm_recoil) == "table" and type(data.vm_recoil) == "table" then
            data.vm_recoil.PY = original.vm_recoil.PY
            data.vm_recoil.PZ = original.vm_recoil.PZ
            data.vm_recoil.RY = original.vm_recoil.RY
            data.vm_recoil.PX = original.vm_recoil.PX
            data.vm_recoil.RX = original.vm_recoil.RX
            data.vm_recoil.RZ = original.vm_recoil.RZ
        end
    end
end

local function setupWeaponMods()
    local modules = ReplicatedStorage:FindFirstChild("Modules")
    if not modules then return end
    local gunSettings = modules:FindFirstChild("Settings") and modules.Settings:FindFirstChild("Guns")
    if not gunSettings then return end
    for _, module in ipairs(gunSettings:GetChildren()) do
        if module:IsA("ModuleScript") then
            task.spawn(function() applyGunMods(module, modsActive) end)
        end
    end
    gunSettings.ChildAdded:Connect(function(module)
        if module:IsA("ModuleScript") then
            applyGunMods(module, modsActive)
        end
    end)
end
task.spawn(setupWeaponMods)

local espVisible = true
local playerData = {}
local lootItems = {}
local localPlayerTeam = nil

local function getPlayerModel(player)
    local playersContainer = workspace:FindFirstChild("Players")
    if not playersContainer then return nil end
    return playersContainer:FindFirstChild(player.Name)
end

local function updateLocalTeam()
    local localModel = getPlayerModel(PlayersService.LocalPlayer)
    if localModel and localModel:IsA("Model") then
        localPlayerTeam = localModel:GetAttribute("rg_team")
    else
        localPlayerTeam = nil
    end
end

local function isTeammate(playerModel)
    if not localPlayerTeam then return false end
    local theirTeam = playerModel:GetAttribute("rg_team")
    return theirTeam == localPlayerTeam and theirTeam ~= nil
end

local function getPlayerColor(playerModel)
    if isTeammate(playerModel) then
        return settings.TeammateColor
    end
    local team = playerModel:GetAttribute("rg_team")
    if team and settings.TeamColors[team] then
        return settings.TeamColors[team]
    end
    return Color3.new(0.8, 0.8, 0.8)
end

local function updateInventoryDisplay(player, data)
    for _, bill in ipairs(data.itemBillboards) do
        if bill and bill.Parent then bill:Destroy() end
    end
    data.itemBillboards = {}
    local character = player.Character
    if not character then return end
    local root = character:FindFirstChild("HumanoidRootPart")
    if not root then return end
    local items = {}
    for _, tool in ipairs(character:GetChildren()) do
        if tool:IsA("Tool") then
            table.insert(items, "⚔ " .. tool.Name)
        end
    end
    local backpack = player:FindFirstChildOfClass("Backpack")
    if backpack then
        for _, tool in ipairs(backpack:GetChildren()) do
            table.insert(items, "🎒 " .. tool.Name)
        end
    end
    for i, name in ipairs(items) do
        local bill = Instance.new("BillboardGui")
        bill.Name = "ItemESP"
        bill.AlwaysOnTop = true
        bill.Size = UDim2.new(0, 180, 0, 16)
        bill.StudsOffset = Vector3.new(0, settings.ItemBaseOffset.Y + ((i - 1) * settings.ItemRowSpacing), 0)
        bill.Adornee = root
        bill.Enabled = espVisible
        local label = Instance.new("TextLabel", bill)
        label.Size = UDim2.new(1, 0, 1, 0)
        label.BackgroundTransparency = 1
        label.TextColor3 = Color3.fromRGB(255, 255, 200)
        label.TextStrokeTransparency = 0.3
        label.Text = name
        label.Font = Enum.Font.GothamMedium
        label.TextSize = settings.ItemFontSize
        bill.Parent = root
        table.insert(data.itemBillboards, bill)
    end
end

local function clearCharacterVisuals(data)
    for _, conn in ipairs(data.characterConnections) do
        pcall(function() conn:Disconnect() end)
    end
    data.characterConnections = {}
    for _, bill in ipairs(data.itemBillboards) do
        if bill and bill.Parent then bill:Destroy() end
    end
    data.itemBillboards = {}
    if data.highlight and data.highlight.Parent then data.highlight:Destroy() end
    if data.healthGui and data.healthGui.Parent then data.healthGui:Destroy() end
    data.highlight = nil
    data.healthGui = nil
end

local function attachPlayerEsp(player, character, data)
    clearCharacterVisuals(data)
    local root = character:FindFirstChild("HumanoidRootPart")
    if not root then
        root = character:WaitForChild("HumanoidRootPart", 3)
    end
    local humanoid = character:FindFirstChild("Humanoid")
    if not humanoid then
        humanoid = character:WaitForChild("Humanoid", 3)
    end
    if not root or not humanoid or not character.Parent then return end

    local playerModel = getPlayerModel(player)
    if not playerModel or not playerModel:IsA("Model") then return end

    local currentColor = getPlayerColor(playerModel)

    local highlight = Instance.new("Highlight")
    highlight.Name = "PlayerESP"
    highlight.Adornee = character
    highlight.FillTransparency = settings.FillTransparency
    highlight.OutlineTransparency = settings.OutlineTransparency
    highlight.FillColor = currentColor
    highlight.OutlineColor = currentColor
    highlight.Enabled = espVisible
    highlight.Parent = character
    data.highlight = highlight

    local healthGui = Instance.new("BillboardGui")
    healthGui.Name = "HealthESP"
    healthGui.AlwaysOnTop = true
    healthGui.Size = UDim2.new(0, 130, 0, 18)
    healthGui.StudsOffset = settings.HealthOffset
    healthGui.Adornee = root
    healthGui.Enabled = espVisible
    local healthLabel = Instance.new("TextLabel", healthGui)
    healthLabel.Size = UDim2.new(1, 0, 1, 0)
    healthLabel.BackgroundTransparency = 1
    healthLabel.Font = Enum.Font.GothamBold
    healthLabel.TextSize = settings.HealthFontSize
    healthLabel.TextStrokeTransparency = 0.2
    healthGui.Parent = root
    data.healthGui = healthGui

    local function updateColors()
        if not highlight then return end
        local newColor = getPlayerColor(playerModel)
        highlight.FillColor = newColor
        highlight.OutlineColor = newColor
    end

    local function updateHealth()
        if not humanoid or not humanoid.Parent then return end
        local hp = math.floor(humanoid.Health)
        local maxHp = math.floor(humanoid.MaxHealth)
        healthLabel.Text = "❤ " .. hp .. " / " .. maxHp
        local healthColorVal = Color3.new(1, 0, 0):Lerp(Color3.new(0, 1, 0), math.clamp(hp / maxHp, 0, 1))
        healthLabel.TextColor3 = healthColorVal
    end

    local invDebounce = false
    local function onInventoryChange()
        if invDebounce then return end
        invDebounce = true
        task.delay(settings.InventoryDebounce, function()
            invDebounce = false
            if character and character.Parent and character:FindFirstChild("HumanoidRootPart") then
                updateInventoryDisplay(player, data)
            end
        end)
    end

    table.insert(data.characterConnections, humanoid:GetPropertyChangedSignal("Health"):Connect(updateHealth))
    table.insert(data.characterConnections, character.ChildAdded:Connect(onInventoryChange))
    table.insert(data.characterConnections, character.ChildRemoved:Connect(onInventoryChange))
    local backpack = player:FindFirstChildOfClass("Backpack")
    if backpack then
        table.insert(data.characterConnections, backpack.ChildAdded:Connect(onInventoryChange))
        table.insert(data.characterConnections, backpack.ChildRemoved:Connect(onInventoryChange))
    end

    local teamAttrConn = playerModel:GetAttributeChangedSignal("rg_team"):Connect(updateColors)
    table.insert(data.characterConnections, teamAttrConn)

    updateColors()
    updateHealth()
    updateInventoryDisplay(player, data)
end

local function startTracking(player)
    if player == PlayersService.LocalPlayer then return end
    if playerData[player] then
        for _, conn in ipairs(playerData[player].playerConnections) do
            pcall(function() conn:Disconnect() end)
        end
        clearCharacterVisuals(playerData[player])
    end
    playerData[player] = {
        itemBillboards = {},
        characterConnections = {},
        playerConnections = {},
        highlight = nil,
        healthGui = nil
    }
    local data = playerData[player]
    table.insert(data.playerConnections, player.CharacterAdded:Connect(function(char)
        attachPlayerEsp(player, char, data)
    end))
    if player.Character then
        attachPlayerEsp(player, player.Character, data)
    end
end

local function stopTracking(player)
    local data = playerData[player]
    if not data then return end
    for _, conn in ipairs(data.playerConnections) do
        pcall(function() conn:Disconnect() end)
    end
    clearCharacterVisuals(data)
    playerData[player] = nil
end

UserInputService.InputBegan:Connect(function(input, gameProcessed)
    if gameProcessed then return end
    if input.KeyCode == settings.ToggleKey then
        espVisible = not espVisible
        for _, plr in ipairs(PlayersService:GetPlayers()) do
            if plr.Character then
                for _, obj in ipairs(plr.Character:GetDescendants()) do
                    if obj:IsA("Highlight") or obj:IsA("BillboardGui") then
                        obj.Enabled = espVisible
                    end
                end
            end
        end
        for _, loot in pairs(lootItems) do
            if loot and loot.highlight and loot.highlight.Parent then
                loot.highlight.Enabled = espVisible
            end
        end
    elseif input.KeyCode == settings.ModKey then
        modsActive = not modsActive
        setupWeaponMods()
    end
end)

local function addLootHighlight(item)
    if not (item:IsA("Tool") or item:IsA("Model")) then return end
    if lootItems[item] then return end
    if not item.Parent then return end
    if not item:IsDescendantOf(workspace) then return end
    local highlight = Instance.new("Highlight")
    highlight.Name = "LootESP"
    highlight.FillColor = Color3.fromRGB(255, 150, 255)
    highlight.OutlineColor = Color3.fromRGB(255, 0, 255)
    highlight.FillTransparency = 0.4
    highlight.Enabled = espVisible
    highlight.Parent = item
    local conn
    conn = item.AncestryChanged:Connect(function()
        if not item:IsDescendantOf(workspace) then
            conn:Disconnect()
            if highlight and highlight.Parent then highlight:Destroy() end
            lootItems[item] = nil
        end
    end)
    lootItems[item] = {highlight = highlight, connection = conn}
end

local function monitorLoot()
    local gameFolder = workspace:FindFirstChild("Game")
    if not gameFolder then
        gameFolder = workspace:WaitForChild("Game", 10)
        if not gameFolder then return end
    end
    local lootFolder = gameFolder:FindFirstChild("Loot")
    if not lootFolder then
        lootFolder = Instance.new("Folder")
        lootFolder.Name = "Loot"
        lootFolder.Parent = gameFolder
    end
    local dropsFolder = lootFolder:FindFirstChild("drops")
    if not dropsFolder then
        dropsFolder = Instance.new("Folder")
        dropsFolder.Name = "drops"
        dropsFolder.Parent = lootFolder
    end

    local function refreshAllLoot()
        for _, existing in pairs(lootItems) do
            if existing and existing.highlight then existing.highlight:Destroy() end
            if existing and existing.connection then existing.connection:Disconnect() end
        end
        lootItems = {}
        for _, child in ipairs(dropsFolder:GetChildren()) do
            addLootHighlight(child)
        end
    end

    refreshAllLoot()
    dropsFolder.DescendantAdded:Connect(function(child)
        if child.Parent == dropsFolder then
            addLootHighlight(child)
        end
    end)
    dropsFolder.DescendantRemoving:Connect(function(child)
        local data = lootItems[child]
        if data then
            if data.connection then data.connection:Disconnect() end
            if data.highlight then data.highlight:Destroy() end
            lootItems[child] = nil
        end
    end)
    lootFolder.ChildAdded:Connect(function(child)
        if child.Name == "drops" and child:IsA("Folder") then
            dropsFolder = child
            refreshAllLoot()
        end
    end)
end
task.spawn(monitorLoot)

local function syncPlayers()
    local playersContainer = workspace:FindFirstChild("Players")
    if not playersContainer then
        playersContainer = workspace:WaitForChild("Players", 10)
        if not playersContainer then return end
    end

    updateLocalTeam()
    local localModel = getPlayerModel(PlayersService.LocalPlayer)
    if localModel then
        local teamConn = localModel:GetAttributeChangedSignal("rg_team"):Connect(function()
            updateLocalTeam()
            for player, data in pairs(playerData) do
                if data.highlight and data.highlight.Parent then
                    local model = getPlayerModel(player)
                    if model then
                        local newColor = getPlayerColor(model)
                        data.highlight.FillColor = newColor
                        data.highlight.OutlineColor = newColor
                    end
                end
            end
        end)
    end

    local function handlePlayerModel(model)
        if not model:IsA("Model") then return end
        local player = PlayersService:FindFirstChild(model.Name)
        if player then
            startTracking(player)
        else
            local playerAddedConn
            playerAddedConn = PlayersService.PlayerAdded:Connect(function(plr)
                if plr.Name == model.Name then
                    playerAddedConn:Disconnect()
                    startTracking(plr)
                end
            end)
        end
    end

    for _, model in ipairs(playersContainer:GetChildren()) do
        handlePlayerModel(model)
    end
    playersContainer.ChildAdded:Connect(handlePlayerModel)
    playersContainer.ChildRemoved:Connect(function(model)
        if model:IsA("Model") then
            local player = PlayersService:FindFirstChild(model.Name)
            if player then stopTracking(player) end
        end
    end)
end
task.spawn(syncPlayers)

for _, player in ipairs(PlayersService:GetPlayers()) do
    if player ~= PlayersService.LocalPlayer then
        startTracking(player)
    end
end
PlayersService.PlayerAdded:Connect(function(player)
    if player ~= PlayersService.LocalPlayer then
        startTracking(player)
    end
end)
PlayersService.PlayerRemoving:Connect(stopTracking)