XENO COMPATIBLE AIMBOT ESP FPV ESP MORE SOURCE CODE

 Players = :()
 RunService = :()
 UserInputService = :()
 Workspace = :()
 GuiService = :()

 LocalPlayer = Players.LocalPlayer
 Mouse = LocalPlayer:()

 Config = {
    ESP_Enabled = ,
    ESP_Boxes = ,
    ESP_Names = ,
    ESP_Distance = ,
    ESP_Skeleton = ,
    ESP_Health = ,
    ESP_TeamCheck = ,
    ESP_MaxDist = ,
    ESP_AimDir = ,
    ESP_LookingAtYou = ,
    ESP_Tracers = ,
    ESP_FPV = ,
    
    RADAR_Enabled = ,
    RADAR_Size = ,
    
    AIM_Enabled = ,
    AIM_FOV = ,
    AIM_Smooth = ,
    AIM_ShowFOV = ,
    AIM_TeamCheck = ,
    AIM_FPV = ,
    
    DESYNC_Enabled = ,
    DESYNC_Amount = ,
    
    TRIGGER_Enabled = ,
    TRIGGER_Delay = ,
    TRIGGER_TeamCheck = ,
    
    MENU_Open = ,
    MENU_Tab = 
}

 Tuning = {
    TargetRefreshRate = ,
    VisibilityRefreshRate = ,
    TeamRefreshRate = ,
    FPVRefreshRate = ,
    
    BoxWidthRatio = ,
    HealthBarWidth = ,
    HealthBarOffset = ,
    NameOffset = ,
    DistOffset = ,
    
    AimLineLength = ,
    LookingThreshold = ,
    FPVClusterDist = ,
    
    RadarRange = ,
    RadarDotSize = ,
    
    TriggerRadius = 
}

 Palette = {
    Enemy = .(, , ),
    EnemyVisible = .(, , ),
    Team = .(, , ),
    Skeleton = .(, , ),
    SkeletonVisible = .(, , ),
    LookingAtYou = .(, , ),
    AimDir = .(, , ),
    FPV = .(, , ),
    Tracer = .(, , ),
    HealthHigh = .(, , ),
    HealthMid = .(, , ),
    HealthLow = .(, , ),
    HealthBg = .(, , ),
    
    RadarBg = .(, , ),
    RadarBorder = .(, , ),
    RadarYou = .(, , ),
    RadarEnemy = .(, , ),
    
    MenuBg = .(, , ),
    MenuPanel = .(, , ),
    MenuBorder = .(, , ),
    MenuAccent = .(, , ),
    MenuText = .(, , ),
    MenuTextDim = .(, , ),
    MenuOn = .(, , ),
    MenuOff = .(, , ),
    MenuTab = .(, , ),
    
    FOV_Circle = .(, , ),
    FOV_Active = .(, , )
}

 Timers = {
    lastTargetRefresh = ,
    lastVisRefresh = ,
    lastTeamRefresh = ,
    lastFPVRefresh = 
}

 Cache = {
    targets = {},
    humanoids = {},
    teamStatus = {},
    visibility = {},
    lookingAtYou = {},
    drones = {},
    names = {},
    myRoot = 
}

 Teams = {
    sets = {
        {colors = {{R=,G=,B=}, {R=,G=,B=}}},
        {colors = {{R=,G=,B=}}},
    },
    localSet = 
}

 Bones = {{,},{,},{,},{,},{,}}

 Connections = {}
 Unloaded = 

 UI = {}
UI.ScreenGui = .()
UI.ScreenGui.Name = 
UI.ScreenGui.ResetOnSpawn = 
UI.ScreenGui.ZIndexBehavior = .ZIndexBehavior.Sibling
UI.ScreenGui.DisplayOrder = 
UI.ScreenGui.IgnoreGuiInset = 

(() UI.ScreenGui.Parent = :() )
  UI.ScreenGui.Parent 
    UI.ScreenGui.Parent = LocalPlayer:()


 Team = {}





 Team.(char)
      LocalPlayer.Character    
      char   char.Parent    
    
     localParent = LocalPlayer.Character.Parent
     charParent = char.Parent
    
      localParent   charParent    
    
     localParent == charParent 
         
    
    
     


 Team.(char)
      char   char.Parent    
    
     parentName = char.Parent.Name:()
     parentName:()  parentName:()  parentName:() 
         
    
    
     


 Util = {}

 Util.(character)
      character    
     cam = Workspace.CurrentCamera
      cam    
    
     origin = cam.CFrame.Position
     parts = {, , }
    
     rayParams = RaycastParams.()
    rayParams.FilterType = .RaycastFilterType.Exclude
     filter = {cam}
     LocalPlayer.Character  .(filter, LocalPlayer.Character) 
    .(filter, character)
    rayParams.FilterDescendantsInstances = filter
    
     _, partName  (parts) 
         part = character:(partName)
         part 
             dir = (part.Position - origin)
             result = Workspace:(origin, dir.Unit * dir.Magnitude, rayParams)
              result  (result.Position - part.Position).Magnitude <  
                 
            
        
    
     


 Util.(char)
      LocalPlayer.Character    
     myHead = LocalPlayer.Character:()
     head = char:()
      myHead   head    
     toYou = (myHead.Position - head.Position).Unit
     toYou:(head.CFrame.LookVector) > Tuning.LookingThreshold


 Util.(char)
     Cache.names[char]   Cache.names[char] 
     _, p  (Players:()) 
         p.Character == char 
            Cache.names[char] = p.Name
             p.Name
        
    
     name = ( char.Name:())  char.Name  
    Cache.names[char] = name
     name


 Targets = {}

 Targets.()
     new, newTeam, newNames, newHum = {}, {}, {}, {}
     myChar = LocalPlayer.Character
    Cache.myRoot = myChar  myChar:()
     _, plr  (Players:()) 
         plr ~= LocalPlayer  plr.Character 
             char = plr.Character
            
             Team.(char)   
            
             root = char:()
             hum = char:()
             root  hum  hum.Health >   root.Position.Y > - 
                new[root] = char
                newHum[root] = hum
                newTeam[root] = Team.(char)
                 Cache.names[char]  newNames[char] = Cache.names[char] 
            
        
    
    Cache.targets = new
    Cache.humanoids = newHum
    Cache.teamStatus = newTeam
    Cache.names = newNames


 Targets.()
     count = 
     root, char  (Cache.targets) 
        count = count + 
         count >  
            Cache.visibility[root] = 
            Cache.lookingAtYou[root] = 
        
             vis = Util.(char)
            Cache.visibility[root] = vis
            Cache.lookingAtYou[root] = vis  Util.(char)  
        
    


 ESP = { cache = {} }

  (frame, x1, y1, x2, y2, color, thickness)
    thickness = thickness  
     dx = x2 - x1
     dy = y2 - y1
     length = .(dx * dx + dy * dy)
     length <  
        frame.Visible = 
        
    
     cx = (x1 + x2) / 
     cy = (y1 + y2) / 
     angle = .(dy, dx) * ( / .pi)
    frame.AnchorPoint = .(, )
    frame.Position = .(, cx, , cy)
    frame.Size = .(, length, , thickness)
    frame.Rotation = angle
     color  frame.BackgroundColor3 = color 
    frame.Visible = 


 ESP.(root)
     ESP.cache[root]   
    
     box = .()
    box.BackgroundTransparency = 
    box.BorderSizePixel = 
    box.Visible = 
    box.Parent = UI.ScreenGui
     boxStroke = .()
    boxStroke.Thickness = 
    boxStroke.Parent = box
    
     name = .()
    name.BackgroundTransparency = 
    name.Font = .Font.RobotoMono
    name.TextSize = 
    name.TextColor3 = .(, , )
    name.TextStrokeTransparency = 
    name.Size = .(, , , )
    name.TextXAlignment = .TextXAlignment.Center
    name.Visible = 
    name.Parent = UI.ScreenGui
    
     dist = .()
    dist.BackgroundTransparency = 
    dist.Font = .Font.RobotoMono
    dist.TextSize = 
    dist.TextColor3 = .(, , )
    dist.TextStrokeTransparency = 
    dist.Size = .(, , , )
    dist.TextXAlignment = .TextXAlignment.Center
    dist.Visible = 
    dist.Parent = UI.ScreenGui
    
     healthBg = .()
    healthBg.BackgroundColor3 = Palette.HealthBg
    healthBg.BorderSizePixel = 
    healthBg.Visible = 
    healthBg.Parent = UI.ScreenGui
    
     healthBar = .()
    healthBar.BackgroundColor3 = Palette.HealthHigh
    healthBar.BorderSizePixel = 
    healthBar.Visible = 
    healthBar.Parent = UI.ScreenGui
    
     skel = {}
     i = ,  
         line = .()
        line.BackgroundColor3 = Palette.Skeleton
        line.BorderSizePixel = 
        line.AnchorPoint = .(, )
        line.Visible = 
        line.Parent = UI.ScreenGui
        skel[i] = line
    
    
     aimLine = .()
    aimLine.BackgroundColor3 = Palette.AimDir
    aimLine.BorderSizePixel = 
    aimLine.AnchorPoint = .(, )
    aimLine.Visible = 
    aimLine.Parent = UI.ScreenGui
    
     lookingText = .()
    lookingText.BackgroundTransparency = 
    lookingText.Font = .Font.RobotoMono
    lookingText.TextSize = 
    lookingText.TextColor3 = Palette.LookingAtYou
    lookingText.TextStrokeTransparency = 
    lookingText.Text = 
    lookingText.Size = .(, , , )
    lookingText.TextXAlignment = .TextXAlignment.Center
    lookingText.Visible = 
    lookingText.Parent = UI.ScreenGui
    
     tracer = .()
    tracer.BackgroundColor3 = Palette.Tracer
    tracer.BorderSizePixel = 
    tracer.AnchorPoint = .(, )
    tracer.Visible = 
    tracer.Parent = UI.ScreenGui
    
    ESP.cache[root] = {
        Box = box, BoxStroke = boxStroke,
        Name = name, Dist = dist,
        HealthBg = healthBg, HealthBar = healthBar,
        Skel = skel,
        AimLine = aimLine, LookingText = lookingText,
        Tracer = tracer
    }


 ESP.(esp)
      esp   
    esp.Box.Visible = 
    esp.Name.Visible = 
    esp.Dist.Visible = 
    esp.HealthBg.Visible = 
    esp.HealthBar.Visible = 
     _, l  (esp.Skel)  l.Visible =  
    esp.AimLine.Visible = 
    esp.LookingText.Visible = 
    esp.Tracer.Visible = 


 ESP.(esp)
      esp   
    (() esp.Box:() )
    (() esp.Name:() )
    (() esp.Dist:() )
    (() esp.HealthBg:() )
    (() esp.HealthBar:() )
     _, l  (esp.Skel)  (() l:() ) 
    (() esp.AimLine:() )
    (() esp.LookingText:() )
    (() esp.Tracer:() )


 ESP.()
     _, esp  (ESP.cache)  ESP.(esp) 


 ESP.()
     toRemove = {}
     root, esp  (ESP.cache) 
          Cache.targets[root] 
            ESP.(esp)
            ESP.(esp)
            toRemove[#toRemove + ] = root
        
    
     _, root  (toRemove)  ESP.cache[root] =  


 ESP.(esp, root, char, hum, cam, screenSize, screenCenter, dist)
     head = char:()
     headPos = head  head.Position  (root.Position + .(, , ))
     feetPos = root.Position - .(, , )
     topPos = headPos + .(, , )
    
     rs, ron = cam:(root.Position)
     hs = cam:(topPos)
     fs = cam:(feetPos)
    
     onScreen = ron  rs.Z > 
     isTeam = Cache.teamStatus[root]  
     visible = Cache.visibility[root]  
     col = isTeam  Palette.Team  (visible  Palette.EnemyVisible  Palette.Enemy)
     skelCol = isTeam  Palette.Team  (visible  Palette.SkeletonVisible  Palette.Skeleton)
     lookingAtYou = Cache.lookingAtYou[root]  
    
     onScreen 
         boxTop, boxBottom = hs.Y, fs.Y
         boxHeight = .(boxBottom - boxTop)
         boxWidth = boxHeight * Tuning.BoxWidthRatio
         cx = rs.X
        
         Config.ESP_Boxes 
            esp.Box.Position = .(, cx - boxWidth/, , boxTop)
            esp.Box.Size = .(, boxWidth, , boxHeight)
            esp.BoxStroke.Color = col
            esp.Box.Visible = 
        
            esp.Box.Visible = 
        
        
         Config.ESP_Names 
            esp.Name.Text = Util.(char)
            esp.Name.Position = .(, cx - , , hs.Y - Tuning.NameOffset)
            esp.Name.TextColor3 = col
            esp.Name.Visible = 
        
            esp.Name.Visible = 
        
        
         Config.ESP_Distance 
            esp.Dist.Text = .(dist) .. 
            esp.Dist.Position = .(, cx - , , fs.Y + Tuning.DistOffset)
            esp.Dist.Visible = 
        
            esp.Dist.Visible = 
        
        
         Config.ESP_Health 
             pct = .(hum.Health / hum.MaxHealth, , )
             barX = cx - boxWidth/ - Tuning.HealthBarOffset
            esp.HealthBg.Position = .(, barX - , , boxTop - )
            esp.HealthBg.Size = .(, Tuning.HealthBarWidth + , , boxHeight + )
            esp.HealthBg.Visible = 
             hh = boxHeight * pct
            esp.HealthBar.Position = .(, barX, , boxBottom - hh)
            esp.HealthBar.Size = .(, Tuning.HealthBarWidth, , hh)
            esp.HealthBar.BackgroundColor3 = pct >   Palette.HealthHigh  pct >   Palette.HealthMid  Palette.HealthLow
            esp.HealthBar.Visible = 
        
            esp.HealthBg.Visible = 
            esp.HealthBar.Visible = 
        
        
         Config.ESP_Skeleton 
             i, b  (Bones) 
                 p1, p2 = char:(b[]), char:(b[])
                 p1  p2 
                     s1, o1 = cam:(p1.Position)
                     s2, o2 = cam:(p2.Position)
                     o1  o2  s1.Z >   s2.Z >  
                        (esp.Skel[i], s1.X, s1.Y, s2.X, s2.Y, skelCol, )
                    
                        esp.Skel[i].Visible = 
                    
                
                    esp.Skel[i].Visible = 
                
            
        
             _, l  (esp.Skel)  l.Visible =  
        
        
         Config.ESP_AimDir  head 
             aimEnd = head.Position + head.CFrame.LookVector * Tuning.AimLineLength
             headScreen, headOn = cam:(head.Position)
             aimScreen, aimOn = cam:(aimEnd)
             headOn  aimOn  headScreen.Z >   aimScreen.Z >  
                (esp.AimLine, headScreen.X, headScreen.Y, aimScreen.X, aimScreen.Y, Palette.AimDir, )
            
                esp.AimLine.Visible = 
            
        
            esp.AimLine.Visible = 
        
        
         Config.ESP_LookingAtYou  lookingAtYou 
            esp.LookingText.Position = .(, cx - , , hs.Y - )
            esp.LookingText.Visible = 
        
            esp.LookingText.Visible = 
        
        
         Config.ESP_Tracers 
             tracerCol = visible  Palette.EnemyVisible  Palette.Tracer
            (esp.Tracer, screenCenter.X, screenSize.Y, cx, fs.Y, tracerCol, )
        
            esp.Tracer.Visible = 
        
    
        ESP.(esp)
    


 ESP.(cam, screenSize, screenCenter)
      Config.ESP_Enabled 
        ESP.()
        
    
    
    ESP.()
    
     myRoot = Cache.myRoot
     root, char  (Cache.targets) 
          root   root.Parent   char 
             ESP.cache[root]  ESP.(ESP.cache[root]) 
        
             hum = Cache.humanoids[root]
              hum   hum.Parent  hum.Health <=  
                 ESP.cache[root]  ESP.(ESP.cache[root]) 
             Config.ESP_TeamCheck  Cache.teamStatus[root] 
                 ESP.cache[root]  ESP.(ESP.cache[root]) 
            
                  ESP.cache[root]  ESP.(root) 
                 esp = ESP.cache[root]
                 dist = myRoot  (root.Position - myRoot.Position).Magnitude  
                
                 dist > Config.ESP_MaxDist 
                    ESP.(esp)
                
                    ESP.(esp, root, char, hum, cam, screenSize, screenCenter, dist)
                
            
        
    


 FPV = {
    cache = {},
    partNames = {, , , , , , , , , , }
}

 fpvNameSet = {}
 _, n  (FPV.partNames)  fpvNameSet[n] =  

 FPV.(drone)
     FPV.cache[drone]   
    
     box = .()
    box.BackgroundTransparency = 
    box.BorderSizePixel = 
    box.Visible = 
    box.Parent = UI.ScreenGui
     boxStroke = .()
    boxStroke.Thickness = 
    boxStroke.Color = Palette.FPV
    boxStroke.Parent = box
    
     name = .()
    name.BackgroundTransparency = 
    name.Font = .Font.RobotoMono
    name.TextSize = 
    name.TextColor3 = Palette.FPV
    name.TextStrokeTransparency = 
    name.Text = 
    name.Size = .(, , , )
    name.TextXAlignment = .TextXAlignment.Center
    name.Visible = 
    name.Parent = UI.ScreenGui
    
     dist = .()
    dist.BackgroundTransparency = 
    dist.Font = .Font.RobotoMono
    dist.TextSize = 
    dist.TextColor3 = Palette.FPV
    dist.TextStrokeTransparency = 
    dist.Size = .(, , , )
    dist.TextXAlignment = .TextXAlignment.Center
    dist.Visible = 
    dist.Parent = UI.ScreenGui
    
    FPV.cache[drone] = {Box = box, BoxStroke = boxStroke, Name = name, Dist = dist}


 FPV.(esp)
      esp   
    esp.Box.Visible = 
    esp.Name.Visible = 
    esp.Dist.Visible = 


 FPV.(esp)
      esp   
    (() esp.Box:() )
    (() esp.Name:() )
    (() esp.Dist:() )


 FPV.()
      Config.ESP_FPV   Cache.drones  {} 
     drones, seen, count = {}, {}, 
     camRef = Workspace.CurrentCamera
     plrs = Players:()
     _, obj  (Workspace:()) 
         count >=    
         obj:()  fpvNameSet[obj.Name] 
             model = obj.Parent
             model  model:()   seen[model] 
                 skip = 
                 camRef  model:(camRef)  skip =  
                  skip 
                     i = , #plrs 
                         plrs[i].Character  model:(plrs[i].Character)  skip = ;  
                    
                
                  skip 
                    seen[model] = 
                     center = model:()  model:()  obj
                    drones[model] = center
                    count = count + 
                
            
        
    
     drones


 FPV.(cam)
      Config.ESP_Enabled   Config.ESP_FPV 
         _, esp  (FPV.cache)  FPV.(esp) 
        
    
    
     screenPos, toShow = {}, {}
     drone, part  (Cache.drones) 
         sp, on = cam:(part.Position)
         on  sp.Z >  
             tooClose = 
             _, ex  (screenPos) 
                 .((sp.X - ex.X)^ + (sp.Y - ex.Y)^) < Tuning.FPVClusterDist 
                    tooClose = 
                    
                
            
              tooClose 
                screenPos[drone] = sp
                toShow[drone] = part
            
        
    
    
     drone, esp  (FPV.cache) 
          toShow[drone]  FPV.(esp); FPV.(esp); FPV.cache[drone] =  
    
    
     myRoot = Cache.myRoot
     drone, part  (toShow) 
          FPV.cache[drone]  FPV.(drone) 
         esp = FPV.cache[drone]
         sp = screenPos[drone]
         dist = myRoot  (part.Position - myRoot.Position).Magnitude  
        
         dist < Config.ESP_MaxDist 
             size = .( / sp.Z, , )
            esp.Box.Position = .(, sp.X - size/, , sp.Y - size/)
            esp.Box.Size = .(, size, , size)
            esp.Box.Visible = 
            esp.Name.Position = .(, sp.X - , , sp.Y - size/ - )
            esp.Name.Visible = 
            esp.Dist.Position = .(, sp.X - , , sp.Y + size/ + )
            esp.Dist.Text = .(dist) .. 
            esp.Dist.Visible = 
        
            FPV.(esp)
        
    


 radarDots = {}
 RadarFrame = .()
RadarFrame.Name = 
RadarFrame.BackgroundColor3 = Palette.RadarBg
RadarFrame.BackgroundTransparency = 
RadarFrame.BorderSizePixel = 
RadarFrame.AnchorPoint = .(, )
RadarFrame.Parent = UI.ScreenGui

 RadarStroke = .()
RadarStroke.Color = Palette.RadarBorder
RadarStroke.Thickness = 
RadarStroke.Parent = RadarFrame

 RadarCross1 = .()
RadarCross1.BackgroundColor3 = .(, , )
RadarCross1.BorderSizePixel = 
RadarCross1.AnchorPoint = .(, )
RadarCross1.Parent = RadarFrame

 RadarCross2 = .()
RadarCross2.BackgroundColor3 = .(, , )
RadarCross2.BorderSizePixel = 
RadarCross2.AnchorPoint = .(, )
RadarCross2.Parent = RadarFrame

 RadarCenter = .()
RadarCenter.BackgroundColor3 = Palette.RadarYou
RadarCenter.BorderSizePixel = 
RadarCenter.AnchorPoint = .(, )
RadarCenter.Size = .(, , , )
RadarCenter.Parent = RadarFrame
.(, RadarCenter).CornerRadius = .(, )

 i = ,  
     dot = .()
    dot.BackgroundColor3 = Palette.RadarEnemy
    dot.BorderSizePixel = 
    dot.AnchorPoint = .(, )
    dot.Size = .(, Tuning.RadarDotSize, , Tuning.RadarDotSize)
    dot.Visible = 
    dot.Parent = RadarFrame
    .(, dot).CornerRadius = .(, )
    radarDots[i] = dot


 fpvRadarDots = {}
 i = ,  
     dot = .()
    dot.BackgroundColor3 = Palette.FPV
    dot.BorderSizePixel = 
    dot.AnchorPoint = .(, )
    dot.Size = .(, , , )
    dot.Visible = 
    dot.Parent = RadarFrame
    .(, dot).CornerRadius = .(, )
    fpvRadarDots[i] = dot


  (cam)
      Config.RADAR_Enabled 
        RadarFrame.Visible = 
        
    
    
     myRoot = Cache.myRoot
      myRoot   myRoot.Parent 
        RadarFrame.Visible = 
        
    
    
     size = Config.RADAR_Size
    RadarFrame.Position = .(, -, , )
    RadarFrame.Size = .(, size, , size)
    RadarFrame.Visible = 
    
    RadarCross1.Position = .(, , , )
    RadarCross1.Size = .(, , , -)
    RadarCross2.Position = .(, , , )
    RadarCross2.Size = .(, -, , )
    RadarCenter.Position = .(, , , )
    
     myLook = cam.CFrame.LookVector
     myAngle = .(-myLook.X, -myLook.Z)
     cosA, sinA = .(myAngle), .(myAngle)
     scale = (size/ - ) / Tuning.RadarRange
    
     idx = 
     root, char  (Cache.targets) 
         idx > #radarDots   
         root  root.Parent 
             isTeam = Cache.teamStatus[root]
              (Config.ESP_TeamCheck  isTeam) 
                 rx, rz = root.Position.X - myRoot.Position.X, root.Position.Z - myRoot.Position.Z
                 dist2D = .(rx^ + rz^)
                 dist2D < Tuning.RadarRange 
                     rotX = rx * cosA - rz * sinA
                     rotZ = rx * sinA + rz * cosA
                     radarX, radarY = rotX * scale, rotZ * scale
                     maxD = size/ - 
                     rDist = .(radarX^ + radarY^)
                     rDist > maxD  radarX, radarY = radarX/rDist*maxD, radarY/rDist*maxD 
                    
                    radarDots[idx].Position = .(, radarX, , radarY)
                    radarDots[idx].BackgroundColor3 = isTeam  Palette.Team  Palette.RadarEnemy
                    radarDots[idx].Visible = 
                    idx = idx + 
                
            
        
    
     i = idx, #radarDots  radarDots[i].Visible =  
    
     fpvIdx = 
     Config.ESP_FPV 
         _, part  (Cache.drones) 
             fpvIdx > #fpvRadarDots   
             rx, rz = part.Position.X - myRoot.Position.X, part.Position.Z - myRoot.Position.Z
             dist2D = .(rx^ + rz^)
             dist2D < Tuning.RadarRange 
                 rotX = rx * cosA - rz * sinA
                 rotZ = rx * sinA + rz * cosA
                 radarX, radarY = rotX * scale, rotZ * scale
                 maxD = size/ - 
                 rDist = .(radarX^ + radarY^)
                 rDist > maxD  radarX, radarY = radarX/rDist*maxD, radarY/rDist*maxD 
                fpvRadarDots[fpvIdx].Position = .(, radarX, , radarY)
                fpvRadarDots[fpvIdx].Visible = 
                fpvIdx = fpvIdx + 
            
        
    
     i = fpvIdx, #fpvRadarDots  fpvRadarDots[i].Visible =  


 FOVCircle = .()
FOVCircle.BackgroundTransparency = 
FOVCircle.BorderSizePixel = 
FOVCircle.AnchorPoint = .(, )
FOVCircle.Parent = UI.ScreenGui
 FOVStroke = .()
FOVStroke.Color = Palette.FOV_Circle
FOVStroke.Thickness = 
FOVStroke.Parent = FOVCircle
.(, FOVCircle).CornerRadius = .(, )

 Aimbot = { aiming = , locked = , lockedFPV =  }

Connections.mb2down = Mouse.Button2Down:(() Aimbot.aiming = ; Aimbot.locked = ; Aimbot.lockedFPV =  )
Connections.mb2up = Mouse.Button2Up:(() Aimbot.aiming = ; Aimbot.locked = ; Aimbot.lockedFPV =  )

 Aimbot.(cam)
     center = .(cam.ViewportSize.X/, cam.ViewportSize.Y/)
     myRoot = LocalPlayer.Character  LocalPlayer.Character:()
      myRoot    
     best, bestDist, isFPV = , .huge, 
     root, char  (Cache.targets) 
         root  root.Parent  char 
              (Config.AIM_TeamCheck  Cache.teamStatus[root]) 
                 head = char:()
                 head 
                     sp, on = cam:(head.Position)
                     on  sp.Z >  
                         sDist = (.(sp.X, sp.Y) - center).Magnitude
                         sDist <= Config.AIM_FOV 
                             wDist = (root.Position - myRoot.Position).Magnitude
                             wDist < bestDist  bestDist = wDist; best = char; isFPV =  
                        
                    
                
            
        
    
     Config.AIM_FPV 
         drone, part  (Cache.drones) 
             drone  part  part.Parent 
                 sp, on = cam:(part.Position)
                 on  sp.Z >  
                     sDist = (.(sp.X, sp.Y) - center).Magnitude
                     sDist <= Config.AIM_FOV 
                         wDist = (part.Position - myRoot.Position).Magnitude
                         wDist < bestDist  bestDist = wDist; best = drone; isFPV =  
                    
                
            
        
    
     best, isFPV


 Aimbot.(cam, screenCenter)
     guiInset = GuiService:()
    
     Config.AIM_Enabled  Config.AIM_ShowFOV 
        FOVCircle.Position = .(, screenCenter.X, , screenCenter.Y + guiInset.Y)
        FOVCircle.Size = .(, Config.AIM_FOV * , , Config.AIM_FOV * )
        FOVStroke.Color = (Aimbot.aiming  Aimbot.locked)  Palette.FOV_Active  Palette.FOV_Circle
        FOVCircle.Visible = 
    
        FOVCircle.Visible = 
    


RunService:(, .RenderPriority.Camera.Value + , ()
     Unloaded   Config.AIM_Enabled   
     rmb = UserInputService:(.UserInputType.MouseButton2)
      (Aimbot.aiming  rmb)  Aimbot.locked = ; Aimbot.lockedFPV = ;  
    
     cam = Workspace.CurrentCamera
      cam   
    
     needNewTarget =  Aimbot.locked   Aimbot.locked.Parent
      needNewTarget   Aimbot.lockedFPV 
        needNewTarget =  Aimbot.locked:()
    
     needNewTarget 
         target, isFPV = Aimbot.(cam)
        Aimbot.locked = target
        Aimbot.lockedFPV = isFPV  
    
      Aimbot.locked   
    
     aimPos
     Aimbot.lockedFPV 
         part = Cache.drones[Aimbot.locked]
          part   part.Parent  Aimbot.locked = ; Aimbot.lockedFPV = ;  
        aimPos = part.Position
    
         head = Aimbot.locked:()
         hum = Aimbot.locked:()
          head   hum  hum.Health <=   Aimbot.locked = ;  
        aimPos = head.Position
    
    
     goal = .(cam.CFrame.Position, aimPos)
     newCF
     Config.AIM_Smooth <=  
        newCF = goal
    
         alpha = .( - (Config.AIM_Smooth/)*, , )
        newCF = cam.CFrame:(goal, alpha)
    
    cam.CFrame = newCF
    
    (()
         vm = cam:()
         vm 
             cb = vm:()
             cb  cb.CFrame = newCF 
             hrp = vm:()
             hrp  hrp.CFrame = newCF 
        
    )
    
    (()
         net = .ReplicatedStorage:()
         net 
             lv = net:()
             lv  lv:(newCF.LookVector) 
        
    )
)

 Desync = { active =  }

 Desync.()
    Desync.active = 
     Desync.active  Config.DESYNC_Enabled   Unloaded 
        (()
              LocalPlayer.Character   
             root = LocalPlayer.Character:()
              root   
             a = Config.DESYNC_Amount
             cf = root.CFrame
            root.CFrame = cf * .(.(-a,a)*, , .(-a,a)*)
            .()
            root.CFrame = cf
        )
        .( + /.(Config.DESYNC_Amount, ))
    
    Desync.active = 


.(()
      Unloaded 
         Config.DESYNC_Enabled   Desync.active  .(Desync.Run) 
        .()
    
)

 Trigger = { active = , lastShot =  }

 Trigger.(cam)
     center = .(cam.ViewportSize.X/, cam.ViewportSize.Y/)
     root, char  (Cache.targets) 
         root  char 
             Config.TRIGGER_TeamCheck  Cache.teamStatus[root]   
             hum = char:()
              hum  hum.Health <=    
             _, pn  ({, , }) 
                 p = char:(pn)
                 p 
                     sp, on = cam:(p.Position)
                     on  sp.Z >   (.(sp.X, sp.Y) - center).Magnitude < Tuning.TriggerRadius 
                         
                    
                
            
        
    
     


 Trigger.()
    (()  mouse1click  ()  )
    (()
         vim = :()
        vim:(,,,,,)
        .()
        vim:(,,,,,)
    )


 Trigger.()
    Trigger.active = 
     Config.TRIGGER_Enabled   Unloaded 
        (()
             cam = Workspace.CurrentCamera
             cam  Trigger.(cam) 
                 now = () * 
                 now - Trigger.lastShot >= Config.TRIGGER_Delay 
                    Trigger.()
                    Trigger.lastShot = now
                
            
        )
        .()
    
    Trigger.active = 


.(()
      Unloaded 
         Config.TRIGGER_Enabled   Trigger.active  .(Trigger.Run) 
        .()
    
)

 Tabs = {{name = }, {name = }, {name = }}
 MenuItems = {
    {tab = , name = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = , min = , max = , step = },
    {tab = , name = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = , min = , max = , step = },
    
    {tab = , name = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = , min = , max = , step = },
    {tab = , name = , key = ,  = , min = , max = , step = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    
    {tab = , name = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = , min = , max = , step = },
    {tab = , name = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = , min = , max = , step = },
    {tab = , name = , key = ,  = }
}

 GUI = {
    Frame = ,
    Position = ,
    Dragging = ,
    DragOffset = .zero,
    Items = {},
    TabButtons = {},
    ContentFrame = 
}

 GUI.()
     menuW, menuH = , 
     titleH, tabH, footerH = , , 
    
     main = .()
    main.Name = 
    main.BackgroundColor3 = Palette.MenuBg
    main.BackgroundTransparency = 
    main.BorderSizePixel = 
    main.Size = .(, menuW, , menuH)
    main.Position = .(, , , -menuH/)
    main.Active = 
    main.Parent = UI.ScreenGui
    GUI.Frame = main
    
     stroke = .()
    stroke.Color = Palette.MenuBorder
    stroke.Thickness = 
    stroke.Parent = main
    
     title = .()
    title.Name = 
    title.BackgroundColor3 = Palette.MenuTab
    title.BorderSizePixel = 
    title.Size = .(, , , titleH)
    title.Parent = main
    
     titleText = .()
    titleText.BackgroundTransparency = 
    titleText.Position = .(, , , )
    titleText.Size = .(, , , )
    titleText.Font = .Font.GothamBold
    titleText.TextSize = 
    titleText.TextColor3 = Palette.MenuAccent
    titleText.TextXAlignment = .TextXAlignment.Left
    titleText.Text = 
    titleText.Parent = title
    
     xenoTag = .()
    xenoTag.BackgroundTransparency = 
    xenoTag.Position = .(, , , )
    xenoTag.Size = .(, , , )
    xenoTag.Font = .Font.RobotoMono
    xenoTag.TextSize = 
    xenoTag.TextColor3 = .(, , )
    xenoTag.TextXAlignment = .TextXAlignment.Left
    xenoTag.Text = 
    xenoTag.Parent = title
    
     hotkeyText = .()
    hotkeyText.BackgroundTransparency = 
    hotkeyText.Position = .(, -, , )
    hotkeyText.Size = .(, , , )
    hotkeyText.Font = .Font.RobotoMono
    hotkeyText.TextSize = 
    hotkeyText.TextColor3 = Palette.MenuTextDim
    hotkeyText.TextXAlignment = .TextXAlignment.Right
    hotkeyText.Text = 
    hotkeyText.Parent = title
    
     tabFrame = .()
    tabFrame.Name = 
    tabFrame.BackgroundTransparency = 
    tabFrame.Position = .(, , , titleH)
    tabFrame.Size = .(, , , tabH)
    tabFrame.Parent = main
    
     tabW = menuW / #Tabs
     i, tab  (Tabs) 
         btn = .()
        btn.Name = tab.name
        btn.BackgroundColor3 = Palette.MenuTab
        btn.BackgroundTransparency = 
        btn.BorderSizePixel = 
        btn.Position = .(, (i-) * tabW, , )
        btn.Size = .(, tabW, , )
        btn.Font = .Font.GothamBold
        btn.TextSize = 
        btn.TextColor3 = Palette.MenuTextDim
        btn.Text = tab.name
        btn.AutoButtonColor = 
        btn.Parent = tabFrame
        
         indicator = .()
        indicator.Name = 
        indicator.BackgroundColor3 = Palette.MenuAccent
        indicator.BorderSizePixel = 
        indicator.Position = .(, , , -)
        indicator.Size = .(, , , )
        indicator.Visible = i == 
        indicator.Parent = btn
        
        btn.MouseButton1Click:(()
            Config.MENU_Tab = i
            GUI.()
            GUI.()
        )
        
        GUI.TabButtons[i] = {Button = btn, Indicator = indicator}
    
    
     contentFrame = .()
    contentFrame.Name = 
    contentFrame.BackgroundTransparency = 
    contentFrame.Position = .(, , , titleH + tabH + )
    contentFrame.Size = .(, -, , -titleH - tabH - footerH - )
    contentFrame.CanvasSize = .(, , , )
    contentFrame.ScrollBarThickness = 
    contentFrame.ScrollBarImageColor3 = Palette.MenuAccent
    contentFrame.BorderSizePixel = 
    contentFrame.Parent = main
    GUI.ContentFrame = contentFrame
    
     layout = .()
    layout.SortOrder = .SortOrder.LayoutOrder
    layout.Padding = .(, )
    layout.Parent = contentFrame
    
     footer = .()
    footer.Name = 
    footer.BackgroundTransparency = 
    footer.Position = .(, , , -footerH)
    footer.Size = .(, , , footerH)
    footer.Parent = main
    
     credit = .()
    credit.BackgroundTransparency = 
    credit.Position = .(, , , )
    credit.Size = .(, -, , )
    credit.Font = .Font.RobotoMono
    credit.TextSize = 
    credit.TextColor3 = Palette.MenuTextDim
    credit.TextXAlignment = .TextXAlignment.Right
    credit.Text = 
    credit.Parent = footer
    
    title.InputBegan:((input)
         input.UserInputType == .UserInputType.MouseButton1 
            GUI.Dragging = 
             mouse = UserInputService:()
            GUI.DragOffset = mouse - .(main.AbsolutePosition.X, main.AbsolutePosition.Y)
        
    )
    
    title.InputEnded:((input)
         input.UserInputType == .UserInputType.MouseButton1 
            GUI.Dragging = 
        
    )
    
    GUI.()


 GUI.()
     i, tab  (GUI.TabButtons) 
         isSelected = i == Config.MENU_Tab
        tab.Button.BackgroundTransparency = isSelected    
        tab.Button.TextColor3 = isSelected  .(, , )  Palette.MenuTextDim
        tab.Indicator.Visible = isSelected
    


 GUI.()
     _, child  (GUI.ContentFrame:()) 
         child:()  child:() 
    
    GUI.Items = {}
    
     order = 
     _, menuItem  (MenuItems) 
         menuItem.tab == Config.MENU_Tab 
            order = order + 
             itemH = menuItem.type ==     
            
             item = .()
            item.Name = menuItem.name
            item.BackgroundColor3 = menuItem.type ==   Palette.MenuBg  Palette.MenuPanel
            item.BackgroundTransparency = menuItem.type ==     
            item.BorderSizePixel = 
            item.Size = .(, , , itemH)
            item.LayoutOrder = order
            item.Parent = GUI.ContentFrame
            
             label = .()
            label.BackgroundTransparency = 
            label.Position = .(, , , )
            label.Size = .(, , , )
            label.Font = .Font.RobotoMono
            label.TextSize = menuItem.type ==     
            label.TextColor3 = menuItem.type ==   Palette.MenuAccent  Palette.MenuText
            label.TextXAlignment = .TextXAlignment.Left
            label.Text = menuItem.name
            label.Parent = item
            
             menuItem.type ==  
                 toggle = .()
                toggle.Name = 
                toggle.BackgroundColor3 = Config[menuItem.key]  Palette.MenuOn  Palette.MenuOff
                toggle.BorderSizePixel = 
                toggle.Position = .(, -, , -)
                toggle.Size = .(, , , )
                toggle.Parent = item
                .(, toggle).CornerRadius = .(, )
                
                 knob = .()
                knob.Name = 
                knob.BackgroundColor3 = .(, , )
                knob.BorderSizePixel = 
                knob.Position = Config[menuItem.key]  .(, -, , -)  .(, , , -)
                knob.Size = .(, , , )
                knob.Parent = toggle
                .(, knob).CornerRadius = .(, )
                
                 btn = .()
                btn.BackgroundTransparency = 
                btn.Size = .(, , , )
                btn.Text = 
                btn.Parent = item
                
                btn.MouseButton1Click:(()
                    Config[menuItem.key] =  Config[menuItem.key]
                    toggle.BackgroundColor3 = Config[menuItem.key]  Palette.MenuOn  Palette.MenuOff
                    knob.Position = Config[menuItem.key]  .(, -, , -)  .(, , , -)
                )
                
             menuItem.type ==  
                 val = Config[menuItem.key]
                 valText = menuItem.step <   .(, val)  (.(val))
                
                 valLabel = .()
                valLabel.Name = 
                valLabel.BackgroundTransparency = 
                valLabel.Position = .(, -, , )
                valLabel.Size = .(, , , )
                valLabel.Font = .Font.RobotoMono
                valLabel.TextSize = 
                valLabel.TextColor3 = Palette.MenuTextDim
                valLabel.TextXAlignment = .TextXAlignment.Right
                valLabel.Text = valText
                valLabel.Parent = item
                
                 track = .()
                track.Name = 
                track.BackgroundColor3 = Palette.MenuOff
                track.BorderSizePixel = 
                track.Position = .(, , , )
                track.Size = .(, -, , )
                track.Parent = item
                .(, track).CornerRadius = .(, )
                
                 pct = (val - menuItem.min) / (menuItem.max - menuItem.min)
                 fill = .()
                fill.Name = 
                fill.BackgroundColor3 = Palette.MenuAccent
                fill.BorderSizePixel = 
                fill.Size = .(pct, , , )
                fill.Parent = track
                .(, fill).CornerRadius = .(, )
                
                 dragging = 
                track.InputBegan:((input)
                     input.UserInputType == .UserInputType.MouseButton1 
                        dragging = 
                    
                )
                track.InputEnded:((input)
                     input.UserInputType == .UserInputType.MouseButton1 
                        dragging = 
                    
                )
                
                Connections[ .. menuItem.key] = RunService.RenderStepped:(()
                     dragging 
                         mx = UserInputService:().X
                         tx = track.AbsolutePosition.X
                         tw = track.AbsoluteSize.X
                         p = .((mx - tx) / tw, , )
                         v = menuItem.min + p * (menuItem.max - menuItem.min)
                        v = .(v / menuItem.step + ) * menuItem.step
                        Config[menuItem.key] = .(v, menuItem.min, menuItem.max)
                        fill.Size = .((Config[menuItem.key] - menuItem.min) / (menuItem.max - menuItem.min), , , )
                        valLabel.Text = menuItem.step <   .(, Config[menuItem.key])  (.(Config[menuItem.key]))
                    
                )
            
            
            GUI.Items[#GUI.Items + ] = item
        
    
    
     totalH = 
     _, item  (GUI.Items) 
        totalH = totalH + item.AbsoluteSize.Y + 
    
    GUI.ContentFrame.CanvasSize = .(, , , totalH)


 GUI.()
     GUI.Dragging 
         mouse = UserInputService:()
         newPos = mouse - GUI.DragOffset
        GUI.Frame.Position = .(, newPos.X, , newPos.Y)
    


  ()
     Unloaded   
    Unloaded = 
    
    Config.DESYNC_Enabled = 
    Config.TRIGGER_Enabled = 
    Desync.active = 
    Trigger.active = 
    
    (() RunService:() )
    
     _, c  (Connections)  (() c:() ) 
    
     _, esp  (ESP.cache)  ESP.(esp) 
     _, esp  (FPV.cache)  FPV.(esp) 
    
    (() UI.ScreenGui:() )


Connections.input = UserInputService.InputBegan:((input, gp)
     input.KeyCode == .KeyCode.Home  ();  
     input.KeyCode == .KeyCode.Insert   gp 
        Config.MENU_Open =  Config.MENU_Open
         GUI.Frame  GUI.Frame.Visible = Config.MENU_Open 
        
    
)

Connections.inputUp = UserInputService.InputEnded:((input)
     input.UserInputType == .UserInputType.MouseButton1  GUI.Dragging =  
)

Connections.render = RunService.RenderStepped:(()
     Unloaded   
    
     cam = Workspace.CurrentCamera
      cam   
     screenSize = cam.ViewportSize
     screenCenter = .(screenSize.X/, screenSize.Y/)
     now = ()
    
     myChar = LocalPlayer.Character
    Cache.myRoot = myChar  myChar:()
    
     now - Timers.lastTeamRefresh > Tuning.TeamRefreshRate  Timers.lastTeamRefresh = now; Team.() 
     now - Timers.lastTargetRefresh > Tuning.TargetRefreshRate  Timers.lastTargetRefresh = now; Targets.() 
     now - Timers.lastVisRefresh > Tuning.VisibilityRefreshRate  Timers.lastVisRefresh = now; Targets.() 
     now - Timers.lastFPVRefresh > Tuning.FPVRefreshRate  Timers.lastFPVRefresh = now; Cache.drones = FPV.() 
    
    (() ESP.(cam, screenSize, screenCenter) )
    (() FPV.(cam) )
    (() (cam) )
    (() Aimbot.(cam, screenCenter) )
    (GUI.Step)
)

GUI.()
GUI.()