Updated SOURCE ESP AIM TRIGGER DESYNC FPV ESP

-- This WILL NOT WORK ON LOW UNC EXECUTORS LIKE XENO

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local LocalPlayer = Players.LocalPlayer
local Mouse = LocalPlayer:GetMouse()

local Config = {
    ESP_Enabled = true,
    ESP_Boxes = true,
    ESP_Names = true,
    ESP_Distance = true,
    ESP_Skeleton = true,
    ESP_Weapons = false,
    ESP_Health = true,
    ESP_TeamCheck = true,
    ESP_MaxDist = 2000,
    ESP_Offscreen = true,
    ESP_AimDir = true,
    ESP_LookingAtYou = true,
    ESP_FPV = true,
    ESP_FPVPredict = true,
    ESP_Tracers = false,
    ESP_Velocity = false,
    ESP_Sound = false,
    ESP_Trails = false,
    RADAR_Enabled = true,
    RADAR_Size = 120,
    RADAR_Circle = false,
    AIM_Enabled = false,
    AIM_FOV = 150,
    AIM_Smooth = 15,
    AIM_ShowFOV = true,
    AIM_TeamCheck = true,
    AIM_FPV = false,
    DESYNC_Enabled = false,
    DESYNC_Amount = 2,
    TRIGGER_Enabled = false,
    TRIGGER_Delay = 50,
    TRIGGER_TeamCheck = true,
    SILENT_Enabled = false,
    SILENT_FOV = 120,
    SILENT_TeamCheck = true,
    MenuOpen = true
}

local Tuning = {
    TargetRefreshRate = 0.75,
    VisibilityRefreshRate = 0.15,
    WeaponRefreshRate = 2.0,
    FPVRefreshRate = 1.0,
    TeamRefreshRate = 5.0,
    
    BoxWidthRatio = 0.6,
    HealthBarWidth = 4,
    HealthBarOffset = 6,
    NameOffset = 18,
    DistOffset = 4,
    WeaponOffset = 8,
    LookingOffset = 35,
    
    OffscreenEdgeDist = 50,
    OffscreenArrowSize = 12,
    AimLineLength = 15,
    LookingThreshold = 0.85,
    
    SoundRippleMax = 15,
    SoundRippleDuration = 1.0,
    SoundRippleRadius = 35,
    SoundMoveThreshold = 1.0,
    
    TrailMaxPoints = 12,
    TrailUpdateInterval = 0.2,
    
    RadarRange = 150,
    RadarDotSize = 5,
    RadarArrowSize = 8,
    
    FPVClusterDist = 100,
    FPVGravity = 50,
    FPVPredictTime = 3,
    FPVPredictSteps = 30,
    
    TriggerRadius = 50
}

local Colors = {
    Enemy = Color3.fromRGB(255, 50, 50),
    EnemyVisible = Color3.fromRGB(0, 255, 0),
    Team = Color3.fromRGB(0, 150, 255),
    Skeleton = Color3.fromRGB(255, 255, 255),
    SkeletonVisible = Color3.fromRGB(0, 255, 0),
    LookingAtYou = Color3.fromRGB(255, 255, 0),
    AimDir = Color3.fromRGB(255, 150, 0),
    Weapon = Color3.fromRGB(255, 200, 100),
    FPV = Color3.fromRGB(255, 0, 255),
    Tracer = Color3.fromRGB(255, 100, 100),
    Sound = Color3.fromRGB(100, 200, 255),
    Trail = Color3.fromRGB(255, 150, 50),
    HealthHigh = Color3.fromRGB(0, 255, 0),
    HealthMid = Color3.fromRGB(255, 255, 0),
    HealthLow = Color3.fromRGB(255, 0, 0),
    HealthBg = Color3.fromRGB(40, 40, 40),
    RadarBg = Color3.fromRGB(20, 20, 20),
    RadarBorder = Color3.fromRGB(255, 50, 50),
    RadarYou = Color3.fromRGB(0, 255, 0),
    RadarEnemy = Color3.fromRGB(255, 50, 50),
    RadarTeam = Color3.fromRGB(0, 150, 255),
    MenuBg = Color3.fromRGB(12, 12, 12),
    MenuHighlight = Color3.fromRGB(255, 50, 50),
    MenuOn = Color3.fromRGB(50, 255, 50),
    MenuOff = Color3.fromRGB(80, 80, 80),
    MenuText = Color3.fromRGB(150, 150, 150),
}

local Timers = {
    lastTargetRefresh = 0,
    lastVisRefresh = 0,
    lastWeaponRefresh = 0,
    lastFPVRefresh = 0,
    lastTeamRefresh = 0,
    warningEnd = 0
}

local Cache = {
    targets = {},
    teamStatus = {},
    visibility = {},
    weapons = {},
    drones = {}
}

local Teams = {
    sets = {
        {colors = {{R=0.172549,G=0.192157,B=0.372549}, {R=0.454902,G=0.407843,B=0}}},
        {colors = {{R=0.454902,G=0.454902,B=0.454902}}},
    },
    localSet = nil
}

local Bones = {{"Head","Torso"},{"Torso","Left Arm"},{"Torso","Right Arm"},{"Torso","Left Leg"},{"Torso","Right Leg"}}

local Connections = {}
local Unloaded = false
local Silent = { hooked = false, currentRoot = nil }

local Team = {}

-- OLD METHOD (ArmBand Color Based) - Commented out, optional
--[[
function Team.colorMatch(c1, c2)
    return math.abs(c1.R-c2.R) < 0.03 and math.abs(c1.G-c2.G) < 0.03 and math.abs(c1.B-c2.B) < 0.03
end

function Team.getArmColor(char)
    local ok, c = pcall(function()
        return char:FindFirstChild("Right Arm") and char["Right Arm"]:FindFirstChild("ArmBand") and char["Right Arm"].ArmBand.Color
    end)
    return ok and c
end

function Team.update()
    if LocalPlayer.Character then
        local col = Team.getArmColor(LocalPlayer.Character)
        if col then
            for _, set in pairs(Teams.sets) do
                for _, tc in pairs(set.colors) do
                    if Team.colorMatch(col, tc) then Teams.localSet = set; return end
                end
            end
        end
    end
end

function Team.isTeammate_OLD(char)
    if not Teams.localSet then return false end
    local col = Team.getArmColor(char)
    if not col then return false end
    for _, tc in pairs(Teams.localSet.colors) do
        if Team.colorMatch(col, tc) then return true end
    end
    return false
end

Connections.charAdded = LocalPlayer.CharacterAdded:Connect(function() task.delay(1, Team.update) end)
task.spawn(Team.update)
--]]

-- NEW METHOD (Parent Based) - checks if character parent matches local player's
function Team.isTeammate(char)
    if not LocalPlayer.Character then return false end
    if not char or not char.Parent then return false end
    
    local localParent = LocalPlayer.Character.Parent
    local charParent = char.Parent
    
    if not localParent or not charParent then return false end
    
    if localParent == charParent then
        return true
    end
    
    return false
end

function Team.isSpectator(char)
    if not char or not char.Parent then return true end
    
    local parentName = char.Parent.Name:lower()
    if parentName:find("spectator") or parentName:find("dead") or parentName:find("observer") then
        return true
    end
    
    return false
end

local Util = {}

function Util.isVisible(character)
    if not character then return false end
    local cam = workspace.CurrentCamera
    if not cam then return false end
    
    local origin = cam.CFrame.Position
    local parts = {"Head", "Torso", "HumanoidRootPart"}
    
    local rayParams = RaycastParams.new()
    rayParams.FilterType = Enum.RaycastFilterType.Blacklist
    local filter = {cam}
    if LocalPlayer.Character then table.insert(filter, LocalPlayer.Character) end
    table.insert(filter, character)
    rayParams.FilterDescendantsInstances = filter
    
    for _, partName in pairs(parts) do
        local part = character:FindFirstChild(partName)
        if part then
            local dir = (part.Position - origin)
            local result = workspace:Raycast(origin, dir.Unit * dir.Magnitude, rayParams)
            if not result or (result.Position - part.Position).Magnitude < 5 then
                return true
        end
    end
    end
    return false
end

function Util.isLookingAtYou(char)
    if not LocalPlayer.Character then return false end
    local myHead = LocalPlayer.Character:FindFirstChild("Head")
    local head = char:FindFirstChild("Head")
    if not myHead or not head then return false end
    local toYou = (myHead.Position - head.Position).Unit
    return toYou:Dot(head.CFrame.LookVector) > Tuning.LookingThreshold
end

function Util.getWeapon(char)
    for _, child in pairs(char:GetChildren()) do
        if child.Name == "ItemFolder" and child:IsA("Folder") then
            local items = child:GetChildren()
            if #items > 0 then return items[1].Name end
        end
    end
    local charName = char.Name
    for _, folder in pairs(workspace:GetChildren()) do
        if folder:IsA("Folder") then
            for _, sub in pairs(folder:GetChildren()) do
                if sub:IsA("Folder") or sub:IsA("Model") then
                    local pf = sub:FindFirstChild(charName)
                    if pf then
                        local itemFolder = pf:FindFirstChild("ItemFolder")
                        if itemFolder and #itemFolder:GetChildren() > 0 then
                            return itemFolder:GetChildren()[1].Name
                        end
        end
    end
end
    end
end
    return nil
end

function Util.getName(char)
    for _, p in pairs(Players:GetPlayers()) do
        if p.Character == char then return p.Name end
    end
    return (not char.Name:match("^[Il]+")) and char.Name or "Player"
end

local Targets = {}

function Targets.refresh()
    local new, newTeam = {}, {}
    local myChar = LocalPlayer.Character
    for _, obj in ipairs(workspace:GetDescendants()) do
        if obj.Name == "HumanoidRootPart" and obj:IsA("BasePart") then
            local parent = obj.Parent
            if parent and parent ~= myChar and obj.Position.Y > -50 then
                if Team.isSpectator(parent) then continue end
                
                local hum = parent:FindFirstChild("Humanoid")
                if hum and hum.Health > 0 then
                    new[obj] = parent
                    newTeam[obj] = Team.isTeammate(parent)
                end
            end
        end
    end
    Cache.targets = new
    Cache.teamStatus = newTeam
end

function Targets.refreshVisibility()
    local count = 0
    for root, char in pairs(Cache.targets) do
        count = count + 1
        if count > 20 then Cache.visibility[root] = false
        else Cache.visibility[root] = Util.isVisible(char) end
    end
end

function Targets.refreshWeapons()
    for root, char in pairs(Cache.targets) do
        Cache.weapons[root] = Util.getWeapon(char)
    end
end

local ESP = {
    cache = {},
    velocityData = {}
}

function ESP.create()
    return {
        Box = {Drawing.new("Line"), Drawing.new("Line"), Drawing.new("Line"), Drawing.new("Line")},
        Name = Drawing.new("Text"),
        Dist = Drawing.new("Text"),
        Weapon = Drawing.new("Text"),
        HealthBg = Drawing.new("Square"),
        HealthBar = Drawing.new("Square"),
        Skel = {Drawing.new("Line"), Drawing.new("Line"), Drawing.new("Line"), Drawing.new("Line"), Drawing.new("Line")},
        Offscreen = Drawing.new("Triangle"),
        AimLine = Drawing.new("Line"),
        LookingText = Drawing.new("Text"),
        Tracer = Drawing.new("Line"),
        SilentText = Drawing.new("Text"),
        VelLine = Drawing.new("Line"),
        VelArrow = Drawing.new("Triangle"),
    }
end

function ESP.setup(esp)
    for _, l in pairs(esp.Box) do l.Thickness = 1 end
    esp.Name.Size = 14; esp.Name.Font = Drawing.Fonts.Monospace; esp.Name.Center = true; esp.Name.Outline = true
    esp.Dist.Size = 12; esp.Dist.Font = Drawing.Fonts.Monospace; esp.Dist.Center = true; esp.Dist.Outline = true
    esp.Weapon.Size = 12; esp.Weapon.Font = Drawing.Fonts.Monospace; esp.Weapon.Outline = true
    esp.HealthBg.Filled = true; esp.HealthBg.Color = Colors.HealthBg
    esp.HealthBar.Filled = true
    for _, l in pairs(esp.Skel) do l.Thickness = 1 end
    esp.Offscreen.Filled = true; esp.Offscreen.Thickness = 2
    esp.AimLine.Thickness = 2
    esp.LookingText.Size = 14; esp.LookingText.Font = Drawing.Fonts.Monospace; esp.LookingText.Center = true; esp.LookingText.Outline = true
    esp.Tracer.Thickness = 1; esp.Tracer.Color = Colors.Tracer
    esp.SilentText.Size = 13; esp.SilentText.Font = Drawing.Fonts.Monospace; esp.SilentText.Center = true; esp.SilentText.Outline = true; esp.SilentText.Color = Color3.fromRGB(100, 200, 255)
    esp.VelLine.Thickness = 2; esp.VelLine.Color = Color3.fromRGB(0, 255, 255)
    esp.VelArrow.Filled = true; esp.VelArrow.Color = Color3.fromRGB(0, 255, 255)
end

function ESP.hide(esp)
    for _, l in pairs(esp.Box) do l.Visible = false end
    esp.Name.Visible = false; esp.Dist.Visible = false; esp.Weapon.Visible = false
    esp.HealthBg.Visible = false; esp.HealthBar.Visible = false
    for _, l in pairs(esp.Skel) do l.Visible = false end
    esp.Offscreen.Visible = false; esp.AimLine.Visible = false; esp.LookingText.Visible = false
    esp.Tracer.Visible = false; esp.SilentText.Visible = false
    esp.VelLine.Visible = false; esp.VelArrow.Visible = false
end

function ESP.destroy(esp)
    pcall(function()
        for _, l in pairs(esp.Box) do l:Remove() end
        esp.Name:Remove(); esp.Dist:Remove(); esp.Weapon:Remove()
        esp.HealthBg:Remove(); esp.HealthBar:Remove()
        for _, l in pairs(esp.Skel) do l:Remove() end
        esp.Offscreen:Remove(); esp.AimLine:Remove(); esp.LookingText:Remove()
        esp.Tracer:Remove(); esp.SilentText:Remove()
        esp.VelLine:Remove(); esp.VelArrow:Remove()
    end)
end

function ESP.cleanup()
    for root, esp in pairs(ESP.cache) do
        if not Cache.targets[root] then
            ESP.hide(esp)
            ESP.destroy(esp)
            ESP.cache[root] = nil
            ESP.velocityData[root] = nil
        end
    end
end

function ESP.hideAll()
    for _, esp in pairs(ESP.cache) do ESP.hide(esp) end
end

function ESP.step(cam, screenSize, screenCenter)
    if not Config.ESP_Enabled then
        ESP.hideAll()
        return
    end
    
    ESP.cleanup()
    
    for root, char in pairs(Cache.targets) do
        if not root or not root.Parent or not char then
            if ESP.cache[root] then ESP.hide(ESP.cache[root]); ESP.destroy(ESP.cache[root]); ESP.cache[root] = nil end
        else
            local hum = char:FindFirstChild("Humanoid")
            if not hum or hum.Health <= 0 then
                if ESP.cache[root] then ESP.hide(ESP.cache[root]) end
            elseif Config.ESP_TeamCheck and Cache.teamStatus[root] then
                if ESP.cache[root] then ESP.hide(ESP.cache[root]) end
            else
                if not ESP.cache[root] then
                    ESP.cache[root] = ESP.create()
                    ESP.setup(ESP.cache[root])
                end
                local esp = ESP.cache[root]
                local myRoot = LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
                local dist = myRoot and (root.Position - myRoot.Position).Magnitude or 0
                
                if dist > Config.ESP_MaxDist then
                    ESP.hide(esp)
                else
                    ESP.render(esp, root, char, hum, cam, screenSize, screenCenter, dist)
                end
            end
        end
    end
end

function ESP.render(esp, root, char, hum, cam, screenSize, screenCenter, dist)
    local head = char:FindFirstChild("Head")
    local headPos = head and head.Position or (root.Position + Vector3.new(0,2,0))
    local feetPos = root.Position - Vector3.new(0, 3, 0)
    local topPos = headPos + Vector3.new(0, 0.5, 0)
    
    local rs, ron = cam:WorldToViewportPoint(root.Position)
    local hs = cam:WorldToViewportPoint(topPos)
    local fs = cam:WorldToViewportPoint(feetPos)
    
    local onScreen = ron and rs.Z > 0
    local isTeam = Cache.teamStatus[root] or false
    local visible = Cache.visibility[root] or false
    local col = isTeam and Colors.Team or (visible and Colors.EnemyVisible or Colors.Enemy)
    local skelCol = isTeam and Colors.Team or (visible and Colors.SkeletonVisible or Colors.Skeleton)
    local lookingAtYou = visible and Util.isLookingAtYou(char) or false
    
    if onScreen then
        esp.Offscreen.Visible = false
        local boxTop, boxBottom = hs.Y, fs.Y
        local boxHeight = math.abs(boxBottom - boxTop)
        local boxWidth = boxHeight * Tuning.BoxWidthRatio
        local cx = rs.X
        
        if Config.ESP_Boxes then
            esp.Box[1].From = Vector2.new(cx - boxWidth/2, boxTop)
            esp.Box[1].To = Vector2.new(cx + boxWidth/2, boxTop)
            esp.Box[2].From = Vector2.new(cx + boxWidth/2, boxTop)
            esp.Box[2].To = Vector2.new(cx + boxWidth/2, boxBottom)
            esp.Box[3].From = Vector2.new(cx + boxWidth/2, boxBottom)
            esp.Box[3].To = Vector2.new(cx - boxWidth/2, boxBottom)
            esp.Box[4].From = Vector2.new(cx - boxWidth/2, boxBottom)
            esp.Box[4].To = Vector2.new(cx - boxWidth/2, boxTop)
            for _, l in pairs(esp.Box) do l.Color = col; l.Visible = true end
        else
            for _, l in pairs(esp.Box) do l.Visible = false end
        end
        
        if Config.ESP_Names then
            esp.Name.Text = Util.getName(char)
            esp.Name.Position = Vector2.new(cx, hs.Y - Tuning.NameOffset)
            esp.Name.Color = col
            esp.Name.Visible = true
        else esp.Name.Visible = false end
        
        if Config.ESP_Distance then
            esp.Dist.Text = math.floor(dist) .. "m"
            esp.Dist.Position = Vector2.new(cx, fs.Y + Tuning.DistOffset)
            esp.Dist.Color = Color3.fromRGB(180,180,180)
            esp.Dist.Visible = true
        else esp.Dist.Visible = false end
        
        if Config.ESP_Weapons then
            local weapon = Cache.weapons[root]
            if weapon then
                esp.Weapon.Text = "[" .. weapon .. "]"
                esp.Weapon.Position = Vector2.new(cx + boxWidth/2 + Tuning.WeaponOffset, rs.Y)
                esp.Weapon.Color = Colors.Weapon
                esp.Weapon.Visible = true
            else esp.Weapon.Visible = false end
        else esp.Weapon.Visible = false end
        
        if Config.ESP_Health then
            local pct = math.clamp(hum.Health / hum.MaxHealth, 0, 1)
            local barX = cx - boxWidth/2 - Tuning.HealthBarOffset
            esp.HealthBg.Position = Vector2.new(barX - 1, boxTop - 1)
            esp.HealthBg.Size = Vector2.new(Tuning.HealthBarWidth + 2, boxHeight + 2)
            esp.HealthBg.Visible = true
            local hh = boxHeight * pct
            esp.HealthBar.Position = Vector2.new(barX, boxBottom - hh)
            esp.HealthBar.Size = Vector2.new(Tuning.HealthBarWidth, hh)
            esp.HealthBar.Color = pct > 0.6 and Colors.HealthHigh or pct > 0.3 and Colors.HealthMid or Colors.HealthLow
            esp.HealthBar.Visible = true
        else esp.HealthBg.Visible = false; esp.HealthBar.Visible = false end
        
        if Config.ESP_Skeleton then
            for i, b in pairs(Bones) do
                local p1, p2 = char:FindFirstChild(b[1]), char:FindFirstChild(b[2])
                if p1 and p2 then
                    local s1, o1 = cam:WorldToViewportPoint(p1.Position)
                    local s2, o2 = cam:WorldToViewportPoint(p2.Position)
                    if o1 and o2 and s1.Z > 0 and s2.Z > 0 then
                        esp.Skel[i].From = Vector2.new(s1.X, s1.Y)
                        esp.Skel[i].To = Vector2.new(s2.X, s2.Y)
                        esp.Skel[i].Color = skelCol
                        esp.Skel[i].Visible = true
                    else esp.Skel[i].Visible = false end
                else esp.Skel[i].Visible = false end
            end
        else for _, l in pairs(esp.Skel) do l.Visible = false end end
        
        if Config.ESP_AimDir and head then
            local aimEnd = head.Position + head.CFrame.LookVector * Tuning.AimLineLength
            local aimScreen, aimOn = cam:WorldToViewportPoint(aimEnd)
            local headScreen = cam:WorldToViewportPoint(head.Position)
            if aimOn and headScreen.Z > 0 then
                esp.AimLine.From = Vector2.new(headScreen.X, headScreen.Y)
                esp.AimLine.To = Vector2.new(aimScreen.X, aimScreen.Y)
                esp.AimLine.Color = Colors.AimDir
                esp.AimLine.Visible = true
            else esp.AimLine.Visible = false end
        else esp.AimLine.Visible = false end
        
        if Config.ESP_LookingAtYou and lookingAtYou then
            esp.LookingText.Text = "[!] LOOKING"
            esp.LookingText.Position = Vector2.new(cx, hs.Y - Tuning.LookingOffset)
            esp.LookingText.Color = Colors.LookingAtYou
            esp.LookingText.Visible = true
        else esp.LookingText.Visible = false end
        
        if Config.ESP_Tracers then
            esp.Tracer.From = Vector2.new(screenCenter.X, screenSize.Y)
            esp.Tracer.To = Vector2.new(cx, fs.Y)
            esp.Tracer.Color = visible and Colors.EnemyVisible or Colors.Tracer
            esp.Tracer.Visible = true
        else esp.Tracer.Visible = false end
        
        if Config.SILENT_Enabled and Silent.currentRoot == root and visible then
            esp.SilentText.Text = "[SILENT]"
            esp.SilentText.Position = Vector2.new(cx, hs.Y - Tuning.LookingOffset - 15)
            esp.SilentText.Visible = true
        else esp.SilentText.Visible = false end
        
        local vd = ESP.velocityData[root]
        if not vd then vd = {pos = root.Position, vel = Vector3.zero, time = tick()}; ESP.velocityData[root] = vd end
        local now = tick()
        local dt = now - vd.time
        if dt > 0.03 then
            local rawVel = (root.Position - vd.pos) / dt
            vd.vel = vd.vel * 0.7 + rawVel * 0.3
            vd.pos = root.Position
            vd.time = now
        end
        if Config.ESP_Velocity and not isTeam then
            local velFlat = Vector3.new(vd.vel.X, 0, vd.vel.Z)
            local velMag = velFlat.Magnitude
            if velMag > 2 then
                local futurePos = root.Position + velFlat.Unit * math.clamp(velMag * 0.4, 5, 20)
                local futureScreen, futureOn = cam:WorldToViewportPoint(futurePos)
                if futureOn and futureScreen.Z > 0 then
                    esp.VelLine.From = Vector2.new(rs.X, rs.Y)
                    esp.VelLine.To = Vector2.new(futureScreen.X, futureScreen.Y)
                    esp.VelLine.Visible = true
                    local dx, dy = futureScreen.X - rs.X, futureScreen.Y - rs.Y
                    local len = math.sqrt(dx*dx + dy*dy)
                    if len > 5 then
                        local fx, fy = dx/len, dy/len
                        esp.VelArrow.PointA = Vector2.new(futureScreen.X, futureScreen.Y)
                        esp.VelArrow.PointB = Vector2.new(futureScreen.X - fx*10 + fy*5, futureScreen.Y - fy*10 - fx*5)
                        esp.VelArrow.PointC = Vector2.new(futureScreen.X - fx*10 - fy*5, futureScreen.Y - fy*10 + fx*5)
                        esp.VelArrow.Visible = true
                    else esp.VelArrow.Visible = false end
                else esp.VelLine.Visible = false; esp.VelArrow.Visible = false end
            else esp.VelLine.Visible = false; esp.VelArrow.Visible = false end
        else esp.VelLine.Visible = false; esp.VelArrow.Visible = false end
        
        if Config.ESP_Sound and not isTeam then
            local velMag = vd.vel.Magnitude
            if velMag > Tuning.SoundMoveThreshold then
                Sound.addRipple(Vector3.new(root.Position.X, root.Position.Y - 2, root.Position.Z))
            end
        end
        
        if Config.ESP_Trails and not isTeam then
            Trails.update(char, root.Position)
            Trails.draw(char, cam)
        else Trails.hide(char) end
    else
        for _, l in pairs(esp.Box) do l.Visible = false end
        esp.Name.Visible = false; esp.Dist.Visible = false; esp.Weapon.Visible = false
        esp.HealthBg.Visible = false; esp.HealthBar.Visible = false
        for _, l in pairs(esp.Skel) do l.Visible = false end
        esp.AimLine.Visible = false; esp.LookingText.Visible = false; esp.Tracer.Visible = false
        esp.SilentText.Visible = false; esp.VelLine.Visible = false; esp.VelArrow.Visible = false
        Trails.hide(char)
        
        if Config.ESP_Offscreen and visible then
            local screenPos = cam:WorldToViewportPoint(root.Position)
            local dx, dy = screenPos.X - screenCenter.X, screenPos.Y - screenCenter.Y
            local angle = math.atan2(dy, dx)
            local arrowX = math.clamp(screenCenter.X + math.cos(angle) * (screenSize.X/2 - Tuning.OffscreenEdgeDist), Tuning.OffscreenEdgeDist, screenSize.X - Tuning.OffscreenEdgeDist)
            local arrowY = math.clamp(screenCenter.Y + math.sin(angle) * (screenSize.Y/2 - Tuning.OffscreenEdgeDist), Tuning.OffscreenEdgeDist, screenSize.Y - Tuning.OffscreenEdgeDist)
            local fwd = Vector2.new(math.cos(angle), math.sin(angle))
            local right = Vector2.new(-fwd.Y, fwd.X)
            local pos = Vector2.new(arrowX, arrowY)
            esp.Offscreen.PointA = pos + fwd * Tuning.OffscreenArrowSize
            esp.Offscreen.PointB = pos - fwd * Tuning.OffscreenArrowSize/2 - right * Tuning.OffscreenArrowSize/2
            esp.Offscreen.PointC = pos - fwd * Tuning.OffscreenArrowSize/2 + right * Tuning.OffscreenArrowSize/2
            esp.Offscreen.Color = Colors.EnemyVisible
            esp.Offscreen.Visible = true
        else esp.Offscreen.Visible = false end
    end
end

Sound = { ripples = {} }

function Sound.addRipple(pos)
    if #Sound.ripples >= Tuning.SoundRippleMax then
        local old = table.remove(Sound.ripples, 1)
        if old.circles then for _, c in pairs(old.circles) do c:Remove() end end
    end
    local r = {position = pos, startTime = tick(), circles = {}}
    for i = 1, 3 do
        local c = Drawing.new("Circle")
        c.Filled = false; c.Color = Colors.Sound; c.Thickness = 1; c.NumSides = 32; c.Visible = false
        r.circles[i] = c
    end
    table.insert(Sound.ripples, r)
end

function Sound.step(cam)
    if not Config.ESP_Enabled or not Config.ESP_Sound then
        for _, r in ipairs(Sound.ripples) do for _, c in ipairs(r.circles) do c.Visible = false end end
        return
    end
    local now, remove = tick(), {}
    for i, r in ipairs(Sound.ripples) do
        local age = now - r.startTime
        if age > Tuning.SoundRippleDuration then table.insert(remove, i)
        else
            local sp, on = cam:WorldToViewportPoint(r.position)
            if on and sp.Z > 0 then
                for j, c in ipairs(r.circles) do
                    local ca = age - (j-1) * 0.2
                    if ca > 0 and ca < Tuning.SoundRippleDuration then
                        local prog = ca / Tuning.SoundRippleDuration
                        c.Position = Vector2.new(sp.X, sp.Y)
                        c.Radius = prog * Tuning.SoundRippleRadius
                        c.Transparency = (1 - prog) * 0.8
                        c.Visible = true
                    else c.Visible = false end
                end
            else for _, c in ipairs(r.circles) do c.Visible = false end end
        end
    end
    for i = #remove, 1, -1 do
        local r = Sound.ripples[remove[i]]
        if r.circles then for _, c in pairs(r.circles) do c:Remove() end end
        table.remove(Sound.ripples, remove[i])
    end
end

Trails = { data = {} }

function Trails.getOrCreate(char)
    if not Trails.data[char] then
        Trails.data[char] = {positions = {}, lines = {}, lastUpdate = 0}
        for i = 1, Tuning.TrailMaxPoints - 1 do
            local l = Drawing.new("Line"); l.Thickness = 2; l.Color = Colors.Trail; l.Visible = false
            Trails.data[char].lines[i] = l
        end
    end
    return Trails.data[char]
end

function Trails.update(char, pos)
    local t = Trails.getOrCreate(char)
    if tick() - t.lastUpdate > Tuning.TrailUpdateInterval then
        table.insert(t.positions, 1, pos)
        if #t.positions > Tuning.TrailMaxPoints then table.remove(t.positions) end
        t.lastUpdate = tick()
    end
end

function Trails.draw(char, cam)
    local t = Trails.data[char]
    if not t then return end
    for i, line in ipairs(t.lines) do
        if t.positions[i] and t.positions[i+1] then
            local s1, o1 = cam:WorldToViewportPoint(t.positions[i])
            local s2, o2 = cam:WorldToViewportPoint(t.positions[i+1])
            if (o1 or o2) and s1.Z > 0 and s2.Z > 0 then
                line.From = Vector2.new(s1.X, s1.Y)
                line.To = Vector2.new(s2.X, s2.Y)
                line.Transparency = (1 - i/Tuning.TrailMaxPoints) * 0.8
                line.Visible = true
            else line.Visible = false end
        else line.Visible = false end
    end
end

function Trails.hide(char)
    local t = Trails.data[char]
    if t then for _, l in ipairs(t.lines) do l.Visible = false end end
end

function Trails.hideAll()
    for _, t in pairs(Trails.data) do
        for _, l in ipairs(t.lines) do l.Visible = false end
    end
end

function Trails.cleanup()
    if not Config.ESP_Enabled or not Config.ESP_Trails then
        Trails.hideAll()
    end
    for char in pairs(Trails.data) do
        local found = false
        for _, c in pairs(Cache.targets) do if c == char then found = true; break end end
        if not found then
            for _, l in ipairs(Trails.data[char].lines) do l:Remove() end
            Trails.data[char] = nil
        end
    end
end

local FPV = {
    cache = {},
    partNames = {"Blade_BL", "Blade_BR", "Blade_FL", "Blade_FR", "Explosive", "Explosive1", "Rotator_BL", "Rotator_BR", "Rotator_FL", "Rotator_FR", "FPV"}
}

function FPV.create()
    return {
        Box = {Drawing.new("Line"), Drawing.new("Line"), Drawing.new("Line"), Drawing.new("Line")},
        Name = Drawing.new("Text"), Dist = Drawing.new("Text"),
        Trajectory = Drawing.new("Line"), TrajectoryEnd = Drawing.new("Circle"),
        lastPos = nil, lastTime = 0, velocity = Vector3.new(0,0,0)
    }
end

function FPV.setup(esp)
    for _, l in pairs(esp.Box) do l.Thickness = 2; l.Color = Colors.FPV end
    esp.Name.Size = 14; esp.Name.Font = Drawing.Fonts.Monospace; esp.Name.Center = true; esp.Name.Outline = true; esp.Name.Color = Colors.FPV
    esp.Dist.Size = 12; esp.Dist.Font = Drawing.Fonts.Monospace; esp.Dist.Center = true; esp.Dist.Outline = true; esp.Dist.Color = Colors.FPV
    esp.Trajectory.Thickness = 2; esp.Trajectory.Color = Color3.fromRGB(255, 100, 0)
    esp.TrajectoryEnd.Filled = true; esp.TrajectoryEnd.Color = Color3.fromRGB(255, 50, 50); esp.TrajectoryEnd.Radius = 5; esp.TrajectoryEnd.NumSides = 16
end

function FPV.hide(esp)
    for _, l in pairs(esp.Box) do l.Visible = false end
    esp.Name.Visible = false; esp.Dist.Visible = false
    esp.Trajectory.Visible = false; esp.TrajectoryEnd.Visible = false
end

function FPV.destroy(esp)
    pcall(function()
        for _, l in pairs(esp.Box) do l:Remove() end
        esp.Name:Remove(); esp.Dist:Remove(); esp.Trajectory:Remove(); esp.TrajectoryEnd:Remove()
    end)
end

local fpvNameSet = {}
for _, n in ipairs(FPV.partNames) do fpvNameSet[n] = true end

function FPV.scan()
    if not Config.ESP_FPV then return {} end
    local drones, seen = {}, {}
    local camRef = workspace.CurrentCamera
    local plrs = Players:GetPlayers()
    for _, obj in ipairs(workspace:GetDescendants()) do
        if obj:IsA("BasePart") and fpvNameSet[obj.Name] then
            local model = obj.Parent
            if model and model:IsA("Model") and not seen[model] then
                local skip = false
                if camRef and model:IsDescendantOf(camRef) then skip = true end
                if not skip then
                    for i = 1, #plrs do
                        if plrs[i].Character and model:IsDescendantOf(plrs[i].Character) then skip = true; break end
                    end
                end
                if not skip then
                    seen[model] = true
                    local center = model:FindFirstChild("Explosive") or model:FindFirstChild("FPV") or obj
                    drones[model] = center
                end
            end
        end
    end
    return drones
end

function FPV.step(cam)
    if not Config.ESP_Enabled or not Config.ESP_FPV then
        for _, e in pairs(FPV.cache) do FPV.hide(e) end
        return
    end
    
    local screenPos, toShow = {}, {}
    for drone, part in pairs(Cache.drones) do
        local sp, on = cam:WorldToViewportPoint(part.Position)
        if on and sp.Z > 0 then
            local tooClose = false
            for _, ex in pairs(screenPos) do
                if math.sqrt((sp.X-ex.X)^2 + (sp.Y-ex.Y)^2) < Tuning.FPVClusterDist then tooClose = true; break end
            end
            if not tooClose then screenPos[drone] = sp; toShow[drone] = part end
        end
    end
    
    for drone, esp in pairs(FPV.cache) do
        if not toShow[drone] then FPV.hide(esp); FPV.destroy(esp); FPV.cache[drone] = nil end
    end
    
    for drone, part in pairs(toShow) do
        if not FPV.cache[drone] then FPV.cache[drone] = FPV.create(); FPV.setup(FPV.cache[drone]) end
        local esp = FPV.cache[drone]
        local pos = part.Position
        local sp, on = cam:WorldToViewportPoint(pos)
        if on and sp.Z > 0 then
            local myRoot = LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
            local dist = myRoot and (pos - myRoot.Position).Magnitude or 0
            if dist < Config.ESP_MaxDist then
                local size = math.clamp(1000 / sp.Z, 20, 100)
                local cx, cy = sp.X, sp.Y
                esp.Box[1].From = Vector2.new(cx-size/2, cy-size/2); esp.Box[1].To = Vector2.new(cx+size/2, cy-size/2)
                esp.Box[2].From = Vector2.new(cx+size/2, cy-size/2); esp.Box[2].To = Vector2.new(cx+size/2, cy+size/2)
                esp.Box[3].From = Vector2.new(cx+size/2, cy+size/2); esp.Box[3].To = Vector2.new(cx-size/2, cy+size/2)
                esp.Box[4].From = Vector2.new(cx-size/2, cy+size/2); esp.Box[4].To = Vector2.new(cx-size/2, cy-size/2)
                for _, l in pairs(esp.Box) do l.Visible = true end
                esp.Name.Text = "[FPV DRONE]"; esp.Name.Position = Vector2.new(cx, cy-size/2-18); esp.Name.Visible = true
                esp.Dist.Text = math.floor(dist).."m"; esp.Dist.Position = Vector2.new(cx, cy+size/2+4); esp.Dist.Visible = true
                
                if Config.ESP_FPVPredict then
                    local now = tick()
                    if esp.lastPos and now - esp.lastTime < 0.5 then
                        local dt = now - esp.lastTime
                        if dt > 0 then esp.velocity = esp.velocity:Lerp((pos - esp.lastPos)/dt, 0.3) end
                    end
                    esp.lastPos, esp.lastTime = pos, now
                    if esp.velocity.Magnitude > 1 then
                        local simPos, simVel, hit = pos, esp.velocity, nil
                        local dt = Tuning.FPVPredictTime / Tuning.FPVPredictSteps
                        for _ = 1, Tuning.FPVPredictSteps do
                            simVel = simVel + Vector3.new(0, -Tuning.FPVGravity * dt, 0)
                            simPos = simPos + simVel * dt
                            if simPos.Y < -10 then hit = simPos; break end
                        end
                        local endPos = hit or simPos
                        local es, eo = cam:WorldToViewportPoint(endPos)
                        if eo and es.Z > 0 then
                            esp.Trajectory.From = Vector2.new(cx, cy); esp.Trajectory.To = Vector2.new(es.X, es.Y); esp.Trajectory.Visible = true
                            esp.TrajectoryEnd.Position = Vector2.new(es.X, es.Y); esp.TrajectoryEnd.Visible = true
                        else esp.Trajectory.Visible = false; esp.TrajectoryEnd.Visible = false end
                    else esp.Trajectory.Visible = false; esp.TrajectoryEnd.Visible = false end
                else esp.Trajectory.Visible = false; esp.TrajectoryEnd.Visible = false end
            else FPV.hide(esp) end
        else FPV.hide(esp) end
    end
end

local Radar = {
    bg = Drawing.new("Square"),
    circleBg = Drawing.new("Circle"),
    border = Drawing.new("Square"),
    circleBorder = Drawing.new("Circle"),
    cross1 = Drawing.new("Line"),
    cross2 = Drawing.new("Line"),
    center = Drawing.new("Triangle"),
    dots = {},
    fpvDots = {}
}

do
    Radar.bg.Filled = true; Radar.bg.Color = Colors.RadarBg; Radar.bg.Transparency = 0.8
    Radar.circleBg.Filled = true; Radar.circleBg.Color = Colors.RadarBg; Radar.circleBg.Transparency = 0.8; Radar.circleBg.NumSides = 64
    Radar.border.Filled = false; Radar.border.Color = Colors.RadarBorder; Radar.border.Thickness = 2
    Radar.circleBorder.Filled = false; Radar.circleBorder.Color = Colors.RadarBorder; Radar.circleBorder.Thickness = 2; Radar.circleBorder.NumSides = 64
    Radar.cross1.Color = Color3.fromRGB(40,40,40); Radar.cross1.Thickness = 1
    Radar.cross2.Color = Color3.fromRGB(40,40,40); Radar.cross2.Thickness = 1
    Radar.center.Filled = true; Radar.center.Color = Colors.RadarYou
    for i = 1, 50 do local d = Drawing.new("Triangle"); d.Filled = true; d.Visible = false; Radar.dots[i] = d end
    for i = 1, 10 do local c = Drawing.new("Circle"); c.Filled = true; c.Color = Colors.FPV; c.Radius = 4; c.NumSides = 16; c.Visible = false; Radar.fpvDots[i] = c end
end

function Radar.hideAll()
    Radar.bg.Visible = false; Radar.circleBg.Visible = false; Radar.border.Visible = false; Radar.circleBorder.Visible = false
    Radar.center.Visible = false; Radar.cross1.Visible = false; Radar.cross2.Visible = false
    for _, d in pairs(Radar.dots) do d.Visible = false end
    for _, c in pairs(Radar.fpvDots) do c.Visible = false end
end

function Radar.step(cam)
    if not Config.RADAR_Enabled then Radar.hideAll(); return end
    
    local size = Config.RADAR_Size
    local pos = Vector2.new(cam.ViewportSize.X - size - 20, 20)
    local center = pos + Vector2.new(size/2, size/2)
    
    if Config.RADAR_Circle then
        Radar.bg.Visible = false; Radar.border.Visible = false
        Radar.circleBg.Position = center; Radar.circleBg.Radius = size/2; Radar.circleBg.Visible = true
        Radar.circleBorder.Position = center; Radar.circleBorder.Radius = size/2; Radar.circleBorder.Visible = true
    else
        Radar.circleBg.Visible = false; Radar.circleBorder.Visible = false
        Radar.bg.Position = pos; Radar.bg.Size = Vector2.new(size, size); Radar.bg.Visible = true
        Radar.border.Position = pos; Radar.border.Size = Vector2.new(size, size); Radar.border.Visible = true
    end
    
    Radar.cross1.From = Vector2.new(center.X, pos.Y + 10); Radar.cross1.To = Vector2.new(center.X, pos.Y + size - 10); Radar.cross1.Visible = true
    Radar.cross2.From = Vector2.new(pos.X + 10, center.Y); Radar.cross2.To = Vector2.new(pos.X + size - 10, center.Y); Radar.cross2.Visible = true
    
    local myRoot = LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
    local myLook = cam.CFrame.LookVector
    if not myRoot then Radar.center.Visible = false; for _, d in pairs(Radar.dots) do d.Visible = false end; return end
    
    local myAngle = math.atan2(-myLook.X, -myLook.Z)
    local cosA, sinA = math.cos(myAngle), math.sin(myAngle)
    local scale = (size/2 - 10) / Tuning.RadarRange
    local idx = 1
    
    for root, char in pairs(Cache.targets) do
        if idx > #Radar.dots then break end
        if root and root.Parent then
            local isTeam = Cache.teamStatus[root]
            if not (Config.ESP_TeamCheck and isTeam) then
                local rx, rz = root.Position.X - myRoot.Position.X, root.Position.Z - myRoot.Position.Z
                local dist2D = math.sqrt(rx^2 + rz^2)
                if dist2D < Tuning.RadarRange then
                    local rotX = rx * cosA - rz * sinA
                    local rotZ = rx * sinA + rz * cosA
                    local radarX, radarY = rotX * scale, rotZ * scale
                    local maxD = size/2 - 8
                    local rDist = math.sqrt(radarX^2 + radarY^2)
                    if rDist > maxD then radarX, radarY = radarX/rDist*maxD, radarY/rDist*maxD end
                    local dotPos = center + Vector2.new(radarX, radarY)
                    local dot = Radar.dots[idx]
                    local head = char:FindFirstChild("Head")
                    local eAngle = head and math.atan2(-head.CFrame.LookVector.X, -head.CFrame.LookVector.Z) - myAngle or 0
                    local eFwd = Vector2.new(-math.sin(eAngle), -math.cos(eAngle))
                    local eRight = Vector2.new(-eFwd.Y, eFwd.X)
                    dot.PointA = dotPos + eFwd * Tuning.RadarDotSize
                    dot.PointB = dotPos - eFwd * Tuning.RadarDotSize/2 + eRight * Tuning.RadarDotSize/2
                    dot.PointC = dotPos - eFwd * Tuning.RadarDotSize/2 - eRight * Tuning.RadarDotSize/2
                    dot.Color = isTeam and Colors.RadarTeam or Colors.RadarEnemy
                    dot.Visible = true
                    idx = idx + 1
                end
            end
        end
    end
    for i = idx, #Radar.dots do Radar.dots[i].Visible = false end
    
    local fpvIdx = 1
    if Config.ESP_FPV then
        for _, part in pairs(Cache.drones) do
            if fpvIdx > #Radar.fpvDots then break end
            local rx, rz = part.Position.X - myRoot.Position.X, part.Position.Z - myRoot.Position.Z
            local dist2D = math.sqrt(rx^2 + rz^2)
            if dist2D < Tuning.RadarRange then
                local rotX = rx * cosA - rz * sinA
                local rotZ = rx * sinA + rz * cosA
                local radarX, radarY = rotX * scale, rotZ * scale
                local maxD = size/2 - 8
                local rDist = math.sqrt(radarX^2 + radarY^2)
                if rDist > maxD then radarX, radarY = radarX/rDist*maxD, radarY/rDist*maxD end
                Radar.fpvDots[fpvIdx].Position = center + Vector2.new(radarX, radarY)
                Radar.fpvDots[fpvIdx].Visible = true
                fpvIdx = fpvIdx + 1
            end
        end
    end
    for i = fpvIdx, #Radar.fpvDots do Radar.fpvDots[i].Visible = false end
    
    Radar.center.PointA = center + Vector2.new(0, -Tuning.RadarArrowSize)
    Radar.center.PointB = center + Vector2.new(-Tuning.RadarArrowSize/2, Tuning.RadarArrowSize/2)
    Radar.center.PointC = center + Vector2.new(Tuning.RadarArrowSize/2, Tuning.RadarArrowSize/2)
    Radar.center.Visible = true
end

local Aimbot = {
    aiming = false,
    locked = nil,
    lockedFPV = false,
    fov = Drawing.new("Circle")
}

Aimbot.fov.Thickness = 1; Aimbot.fov.NumSides = 64; Aimbot.fov.Filled = false; Aimbot.fov.Transparency = 0.6

Connections.mb2down = Mouse.Button2Down:Connect(function() Aimbot.aiming = true; Aimbot.locked = nil; Aimbot.lockedFPV = false end)
Connections.mb2up = Mouse.Button2Up:Connect(function() Aimbot.aiming = false; Aimbot.locked = nil; Aimbot.lockedFPV = false end)

function Aimbot.getBest(cam)
    local center = Vector2.new(cam.ViewportSize.X/2, cam.ViewportSize.Y/2)
    local myRoot = LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
    if not myRoot then return nil end
    local best, bestDist, isFPV = nil, math.huge, false
    for root, char in pairs(Cache.targets) do
        if root and root.Parent and char then
            if not (Config.AIM_TeamCheck and Cache.teamStatus[root]) then
                local head = char:FindFirstChild("Head")
                if head then
                    local sp, on = cam:WorldToViewportPoint(head.Position)
                    if on and sp.Z > 0 then
                        local sDist = (Vector2.new(sp.X, sp.Y) - center).Magnitude
                        if sDist <= Config.AIM_FOV then
                            local wDist = (root.Position - myRoot.Position).Magnitude
                            if wDist < bestDist then bestDist = wDist; best = char; isFPV = false end
                        end
                    end
                end
            end
        end
    end
    if Config.AIM_FPV then
        for drone, part in pairs(Cache.drones) do
            if drone and part and part.Parent then
                local sp, on = cam:WorldToViewportPoint(part.Position)
                if on and sp.Z > 0 then
                    local sDist = (Vector2.new(sp.X, sp.Y) - center).Magnitude
                    if sDist <= Config.AIM_FOV then
                        local wDist = (part.Position - myRoot.Position).Magnitude
                        if wDist < bestDist then bestDist = wDist; best = drone; isFPV = true end
                    end
                end
            end
        end
    end
    return best, isFPV
end

function Aimbot.step(cam, screenCenter)
    if Config.AIM_Enabled and Config.AIM_ShowFOV then
        Aimbot.fov.Position = screenCenter
        Aimbot.fov.Radius = Config.AIM_FOV
        Aimbot.fov.Color = (Aimbot.aiming and Aimbot.locked) and Color3.fromRGB(255,0,0) or Color3.fromRGB(255,255,255)
        Aimbot.fov.Visible = true
    else Aimbot.fov.Visible = false end
end

RunService:BindToRenderStep("AimbotCore", Enum.RenderPriority.Camera.Value + 1, function()
    if Unloaded or not Config.AIM_Enabled then return end
    local rmb = UserInputService:IsMouseButtonPressed(Enum.UserInputType.MouseButton2)
    if not (Aimbot.aiming or rmb) then Aimbot.locked = nil; Aimbot.lockedFPV = false; return end
    
    local cam = workspace.CurrentCamera
    if not cam then return end
    
    local needNewTarget = not Aimbot.locked or not Aimbot.locked.Parent
    if not needNewTarget and not Aimbot.lockedFPV then
        needNewTarget = not Aimbot.locked:FindFirstChild("Head")
    end
    if needNewTarget then
        local target, isFPV = Aimbot.getBest(cam)
        Aimbot.locked = target
        Aimbot.lockedFPV = isFPV or false
    end
    if not Aimbot.locked then return end
    
    local aimPos
    if Aimbot.lockedFPV then
        local part = Cache.drones[Aimbot.locked]
        if not part or not part.Parent then Aimbot.locked = nil; Aimbot.lockedFPV = false; return end
        aimPos = part.Position
    else
        local head = Aimbot.locked:FindFirstChild("Head")
        local hum = Aimbot.locked:FindFirstChild("Humanoid")
        if not head or not hum or hum.Health <= 0 then Aimbot.locked = nil; return end
        aimPos = head.Position
    end
    
    local goal = CFrame.lookAt(cam.CFrame.Position, aimPos)
    local newCF
    if Config.AIM_Smooth <= 0 then newCF = goal
    else
        local alpha = math.clamp(0.9 - (Config.AIM_Smooth/100)*0.8, 0.1, 0.9)
        newCF = cam.CFrame:Lerp(goal, alpha)
    end
    cam.CFrame = newCF
    pcall(function()
        local vm = cam:FindFirstChild("ViewModel")
        if vm then
            local cb = vm:FindFirstChild("CameraBone"); if cb then cb.CFrame = newCF end
            local hrp = vm:FindFirstChild("HRP"); if hrp then hrp.CFrame = newCF end
        end
    end)
    pcall(function()
        local net = game.ReplicatedStorage:FindFirstChild("network")
        if net then local lv = net:FindFirstChild("characterLookvector"); if lv then lv:FireServer(newCF.LookVector) end end
    end)
end)

local Desync = { active = false }

function Desync.run()
    Desync.active = true
    while Desync.active and Config.DESYNC_Enabled and not Unloaded do
        pcall(function()
            if not LocalPlayer.Character then return end
            local root = LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
            if not root then return end
            local a = Config.DESYNC_Amount
            local cf = root.CFrame
            root.CFrame = cf * CFrame.new(math.random(-a,a)*0.1, 0, math.random(-a,a)*0.1)
            task.wait(0.01)
            root.CFrame = cf
        end)
        task.wait(0.1 + 0.3/math.max(Config.DESYNC_Amount, 1))
    end
    Desync.active = false
end

task.spawn(function()
    while not Unloaded do
        if Config.DESYNC_Enabled and not Desync.active then task.spawn(Desync.run) end
        task.wait(0.5)
    end
end)

local Trigger = { active = false, lastShot = 0 }

function Trigger.check(cam)
    local center = Vector2.new(cam.ViewportSize.X/2, cam.ViewportSize.Y/2)
    for root, char in pairs(Cache.targets) do
        if root and char then
            if Config.TRIGGER_TeamCheck and Cache.teamStatus[root] then continue end
            local hum = char:FindFirstChild("Humanoid")
            if not hum or hum.Health <= 0 then continue end
            for _, pn in pairs({"Head", "Torso", "HumanoidRootPart"}) do
                local p = char:FindFirstChild(pn)
                if p then
                    local sp, on = cam:WorldToViewportPoint(p.Position)
                    if on and sp.Z > 0 and (Vector2.new(sp.X, sp.Y) - center).Magnitude < Tuning.TriggerRadius then
                        return true
                    end
        end
    end
        end
    end
    return false
end

function Trigger.shoot()
    pcall(function() if mouse1click then mouse1click() end end)
    pcall(function() if Input and Input.MouseButton1Click then Input.MouseButton1Click() end end)
    pcall(function()
        local vim = game:GetService("VirtualInputManager")
        vim:SendMouseButtonEvent(0,0,0,true,game,1); task.wait(0.01); vim:SendMouseButtonEvent(0,0,0,false,game,1)
    end)
end

function Trigger.run()
    Trigger.active = true
    while Config.TRIGGER_Enabled and not Unloaded do
        pcall(function()
            local cam = workspace.CurrentCamera
            if cam and Trigger.check(cam) then
                local now = tick() * 1000
                if now - Trigger.lastShot >= Config.TRIGGER_Delay then
                    Trigger.shoot()
                    Trigger.lastShot = now
                end
            end
        end)
        task.wait(0.016)
    end
    Trigger.active = false
end

task.spawn(function()
    while not Unloaded do
        if Config.TRIGGER_Enabled and not Trigger.active then task.spawn(Trigger.run) end
        task.wait(0.3)
    end
end)

function Silent.getTarget()
    local cam = workspace.CurrentCamera
    if not cam then return nil, nil end
    local mousePos = UserInputService:GetMouseLocation()
    local best, bestDist, bestRoot = nil, Config.SILENT_FOV, nil
    for root, char in pairs(Cache.targets) do
        if root and root.Parent and char then
            if Config.SILENT_TeamCheck and Cache.teamStatus[root] then continue end
            local hum = char:FindFirstChild("Humanoid")
            if not hum or hum.Health <= 0 then continue end
            local head = char:FindFirstChild("Head")
            if head then
                local sp, on = cam:WorldToViewportPoint(head.Position)
                if on and sp.Z > 0 then
                    local dist = (Vector2.new(sp.X, sp.Y) - mousePos).Magnitude
                    if dist < bestDist then bestDist = dist; best = head; bestRoot = root end
                end
            end
        end
    end
    return best, bestRoot
end

function Silent.hook()
    if Silent.hooked then return end
    pcall(function()
        for _, tbl in ipairs(getgc(true)) do
            if type(tbl) == "table" and rawget(tbl, "Fire") and type(rawget(tbl, "Fire")) == "function" then
                local orig = tbl.Fire
                tbl.Fire = function(plr, gun, origin, dir, ...)
                    if plr == LocalPlayer and Config.SILENT_Enabled and not Unloaded then
                        local target = Silent.getTarget()
                        if target then dir = (target.Position - origin).Unit end
                    end
                    return orig(plr, gun, origin, dir, ...)
                end
                Silent.hooked = true
            end
        end
    end)
end

function Silent.step()
    if not Config.SILENT_Enabled then Silent.currentRoot = nil; return end
    local _, root = Silent.getTarget()
    Silent.currentRoot = root
end

task.spawn(Silent.hook)



local Menu = {
    selected = 1,
    drawings = {},
    items = {
        {name = "ESP", key = "ESP_Enabled", type = "toggle"},
        {name = "  Boxes", key = "ESP_Boxes", type = "toggle", parent = "ESP_Enabled"},
        {name = "  Names", key = "ESP_Names", type = "toggle", parent = "ESP_Enabled"},
        {name = "  Distance", key = "ESP_Distance", type = "toggle", parent = "ESP_Enabled"},
        {name = "  Skeleton", key = "ESP_Skeleton", type = "toggle", parent = "ESP_Enabled"},
        {name = "  Weapons", key = "ESP_Weapons", type = "toggle", parent = "ESP_Enabled"},
        {name = "  Health Bar", key = "ESP_Health", type = "toggle", parent = "ESP_Enabled"},
        {name = "  FPV Drones", key = "ESP_FPV", type = "toggle", parent = "ESP_Enabled"},
        {name = "    Trajectory", key = "ESP_FPVPredict", type = "toggle", parent = "ESP_FPV"},
        {name = "  Offscreen", key = "ESP_Offscreen", type = "toggle", parent = "ESP_Enabled"},
        {name = "  Aim Direction", key = "ESP_AimDir", type = "toggle", parent = "ESP_Enabled"},
        {name = "  Looking At You", key = "ESP_LookingAtYou", type = "toggle", parent = "ESP_Enabled"},
        {name = "  Tracers", key = "ESP_Tracers", type = "toggle", parent = "ESP_Enabled"},
        {name = "  Velocity", key = "ESP_Velocity", type = "toggle", parent = "ESP_Enabled"},
        {name = "  Sound ESP", key = "ESP_Sound", type = "toggle", parent = "ESP_Enabled"},
        {name = "  Trails", key = "ESP_Trails", type = "toggle", parent = "ESP_Enabled"},
        {name = "  Team Check", key = "ESP_TeamCheck", type = "toggle", parent = "ESP_Enabled"},
        {name = "  Max Dist", key = "ESP_MaxDist", type = "slider", min = 500, max = 5000, step = 100, parent = "ESP_Enabled"},
        {name = "----------", type = "sep"},
        {name = "RADAR", key = "RADAR_Enabled", type = "toggle"},
        {name = "  Size", key = "RADAR_Size", type = "slider", min = 80, max = 200, step = 10, parent = "RADAR_Enabled"},
        {name = "  Circle Mode", key = "RADAR_Circle", type = "toggle", parent = "RADAR_Enabled"},
        {name = "----------", type = "sep"},
        {name = "AIMBOT", key = "AIM_Enabled", type = "toggle"},
        {name = "  FOV", key = "AIM_FOV", type = "slider", min = 50, max = 500, step = 25, parent = "AIM_Enabled"},
        {name = "  Smooth", key = "AIM_Smooth", type = "slider", min = 0, max = 100, step = 5, parent = "AIM_Enabled"},
        {name = "  Show FOV", key = "AIM_ShowFOV", type = "toggle", parent = "AIM_Enabled"},
        {name = "  Team Check", key = "AIM_TeamCheck", type = "toggle", parent = "AIM_Enabled"},
        {name = "  Target FPV", key = "AIM_FPV", type = "toggle", parent = "AIM_Enabled"},
        {name = "----------", type = "sep"},
        {name = "DESYNC", key = "DESYNC_Enabled", type = "toggle"},
        {name = "  Strength", key = "DESYNC_Amount", type = "slider", min = 1, max = 10, step = 1, parent = "DESYNC_Enabled"},
        {name = "----------", type = "sep"},
        {name = "TRIGGERBOT", key = "TRIGGER_Enabled", type = "toggle"},
        {name = "  Delay (ms)", key = "TRIGGER_Delay", type = "slider", min = 0, max = 200, step = 10, parent = "TRIGGER_Enabled"},
        {name = "  Team Check", key = "TRIGGER_TeamCheck", type = "toggle", parent = "TRIGGER_Enabled"},
        {name = "----------", type = "sep"},
        {name = "SILENT AIM", key = "SILENT_Enabled", type = "toggle"},
        {name = "  FOV", key = "SILENT_FOV", type = "slider", min = 50, max = 300, step = 25, parent = "SILENT_Enabled"},
        {name = "  Team Check", key = "SILENT_TeamCheck", type = "toggle", parent = "SILENT_Enabled"},
    },
    bg = Drawing.new("Square"),
    border = Drawing.new("Square"),
    title = Drawing.new("Text"),
    warning = {
        bg = Drawing.new("Square"), border = Drawing.new("Square"),
        title = Drawing.new("Text"), text1 = Drawing.new("Text"), text2 = Drawing.new("Text")
    }
}

Menu.bg.Position = Vector2.new(10,10); Menu.bg.Color = Colors.MenuBg; Menu.bg.Filled = true; Menu.bg.Transparency = 0.9
Menu.border.Position = Vector2.new(10,10); Menu.border.Color = Colors.MenuHighlight; Menu.border.Filled = false; Menu.border.Thickness = 1
Menu.title.Position = Vector2.new(18,14); Menu.title.Text = "INS menu | HOME panic"; Menu.title.Size = 13; Menu.title.Font = Drawing.Fonts.Monospace; Menu.title.Color = Color3.fromRGB(100,100,100); Menu.title.Outline = true

Menu.warning.bg.Filled = true; Menu.warning.bg.Color = Color3.fromRGB(20,0,0); Menu.warning.bg.Transparency = 0.9; Menu.warning.bg.Visible = false
Menu.warning.border.Filled = false; Menu.warning.border.Color = Color3.fromRGB(255,50,50); Menu.warning.border.Thickness = 2; Menu.warning.border.Visible = false
Menu.warning.title.Size = 16; Menu.warning.title.Font = Drawing.Fonts.Monospace; Menu.warning.title.Color = Color3.fromRGB(255,50,50); Menu.warning.title.Outline = true; Menu.warning.title.Center = true; Menu.warning.title.Text = "!! WARNING !!"; Menu.warning.title.Visible = false
Menu.warning.text1.Size = 13; Menu.warning.text1.Font = Drawing.Fonts.Monospace; Menu.warning.text1.Color = Color3.fromRGB(255,200,200); Menu.warning.text1.Outline = true; Menu.warning.text1.Center = true; Menu.warning.text1.Text = "Aimbot may get you banned!"; Menu.warning.text1.Visible = false
Menu.warning.text2.Size = 13; Menu.warning.text2.Font = Drawing.Fonts.Monospace; Menu.warning.text2.Color = Color3.fromRGB(255,150,150); Menu.warning.text2.Outline = true; Menu.warning.text2.Center = true; Menu.warning.text2.Text = "You will get reported and banned if you rage!"; Menu.warning.text2.Visible = false

for i = 1, #Menu.items do
    local t = Drawing.new("Text"); t.Size = 13; t.Font = Drawing.Fonts.Monospace; t.Outline = true
    Menu.drawings[i] = t
end

function Menu.showWarning(cam)
    local cx = cam.ViewportSize.X / 2
    local w, h = 320, 80
    Menu.warning.bg.Position = Vector2.new(cx - w/2, 150); Menu.warning.bg.Size = Vector2.new(w, h); Menu.warning.bg.Visible = true
    Menu.warning.border.Position = Vector2.new(cx - w/2, 150); Menu.warning.border.Size = Vector2.new(w, h); Menu.warning.border.Visible = true
    Menu.warning.title.Position = Vector2.new(cx, 165); Menu.warning.title.Visible = true
    Menu.warning.text1.Position = Vector2.new(cx, 188); Menu.warning.text1.Visible = true
    Menu.warning.text2.Position = Vector2.new(cx, 205); Menu.warning.text2.Visible = true
    Timers.warningEnd = tick() + 3
end

function Menu.updateWarning()
    if Timers.warningEnd > 0 and tick() > Timers.warningEnd then
        Menu.warning.bg.Visible = false; Menu.warning.border.Visible = false
        Menu.warning.title.Visible = false; Menu.warning.text1.Visible = false; Menu.warning.text2.Visible = false
        Timers.warningEnd = 0
    end
end

function Menu.step()
    if not Config.MenuOpen then
        Menu.bg.Visible = false; Menu.border.Visible = false; Menu.title.Visible = false
        for _, d in pairs(Menu.drawings) do d.Visible = false end
        return
    end
    local y, count = 32, 0
    for i, item in ipairs(Menu.items) do
        local d = Menu.drawings[i]
        local show = not item.parent or Config[item.parent]
        if show then
            count = count + 1
            d.Position = Vector2.new(18, y)
            if item.type == "sep" then d.Text = item.name; d.Color = Color3.fromRGB(50,50,50)
            elseif item.type == "toggle" then
                local on = Config[item.key]
                d.Text = (i == Menu.selected and "> " or "  ") .. item.name .. (on and " ON" or " OFF")
                d.Color = i == Menu.selected and Colors.MenuHighlight or (on and Colors.MenuOn or Colors.MenuOff)
            elseif item.type == "slider" then
                d.Text = (i == Menu.selected and "> " or "  ") .. item.name .. " " .. math.floor(Config[item.key])
                d.Color = i == Menu.selected and Colors.MenuHighlight or Colors.MenuText
            end
            d.Visible = true; y = y + 16
        else d.Visible = false end
    end
    Menu.bg.Size = Vector2.new(180, 28 + count * 16 + 6); Menu.border.Size = Vector2.new(180, 28 + count * 16 + 6)
    Menu.bg.Visible = true; Menu.border.Visible = true; Menu.title.Visible = true
end

local function Unload()
    if Unloaded then return end
    Unloaded = true
    Config.DESYNC_Enabled = false
    Config.TRIGGER_Enabled = false
    Desync.active = false
    Trigger.active = false
    pcall(function() RunService:UnbindFromRenderStep("AimbotCore") end)
    for _, c in pairs(Connections) do pcall(function() c:Disconnect() end) end
    for _, esp in pairs(ESP.cache) do ESP.destroy(esp) end
    for _, esp in pairs(FPV.cache) do FPV.destroy(esp) end
    for _, r in pairs(Sound.ripples) do for _, c in pairs(r.circles) do c:Remove() end end
    for _, t in pairs(Trails.data) do for _, l in pairs(t.lines) do l:Remove() end end
    Radar.bg:Remove(); Radar.circleBg:Remove(); Radar.border:Remove(); Radar.circleBorder:Remove()
    Radar.cross1:Remove(); Radar.cross2:Remove(); Radar.center:Remove()
    for _, d in pairs(Radar.dots) do d:Remove() end
    for _, c in pairs(Radar.fpvDots) do c:Remove() end
    Aimbot.fov:Remove()
    Menu.bg:Remove(); Menu.border:Remove(); Menu.title:Remove()
    for _, d in pairs(Menu.drawings) do d:Remove() end
    Menu.warning.bg:Remove(); Menu.warning.border:Remove(); Menu.warning.title:Remove()
    Menu.warning.text1:Remove(); Menu.warning.text2:Remove()
end

Connections.input = UserInputService.InputBegan:Connect(function(input, gp)
    if input.KeyCode == Enum.KeyCode.Home then Unload(); return end
    if input.KeyCode == Enum.KeyCode.Insert and not gp then Config.MenuOpen = not Config.MenuOpen; return end
    if not Config.MenuOpen then return end
    if input.KeyCode == Enum.KeyCode.Up then
        repeat Menu.selected = Menu.selected - 1; if Menu.selected < 1 then Menu.selected = #Menu.items end
        until Menu.items[Menu.selected].type ~= "sep" and (not Menu.items[Menu.selected].parent or Config[Menu.items[Menu.selected].parent])
    elseif input.KeyCode == Enum.KeyCode.Down then
        repeat Menu.selected = Menu.selected + 1; if Menu.selected > #Menu.items then Menu.selected = 1 end
        until Menu.items[Menu.selected].type ~= "sep" and (not Menu.items[Menu.selected].parent or Config[Menu.items[Menu.selected].parent])
    elseif input.KeyCode == Enum.KeyCode.Left or input.KeyCode == Enum.KeyCode.Right then
        local item = Menu.items[Menu.selected]
        if item and item.type == "toggle" then
            Config[item.key] = not Config[item.key]
            if item.key == "AIM_Enabled" and Config.AIM_Enabled then Menu.showWarning(workspace.CurrentCamera) end
        elseif item and item.type == "slider" then
            Config[item.key] = input.KeyCode == Enum.KeyCode.Left and math.max(item.min, Config[item.key] - item.step) or math.min(item.max, Config[item.key] + item.step)
        end
    end
end)

Connections.render = RunService.RenderStepped:Connect(function()
    if Unloaded then return end
    local cam = workspace.CurrentCamera
    if not cam then return end
    local screenSize = cam.ViewportSize
    local screenCenter = Vector2.new(screenSize.X/2, screenSize.Y/2)
    local now = tick()
    
    if now - Timers.lastTeamRefresh > Tuning.TeamRefreshRate then Timers.lastTeamRefresh = now; Team.update() end
    if now - Timers.lastTargetRefresh > Tuning.TargetRefreshRate then Timers.lastTargetRefresh = now; Targets.refresh() end
    if now - Timers.lastVisRefresh > Tuning.VisibilityRefreshRate then Timers.lastVisRefresh = now; Targets.refreshVisibility() end
    if now - Timers.lastWeaponRefresh > Tuning.WeaponRefreshRate then Timers.lastWeaponRefresh = now; Targets.refreshWeapons() end
    if now - Timers.lastFPVRefresh > Tuning.FPVRefreshRate then Timers.lastFPVRefresh = now; Cache.drones = FPV.scan() end
    
    ESP.step(cam, screenSize, screenCenter)
    Sound.step(cam)
    Trails.cleanup()
    FPV.step(cam)
    Radar.step(cam)
    Aimbot.step(cam, screenCenter)
    Silent.step()
    Menu.updateWarning()
    Menu.step()
end)

Menu.step()