Updated SOURCE ESP AIM TRIGGER DESYNC FPV ESP

 Players = :()
 RunService = :()
 UserInputService = :()
 LocalPlayer = Players.LocalPlayer
 Mouse = LocalPlayer:()

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

 Tuning = {
    TargetRefreshRate = ,
    VisibilityRefreshRate = ,
    WeaponRefreshRate = ,
    FPVRefreshRate = ,
    TeamRefreshRate = ,
    
    BoxWidthRatio = ,
    HealthBarWidth = ,
    HealthBarOffset = ,
    NameOffset = ,
    DistOffset = ,
    WeaponOffset = ,
    LookingOffset = ,
    
    OffscreenEdgeDist = ,
    OffscreenArrowSize = ,
    AimLineLength = ,
    LookingThreshold = ,
    
    SoundRippleMax = ,
    SoundRippleDuration = ,
    SoundRippleRadius = ,
    SoundMoveThreshold = ,
    
    TrailMaxPoints = ,
    TrailUpdateInterval = ,
    
    RadarRange = ,
    RadarDotSize = ,
    RadarArrowSize = ,
    
    FPVClusterDist = ,
    FPVGravity = ,
    FPVPredictTime = ,
    FPVPredictSteps = ,
    
    TriggerRadius = 
}

 Colors = {
    Enemy = .(, , ),
    EnemyVisible = .(, , ),
    Team = .(, , ),
    Skeleton = .(, , ),
    SkeletonVisible = .(, , ),
    LookingAtYou = .(, , ),
    AimDir = .(, , ),
    Weapon = .(, , ),
    FPV = .(, , ),
    Tracer = .(, , ),
    Sound = .(, , ),
    Trail = .(, , ),
    HealthHigh = .(, , ),
    HealthMid = .(, , ),
    HealthLow = .(, , ),
    HealthBg = .(, , ),
    RadarBg = .(, , ),
    RadarBorder = .(, , ),
    RadarYou = .(, , ),
    RadarEnemy = .(, , ),
    RadarTeam = .(, , ),
    MenuBg = .(, , ),
    MenuHighlight = .(, , ),
    MenuOn = .(, , ),
    MenuOff = .(, , ),
    MenuText = .(, , ),
}

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

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

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

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

 Connections = {}
 Unloaded = 
 Silent = { hooked = , currentRoot =  }

 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 = .CurrentCamera
      cam    
    
     origin = cam.CFrame.Position
     parts = {, , }
    
     rayParams = RaycastParams.()
    rayParams.FilterType = .RaycastFilterType.Blacklist
     filter = {cam}
     LocalPlayer.Character  .(filter, LocalPlayer.Character) 
    .(filter, character)
    rayParams.FilterDescendantsInstances = filter
    
     _, partName  (parts) 
         part = character:(partName)
         part 
             dir = (part.Position - origin)
             result = :(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)
     _, child  (char:()) 
         child.Name ==   child:() 
             items = child:()
             #items >    items[].Name 
        
    
     charName = char.Name
     _, folder  (:()) 
         folder:() 
             _, sub  (folder:()) 
                 sub:()  sub:() 
                     pf = sub:(charName)
                     pf 
                         itemFolder = pf:()
                         itemFolder  #itemFolder:() >  
                             itemFolder:()[].Name
                        
        
    

    

     


 Util.(char)
     _, p  (Players:()) 
         p.Character == char   p.Name 
    
     ( char.Name:())  char.Name  


 Targets = {}

 Targets.()
     new, newTeam = {}, {}
     myChar = LocalPlayer.Character
     _, obj  (:()) 
         obj.Name ==   obj:() 
             parent = obj.Parent
             parent  parent ~= myChar  obj.Position.Y > - 
                 Team.(parent)   
                
                 hum = parent:()
                 hum  hum.Health >  
                    new[obj] = parent
                    newTeam[obj] = Team.(parent)
                
            
        
    
    Cache.targets = new
    Cache.teamStatus = newTeam


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


 Targets.()
     root, char  (Cache.targets) 
        Cache.weapons[root] = Util.(char)
    


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

 ESP.()
     {
        Box = {.(), .(), .(), .()},
        Name = .(),
        Dist = .(),
        Weapon = .(),
        HealthBg = .(),
        HealthBar = .(),
        Skel = {.(), .(), .(), .(), .()},
        Offscreen = .(),
        AimLine = .(),
        LookingText = .(),
        Tracer = .(),
        SilentText = .(),
        VelLine = .(),
        VelArrow = .(),
    }


 ESP.(esp)
     _, l  (esp.Box)  l.Thickness =  
    esp.Name.Size = ; esp.Name.Font = .Fonts.Monospace; esp.Name.Center = ; esp.Name.Outline = 
    esp.Dist.Size = ; esp.Dist.Font = .Fonts.Monospace; esp.Dist.Center = ; esp.Dist.Outline = 
    esp.Weapon.Size = ; esp.Weapon.Font = .Fonts.Monospace; esp.Weapon.Outline = 
    esp.HealthBg.Filled = ; esp.HealthBg.Color = Colors.HealthBg
    esp.HealthBar.Filled = 
     _, l  (esp.Skel)  l.Thickness =  
    esp.Offscreen.Filled = ; esp.Offscreen.Thickness = 
    esp.AimLine.Thickness = 
    esp.LookingText.Size = ; esp.LookingText.Font = .Fonts.Monospace; esp.LookingText.Center = ; esp.LookingText.Outline = 
    esp.Tracer.Thickness = ; esp.Tracer.Color = Colors.Tracer
    esp.SilentText.Size = ; esp.SilentText.Font = .Fonts.Monospace; esp.SilentText.Center = ; esp.SilentText.Outline = ; esp.SilentText.Color = .(, , )
    esp.VelLine.Thickness = ; esp.VelLine.Color = .(, , )
    esp.VelArrow.Filled = ; esp.VelArrow.Color = .(, , )


 ESP.(esp)
     _, l  (esp.Box)  l.Visible =  
    esp.Name.Visible = ; esp.Dist.Visible = ; esp.Weapon.Visible = 
    esp.HealthBg.Visible = ; esp.HealthBar.Visible = 
     _, l  (esp.Skel)  l.Visible =  
    esp.Offscreen.Visible = ; esp.AimLine.Visible = ; esp.LookingText.Visible = 
    esp.Tracer.Visible = ; esp.SilentText.Visible = 
    esp.VelLine.Visible = ; esp.VelArrow.Visible = 


 ESP.(esp)
    (()
         _, l  (esp.Box)  l:() 
        esp.Name:(); esp.Dist:(); esp.Weapon:()
        esp.HealthBg:(); esp.HealthBar:()
         _, l  (esp.Skel)  l:() 
        esp.Offscreen:(); esp.AimLine:(); esp.LookingText:()
        esp.Tracer:(); esp.SilentText:()
        esp.VelLine:(); esp.VelArrow:()
    )


 ESP.()
     root, esp  (ESP.cache) 
          Cache.targets[root] 
            ESP.(esp)
            ESP.(esp)
            ESP.cache[root] = 
            ESP.velocityData[root] = 
        
    


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


 ESP.(cam, screenSize, screenCenter)
      Config.ESP_Enabled 
        ESP.()
        
    
    
    ESP.()
    
     root, char  (Cache.targets) 
          root   root.Parent   char 
             ESP.cache[root]  ESP.(ESP.cache[root]); ESP.(ESP.cache[root]); ESP.cache[root] =  
        
             hum = char:()
              hum  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.cache[root] = ESP.()
                    ESP.(ESP.cache[root])
                
                 esp = ESP.cache[root]
                 myRoot = LocalPlayer.Character  LocalPlayer.Character:()
                 dist = myRoot  (root.Position - myRoot.Position).Magnitude  
                
                 dist > Config.ESP_MaxDist 
                    ESP.(esp)
                
                    ESP.(esp, root, char, hum, cam, screenSize, screenCenter, dist)
                
            
        
    


 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  Colors.Team  (visible  Colors.EnemyVisible  Colors.Enemy)
     skelCol = isTeam  Colors.Team  (visible  Colors.SkeletonVisible  Colors.Skeleton)
     lookingAtYou = visible  Util.(char)  
    
     onScreen 
        esp.Offscreen.Visible = 
         boxTop, boxBottom = hs.Y, fs.Y
         boxHeight = .(boxBottom - boxTop)
         boxWidth = boxHeight * Tuning.BoxWidthRatio
         cx = rs.X
        
         Config.ESP_Boxes 
            esp.Box[].From = .(cx - boxWidth/, boxTop)
            esp.Box[].To = .(cx + boxWidth/, boxTop)
            esp.Box[].From = .(cx + boxWidth/, boxTop)
            esp.Box[].To = .(cx + boxWidth/, boxBottom)
            esp.Box[].From = .(cx + boxWidth/, boxBottom)
            esp.Box[].To = .(cx - boxWidth/, boxBottom)
            esp.Box[].From = .(cx - boxWidth/, boxBottom)
            esp.Box[].To = .(cx - boxWidth/, boxTop)
             _, l  (esp.Box)  l.Color = col; l.Visible =  
        
             _, l  (esp.Box)  l.Visible =  
        
        
         Config.ESP_Names 
            esp.Name.Text = Util.(char)
            esp.Name.Position = .(cx, hs.Y - Tuning.NameOffset)
            esp.Name.Color = col
            esp.Name.Visible = 
         esp.Name.Visible =  
        
         Config.ESP_Distance 
            esp.Dist.Text = .(dist) .. 
            esp.Dist.Position = .(cx, fs.Y + Tuning.DistOffset)
            esp.Dist.Color = .(,,)
            esp.Dist.Visible = 
         esp.Dist.Visible =  
        
         Config.ESP_Weapons 
             weapon = Cache.weapons[root]
             weapon 
                esp.Weapon.Text =  .. weapon .. 
                esp.Weapon.Position = .(cx + boxWidth/ + Tuning.WeaponOffset, rs.Y)
                esp.Weapon.Color = Colors.Weapon
                esp.Weapon.Visible = 
             esp.Weapon.Visible =  
         esp.Weapon.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.Color = pct >   Colors.HealthHigh  pct >   Colors.HealthMid  Colors.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].From = .(s1.X, s1.Y)
                        esp.Skel[i].To = .(s2.X, s2.Y)
                        esp.Skel[i].Color = skelCol
                        esp.Skel[i].Visible = 
                     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
             aimScreen, aimOn = cam:(aimEnd)
             headScreen = cam:(head.Position)
             aimOn  headScreen.Z >  
                esp.AimLine.From = .(headScreen.X, headScreen.Y)
                esp.AimLine.To = .(aimScreen.X, aimScreen.Y)
                esp.AimLine.Color = Colors.AimDir
                esp.AimLine.Visible = 
             esp.AimLine.Visible =  
         esp.AimLine.Visible =  
        
         Config.ESP_LookingAtYou  lookingAtYou 
            esp.LookingText.Text = 
            esp.LookingText.Position = .(cx, hs.Y - Tuning.LookingOffset)
            esp.LookingText.Color = Colors.LookingAtYou
            esp.LookingText.Visible = 
         esp.LookingText.Visible =  
        
         Config.ESP_Tracers 
            esp.Tracer.From = .(screenCenter.X, screenSize.Y)
            esp.Tracer.To = .(cx, fs.Y)
            esp.Tracer.Color = visible  Colors.EnemyVisible  Colors.Tracer
            esp.Tracer.Visible = 
         esp.Tracer.Visible =  
        
         Config.SILENT_Enabled  Silent.currentRoot == root  visible 
            esp.SilentText.Text = 
            esp.SilentText.Position = .(cx, hs.Y - Tuning.LookingOffset - )
            esp.SilentText.Visible = 
         esp.SilentText.Visible =  
        
         vd = ESP.velocityData[root]
          vd  vd = {pos = root.Position, vel = .zero, time = ()}; ESP.velocityData[root] = vd 
         now = ()
         dt = now - vd.time
         dt >  
             rawVel = (root.Position - vd.pos) / dt
            vd.vel = vd.vel *  + rawVel * 
            vd.pos = root.Position
            vd.time = now
        
         Config.ESP_Velocity   isTeam 
             velFlat = .(vd.vel.X, , vd.vel.Z)
             velMag = velFlat.Magnitude
             velMag >  
                 futurePos = root.Position + velFlat.Unit * .(velMag * , , )
                 futureScreen, futureOn = cam:(futurePos)
                 futureOn  futureScreen.Z >  
                    esp.VelLine.From = .(rs.X, rs.Y)
                    esp.VelLine.To = .(futureScreen.X, futureScreen.Y)
                    esp.VelLine.Visible = 
                     dx, dy = futureScreen.X - rs.X, futureScreen.Y - rs.Y
                     len = .(dx*dx + dy*dy)
                     len >  
                         fx, fy = dx/len, dy/len
                        esp.VelArrow.PointA = .(futureScreen.X, futureScreen.Y)
                        esp.VelArrow.PointB = .(futureScreen.X - fx* + fy*, futureScreen.Y - fy* - fx*)
                        esp.VelArrow.PointC = .(futureScreen.X - fx* - fy*, futureScreen.Y - fy* + fx*)
                        esp.VelArrow.Visible = 
                     esp.VelArrow.Visible =  
                 esp.VelLine.Visible = ; esp.VelArrow.Visible =  
             esp.VelLine.Visible = ; esp.VelArrow.Visible =  
         esp.VelLine.Visible = ; esp.VelArrow.Visible =  
        
         Config.ESP_Sound   isTeam 
             velMag = vd.vel.Magnitude
             velMag > Tuning.SoundMoveThreshold 
                Sound.(.(root.Position.X, root.Position.Y - , root.Position.Z))
            
        
        
         Config.ESP_Trails   isTeam 
            Trails.(char, root.Position)
            Trails.(char, cam)
         Trails.(char) 
    
         _, l  (esp.Box)  l.Visible =  
        esp.Name.Visible = ; esp.Dist.Visible = ; esp.Weapon.Visible = 
        esp.HealthBg.Visible = ; esp.HealthBar.Visible = 
         _, l  (esp.Skel)  l.Visible =  
        esp.AimLine.Visible = ; esp.LookingText.Visible = ; esp.Tracer.Visible = 
        esp.SilentText.Visible = ; esp.VelLine.Visible = ; esp.VelArrow.Visible = 
        Trails.(char)
        
         Config.ESP_Offscreen  visible 
             screenPos = cam:(root.Position)
             dx, dy = screenPos.X - screenCenter.X, screenPos.Y - screenCenter.Y
             angle = .(dy, dx)
             arrowX = .(screenCenter.X + .(angle) * (screenSize.X/ - Tuning.OffscreenEdgeDist), Tuning.OffscreenEdgeDist, screenSize.X - Tuning.OffscreenEdgeDist)
             arrowY = .(screenCenter.Y + .(angle) * (screenSize.Y/ - Tuning.OffscreenEdgeDist), Tuning.OffscreenEdgeDist, screenSize.Y - Tuning.OffscreenEdgeDist)
             fwd = .(.(angle), .(angle))
             right = .(-fwd.Y, fwd.X)
             pos = .(arrowX, arrowY)
            esp.Offscreen.PointA = pos + fwd * Tuning.OffscreenArrowSize
            esp.Offscreen.PointB = pos - fwd * Tuning.OffscreenArrowSize/ - right * Tuning.OffscreenArrowSize/
            esp.Offscreen.PointC = pos - fwd * Tuning.OffscreenArrowSize/ + right * Tuning.OffscreenArrowSize/
            esp.Offscreen.Color = Colors.EnemyVisible
            esp.Offscreen.Visible = 
         esp.Offscreen.Visible =  
    


Sound = { ripples = {} }

 Sound.(pos)
     #Sound.ripples >= Tuning.SoundRippleMax 
         old = .(Sound.ripples, )
         old.circles   _, c  (old.circles)  c:()  
    
     r = {position = pos, startTime = (), circles = {}}
     i = ,  
         c = .()
        c.Filled = ; c.Color = Colors.Sound; c.Thickness = ; c.NumSides = ; c.Visible = 
        r.circles[i] = c
    
    .(Sound.ripples, r)


 Sound.(cam)
      Config.ESP_Enabled   Config.ESP_Sound 
         _, r  (Sound.ripples)   _, c  (r.circles)  c.Visible =   
        
    
     now, remove = (), {}
     i, r  (Sound.ripples) 
         age = now - r.startTime
         age > Tuning.SoundRippleDuration  .(remove, i)
        
             sp, on = cam:(r.position)
             on  sp.Z >  
                 j, c  (r.circles) 
                     ca = age - (j-) * 
                     ca >   ca < Tuning.SoundRippleDuration 
                         prog = ca / Tuning.SoundRippleDuration
                        c.Position = .(sp.X, sp.Y)
                        c.Radius = prog * Tuning.SoundRippleRadius
                        c.Transparency = ( - prog) * 
                        c.Visible = 
                     c.Visible =  
                
              _, c  (r.circles)  c.Visible =   
        
    
     i = #remove, , - 
         r = Sound.ripples[remove[i]]
         r.circles   _, c  (r.circles)  c:()  
        .(Sound.ripples, remove[i])
    


Trails = { data = {} }

 Trails.(char)
      Trails.data[char] 
        Trails.data[char] = {positions = {}, lines = {}, lastUpdate = }
         i = , Tuning.TrailMaxPoints -  
             l = .(); l.Thickness = ; l.Color = Colors.Trail; l.Visible = 
            Trails.data[char].lines[i] = l
        
    
     Trails.data[char]


 Trails.(char, pos)
     t = Trails.(char)
     () - t.lastUpdate > Tuning.TrailUpdateInterval 
        .(t.positions, , pos)
         #t.positions > Tuning.TrailMaxPoints  .(t.positions) 
        t.lastUpdate = ()
    


 Trails.(char, cam)
     t = Trails.data[char]
      t   
     i, line  (t.lines) 
         t.positions[i]  t.positions[i+] 
             s1, o1 = cam:(t.positions[i])
             s2, o2 = cam:(t.positions[i+])
             (o1  o2)  s1.Z >   s2.Z >  
                line.From = .(s1.X, s1.Y)
                line.To = .(s2.X, s2.Y)
                line.Transparency = ( - i/Tuning.TrailMaxPoints) * 
                line.Visible = 
             line.Visible =  
         line.Visible =  
    


 Trails.(char)
     t = Trails.data[char]
     t   _, l  (t.lines)  l.Visible =   


 Trails.()
     _, t  (Trails.data) 
         _, l  (t.lines)  l.Visible =  
    


 Trails.()
      Config.ESP_Enabled   Config.ESP_Trails 
        Trails.()
    
     char  (Trails.data) 
         found = 
         _, c  (Cache.targets)   c == char  found = ;   
          found 
             _, l  (Trails.data[char].lines)  l:() 
            Trails.data[char] = 
        
    


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

 FPV.()
     {
        Box = {.(), .(), .(), .()},
        Name = .(), Dist = .(),
        Trajectory = .(), TrajectoryEnd = .(),
        lastPos = , lastTime = , velocity = .(,,)
    }


 FPV.(esp)
     _, l  (esp.Box)  l.Thickness = ; l.Color = Colors.FPV 
    esp.Name.Size = ; esp.Name.Font = .Fonts.Monospace; esp.Name.Center = ; esp.Name.Outline = ; esp.Name.Color = Colors.FPV
    esp.Dist.Size = ; esp.Dist.Font = .Fonts.Monospace; esp.Dist.Center = ; esp.Dist.Outline = ; esp.Dist.Color = Colors.FPV
    esp.Trajectory.Thickness = ; esp.Trajectory.Color = .(, , )
    esp.TrajectoryEnd.Filled = ; esp.TrajectoryEnd.Color = .(, , ); esp.TrajectoryEnd.Radius = ; esp.TrajectoryEnd.NumSides = 


 FPV.(esp)
     _, l  (esp.Box)  l.Visible =  
    esp.Name.Visible = ; esp.Dist.Visible = 
    esp.Trajectory.Visible = ; esp.TrajectoryEnd.Visible = 


 FPV.(esp)
    (()
         _, l  (esp.Box)  l:() 
        esp.Name:(); esp.Dist:(); esp.Trajectory:(); esp.TrajectoryEnd:()
    )


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

 FPV.()
      Config.ESP_FPV   {} 
     drones, seen = {}, {}
     camRef = .CurrentCamera
     plrs = Players:()
     _, obj  (:()) 
         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
                
            
        
    
     drones


 FPV.(cam)
      Config.ESP_Enabled   Config.ESP_FPV 
         _, e  (FPV.cache)  FPV.(e) 
        
    
    
     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] =  
    
    
     drone, part  (toShow) 
          FPV.cache[drone]  FPV.cache[drone] = FPV.(); FPV.(FPV.cache[drone]) 
         esp = FPV.cache[drone]
         pos = part.Position
         sp, on = cam:(pos)
         on  sp.Z >  
             myRoot = LocalPlayer.Character  LocalPlayer.Character:()
             dist = myRoot  (pos - myRoot.Position).Magnitude  
             dist < Config.ESP_MaxDist 
                 size = .( / sp.Z, , )
                 cx, cy = sp.X, sp.Y
                esp.Box[].From = .(cx-size/, cy-size/); esp.Box[].To = .(cx+size/, cy-size/)
                esp.Box[].From = .(cx+size/, cy-size/); esp.Box[].To = .(cx+size/, cy+size/)
                esp.Box[].From = .(cx+size/, cy+size/); esp.Box[].To = .(cx-size/, cy+size/)
                esp.Box[].From = .(cx-size/, cy+size/); esp.Box[].To = .(cx-size/, cy-size/)
                 _, l  (esp.Box)  l.Visible =  
                esp.Name.Text = ; esp.Name.Position = .(cx, cy-size/-); esp.Name.Visible = 
                esp.Dist.Text = .(dist)..; esp.Dist.Position = .(cx, cy+size/+); esp.Dist.Visible = 
                
                 Config.ESP_FPVPredict 
                     now = ()
                     esp.lastPos  now - esp.lastTime <  
                         dt = now - esp.lastTime
                         dt >   esp.velocity = esp.velocity:((pos - esp.lastPos)/dt, ) 
                    
                    esp.lastPos, esp.lastTime = pos, now
                     esp.velocity.Magnitude >  
                         simPos, simVel, hit = pos, esp.velocity, 
                         dt = Tuning.FPVPredictTime / Tuning.FPVPredictSteps
                         _ = , Tuning.FPVPredictSteps 
                            simVel = simVel + .(, -Tuning.FPVGravity * dt, )
                            simPos = simPos + simVel * dt
                             simPos.Y < -  hit = simPos;  
                        
                         endPos = hit  simPos
                         es, eo = cam:(endPos)
                         eo  es.Z >  
                            esp.Trajectory.From = .(cx, cy); esp.Trajectory.To = .(es.X, es.Y); esp.Trajectory.Visible = 
                            esp.TrajectoryEnd.Position = .(es.X, es.Y); esp.TrajectoryEnd.Visible = 
                         esp.Trajectory.Visible = ; esp.TrajectoryEnd.Visible =  
                     esp.Trajectory.Visible = ; esp.TrajectoryEnd.Visible =  
                 esp.Trajectory.Visible = ; esp.TrajectoryEnd.Visible =  
             FPV.(esp) 
         FPV.(esp) 
    


 Radar = {
    bg = .(),
    circleBg = .(),
    border = .(),
    circleBorder = .(),
    cross1 = .(),
    cross2 = .(),
    center = .(),
    dots = {},
    fpvDots = {}
}


    Radar.bg.Filled = ; Radar.bg.Color = Colors.RadarBg; Radar.bg.Transparency = 
    Radar.circleBg.Filled = ; Radar.circleBg.Color = Colors.RadarBg; Radar.circleBg.Transparency = ; Radar.circleBg.NumSides = 
    Radar.border.Filled = ; Radar.border.Color = Colors.RadarBorder; Radar.border.Thickness = 
    Radar.circleBorder.Filled = ; Radar.circleBorder.Color = Colors.RadarBorder; Radar.circleBorder.Thickness = ; Radar.circleBorder.NumSides = 
    Radar.cross1.Color = .(,,); Radar.cross1.Thickness = 
    Radar.cross2.Color = .(,,); Radar.cross2.Thickness = 
    Radar.center.Filled = ; Radar.center.Color = Colors.RadarYou
     i = ,    d = .(); d.Filled = ; d.Visible = ; Radar.dots[i] = d 
     i = ,    c = .(); c.Filled = ; c.Color = Colors.FPV; c.Radius = ; c.NumSides = ; c.Visible = ; Radar.fpvDots[i] = c 


 Radar.()
    Radar.bg.Visible = ; Radar.circleBg.Visible = ; Radar.border.Visible = ; Radar.circleBorder.Visible = 
    Radar.center.Visible = ; Radar.cross1.Visible = ; Radar.cross2.Visible = 
     _, d  (Radar.dots)  d.Visible =  
     _, c  (Radar.fpvDots)  c.Visible =  


 Radar.(cam)
      Config.RADAR_Enabled  Radar.();  
    
     size = Config.RADAR_Size
     pos = .(cam.ViewportSize.X - size - , )
     center = pos + .(size/, size/)
    
     Config.RADAR_Circle 
        Radar.bg.Visible = ; Radar.border.Visible = 
        Radar.circleBg.Position = center; Radar.circleBg.Radius = size/; Radar.circleBg.Visible = 
        Radar.circleBorder.Position = center; Radar.circleBorder.Radius = size/; Radar.circleBorder.Visible = 
    
        Radar.circleBg.Visible = ; Radar.circleBorder.Visible = 
        Radar.bg.Position = pos; Radar.bg.Size = .(size, size); Radar.bg.Visible = 
        Radar.border.Position = pos; Radar.border.Size = .(size, size); Radar.border.Visible = 
    
    
    Radar.cross1.From = .(center.X, pos.Y + ); Radar.cross1.To = .(center.X, pos.Y + size - ); Radar.cross1.Visible = 
    Radar.cross2.From = .(pos.X + , center.Y); Radar.cross2.To = .(pos.X + size - , center.Y); Radar.cross2.Visible = 
    
     myRoot = LocalPlayer.Character  LocalPlayer.Character:()
     myLook = cam.CFrame.LookVector
      myRoot  Radar.center.Visible = ;  _, d  (Radar.dots)  d.Visible =  ;  
    
     myAngle = .(-myLook.X, -myLook.Z)
     cosA, sinA = .(myAngle), .(myAngle)
     scale = (size/ - ) / Tuning.RadarRange
     idx = 
    
     root, char  (Cache.targets) 
         idx > #Radar.dots   
         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 
                     dotPos = center + .(radarX, radarY)
                     dot = Radar.dots[idx]
                     head = char:()
                     eAngle = head  .(-head.CFrame.LookVector.X, -head.CFrame.LookVector.Z) - myAngle  
                     eFwd = .(-.(eAngle), -.(eAngle))
                     eRight = .(-eFwd.Y, eFwd.X)
                    dot.PointA = dotPos + eFwd * Tuning.RadarDotSize
                    dot.PointB = dotPos - eFwd * Tuning.RadarDotSize/ + eRight * Tuning.RadarDotSize/
                    dot.PointC = dotPos - eFwd * Tuning.RadarDotSize/ - eRight * Tuning.RadarDotSize/
                    dot.Color = isTeam  Colors.RadarTeam  Colors.RadarEnemy
                    dot.Visible = 
                    idx = idx + 
                
            
        
    
     i = idx, #Radar.dots  Radar.dots[i].Visible =  
    
     fpvIdx = 
     Config.ESP_FPV 
         _, part  (Cache.drones) 
             fpvIdx > #Radar.fpvDots   
             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 
                Radar.fpvDots[fpvIdx].Position = center + .(radarX, radarY)
                Radar.fpvDots[fpvIdx].Visible = 
                fpvIdx = fpvIdx + 
            
        
    
     i = fpvIdx, #Radar.fpvDots  Radar.fpvDots[i].Visible =  
    
    Radar.center.PointA = center + .(, -Tuning.RadarArrowSize)
    Radar.center.PointB = center + .(-Tuning.RadarArrowSize/, Tuning.RadarArrowSize/)
    Radar.center.PointC = center + .(Tuning.RadarArrowSize/, Tuning.RadarArrowSize/)
    Radar.center.Visible = 


 Aimbot = {
    aiming = ,
    locked = ,
    lockedFPV = ,
    fov = .()
}

Aimbot.fov.Thickness = ; Aimbot.fov.NumSides = ; Aimbot.fov.Filled = ; Aimbot.fov.Transparency = 

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)
     Config.AIM_Enabled  Config.AIM_ShowFOV 
        Aimbot.fov.Position = screenCenter
        Aimbot.fov.Radius = Config.AIM_FOV
        Aimbot.fov.Color = (Aimbot.aiming  Aimbot.locked)  .(,,)  .(,,)
        Aimbot.fov.Visible = 
     Aimbot.fov.Visible =  


RunService:(, .RenderPriority.Camera.Value + , ()
     Unloaded   Config.AIM_Enabled   
     rmb = UserInputService:(.UserInputType.MouseButton2)
      (Aimbot.aiming  rmb)  Aimbot.locked = ; Aimbot.lockedFPV = ;  
    
     cam = .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  ()  )
    (()  Input  Input.MouseButton1Click  Input.()  )
    (()
         vim = :()
        vim:(,,,,,); .(); vim:(,,,,,)
    )


 Trigger.()
    Trigger.active = 
     Config.TRIGGER_Enabled   Unloaded 
        (()
             cam = .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) 
        .()
    
)

 Silent.()
     cam = .CurrentCamera
      cam   ,  
     mousePos = UserInputService:()
     best, bestDist, bestRoot = , Config.SILENT_FOV, 
     root, char  (Cache.targets) 
         root  root.Parent  char 
             Config.SILENT_TeamCheck  Cache.teamStatus[root]   
             hum = char:()
              hum  hum.Health <=    
             head = char:()
             head 
                 sp, on = cam:(head.Position)
                 on  sp.Z >  
                     dist = (.(sp.X, sp.Y) - mousePos).Magnitude
                     dist < bestDist  bestDist = dist; best = head; bestRoot = root 
                
            
        
    
     best, bestRoot


 Silent.()
     Silent.hooked   
    (()
         _, tbl  (()) 
             (tbl) ==   (tbl, )  ((tbl, )) ==  
                 orig = tbl.Fire
                tbl.Fire = (plr, gun, origin, dir, ...)
                     plr == LocalPlayer  Config.SILENT_Enabled   Unloaded 
                         target = Silent.()
                         target  dir = (target.Position - origin).Unit 
                    
                     (plr, gun, origin, dir, ...)
                
                Silent.hooked = 
            
        
    )


 Silent.()
      Config.SILENT_Enabled  Silent.currentRoot = ;  
     _, root = Silent.()
    Silent.currentRoot = root


.(Silent.hook)



 Menu = {
    selected = ,
    drawings = {},
    items = {
        {name = , key = ,  = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , min = , max = , step = , parent = },
        {name = ,  = },
        {name = , key = ,  = },
        {name = , key = ,  = , min = , max = , step = , parent = },
        {name = , key = ,  = , parent = },
        {name = ,  = },
        {name = , key = ,  = },
        {name = , key = ,  = , min = , max = , step = , parent = },
        {name = , key = ,  = , min = , max = , step = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = ,  = },
        {name = , key = ,  = },
        {name = , key = ,  = , min = , max = , step = , parent = },
        {name = ,  = },
        {name = , key = ,  = },
        {name = , key = ,  = , min = , max = , step = , parent = },
        {name = , key = ,  = , parent = },
        {name = ,  = },
        {name = , key = ,  = },
        {name = , key = ,  = , min = , max = , step = , parent = },
        {name = , key = ,  = , parent = },
    },
    bg = .(),
    border = .(),
    title = .(),
    warning = {
        bg = .(), border = .(),
        title = .(), text1 = .(), text2 = .()
    }
}

Menu.bg.Position = .(,); Menu.bg.Color = Colors.MenuBg; Menu.bg.Filled = ; Menu.bg.Transparency = 
Menu.border.Position = .(,); Menu.border.Color = Colors.MenuHighlight; Menu.border.Filled = ; Menu.border.Thickness = 
Menu.title.Position = .(,); Menu.title.Text = ; Menu.title.Size = ; Menu.title.Font = .Fonts.Monospace; Menu.title.Color = .(,,); Menu.title.Outline = 

Menu.warning.bg.Filled = ; Menu.warning.bg.Color = .(,,); Menu.warning.bg.Transparency = ; Menu.warning.bg.Visible = 
Menu.warning.border.Filled = ; Menu.warning.border.Color = .(,,); Menu.warning.border.Thickness = ; Menu.warning.border.Visible = 
Menu.warning.title.Size = ; Menu.warning.title.Font = .Fonts.Monospace; Menu.warning.title.Color = .(,,); Menu.warning.title.Outline = ; Menu.warning.title.Center = ; Menu.warning.title.Text = ; Menu.warning.title.Visible = 
Menu.warning.text1.Size = ; Menu.warning.text1.Font = .Fonts.Monospace; Menu.warning.text1.Color = .(,,); Menu.warning.text1.Outline = ; Menu.warning.text1.Center = ; Menu.warning.text1.Text = ; Menu.warning.text1.Visible = 
Menu.warning.text2.Size = ; Menu.warning.text2.Font = .Fonts.Monospace; Menu.warning.text2.Color = .(,,); Menu.warning.text2.Outline = ; Menu.warning.text2.Center = ; Menu.warning.text2.Text = ; Menu.warning.text2.Visible = 

 i = , #Menu.items 
     t = .(); t.Size = ; t.Font = .Fonts.Monospace; t.Outline = 
    Menu.drawings[i] = t


 Menu.(cam)
     cx = cam.ViewportSize.X / 
     w, h = , 
    Menu.warning.bg.Position = .(cx - w/, ); Menu.warning.bg.Size = .(w, h); Menu.warning.bg.Visible = 
    Menu.warning.border.Position = .(cx - w/, ); Menu.warning.border.Size = .(w, h); Menu.warning.border.Visible = 
    Menu.warning.title.Position = .(cx, ); Menu.warning.title.Visible = 
    Menu.warning.text1.Position = .(cx, ); Menu.warning.text1.Visible = 
    Menu.warning.text2.Position = .(cx, ); Menu.warning.text2.Visible = 
    Timers.warningEnd = () + 


 Menu.()
     Timers.warningEnd >   () > Timers.warningEnd 
        Menu.warning.bg.Visible = ; Menu.warning.border.Visible = 
        Menu.warning.title.Visible = ; Menu.warning.text1.Visible = ; Menu.warning.text2.Visible = 
        Timers.warningEnd = 
    


 Menu.()
      Config.MenuOpen 
        Menu.bg.Visible = ; Menu.border.Visible = ; Menu.title.Visible = 
         _, d  (Menu.drawings)  d.Visible =  
        
    
     y, count = , 
     i, item  (Menu.items) 
         d = Menu.drawings[i]
         show =  item.parent  Config[item.parent]
         show 
            count = count + 
            d.Position = .(, y)
             item.type ==   d.Text = item.name; d.Color = .(,,)
             item.type ==  
                 on = Config[item.key]
                d.Text = (i == Menu.selected    ) .. item.name .. (on    )
                d.Color = i == Menu.selected  Colors.MenuHighlight  (on  Colors.MenuOn  Colors.MenuOff)
             item.type ==  
                d.Text = (i == Menu.selected    ) .. item.name ..  .. .(Config[item.key])
                d.Color = i == Menu.selected  Colors.MenuHighlight  Colors.MenuText
            
            d.Visible = ; y = y + 
         d.Visible =  
    
    Menu.bg.Size = .(,  + count *  + ); Menu.border.Size = .(,  + count *  + )
    Menu.bg.Visible = ; Menu.border.Visible = ; Menu.title.Visible = 


  ()
     Unloaded   
    Unloaded = 
    Config.DESYNC_Enabled = 
    Config.TRIGGER_Enabled = 
    Desync.active = 
    Trigger.active = 
    (() RunService:() )
     _, c  (Connections)  (() c:() ) 
     _, esp  (ESP.cache)  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()