Source ESPS AIM TRIGGER RADAR AND MORE

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

 Config = {
    ESP_Enabled = ,
    ESP_Boxes = ,
    ESP_Names = ,
    ESP_Distance = ,
    ESP_Skeleton = ,
    ESP_Weapons = ,
    ESP_MaxDist = ,
    ESP_Offscreen = ,
    ESP_AimDir = ,
    ESP_LookingAtYou = ,
    ESP_Tracers = ,
    ESP_Velocity = ,
    ESP_Shield = ,
    RADAR_Enabled = ,
    RADAR_Size = ,
    RADAR_Circle = ,
    AIM_Enabled = ,
    AIM_FOV = ,
    AIM_Smooth = ,
    AIM_ShowFOV = ,
    AIM_WallCheck = ,
    AIM_IgnoreShielded = ,
    AIM_IgnoreLobby = ,
    TRIGGER_Enabled = ,
    TRIGGER_Delay = ,
    RAGE_Enabled = ,
    RAGE_PrioVisible = ,
    RAGE_PrioThreat = ,
    RAGE_AutoShoot = ,
    MISC_WalkSpeed = ,
    MISC_FOV = ,
    MISC_FullBright = ,
    MISC_NoFog = ,
    MISC_AutoRespawn = ,
    MenuOpen = 
}

 Tuning = {
    VisibilityRefreshRate = ,
    WeaponRefreshRate = ,
    ShieldDuration = ,
    
    BoxWidthRatio = ,
    NameOffset = ,
    DistOffset = ,
    WeaponOffset = ,
    LookingOffset = ,
    ShieldOffset = ,
    
    OffscreenEdgeDist = ,
    OffscreenArrowSize = ,
    AimLineLength = ,
    LookingThreshold = ,
    
    RadarRange = ,
    RadarDotSize = ,
    RadarArrowSize = ,
    TriggerRadius = ,
    
    RageShootDelay = ,
    RageDistWeight = ,
    RageVisibleWeight = ,
    RageThreatWeight = ,
    RageMaxDist = 
}

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

 R6Bones = {
    {, },
    {, },
    {, },
    {, },
    {, }
}

 Colors = {
    Enemy = .(, , ),
    EnemyVisible = .(, , ),
    Lobby = .(, , ),
    Shielded = .(, , ),
    Skeleton = .(, , ),
    SkeletonVisible = .(, , ),
    LookingAtYou = .(, , ),
    AimDir = .(, , ),
    Weapon = .(, , ),
    Tracer = .(, , ),
    RadarBg = .(, , ),
    RadarBorder = .(, , ),
    RadarYou = .(, , ),
    RadarEnemy = .(, , ),
    MenuBg = .(, , ),
    MenuHighlight = .(, , ),
    MenuOn = .(, , ),
    MenuOff = .(, , ),
    MenuText = .(, , )
}

 Timers = {
    lastVisRefresh = ,
    lastWeaponRefresh = ,
    warningEnd = 
}

 Cache = {
    visibility = {},
    weapons = {},
    shields = {}
}

 OriginalLighting = {
    Brightness = .Lighting.Brightness,
    Ambient = .Lighting.Ambient,
    OutdoorAmbient = .Lighting.OutdoorAmbient,
    FogEnd = .Lighting.FogEnd,
    FogStart = .Lighting.FogStart
}

 Connections = {}
 Unloaded = 

 Team = {}

 Team.(char)
     _, p  (Players:()) 
         p.Character == char   p 
    
     


 Team.(char)
     player = Team.(char)
      player   LocalPlayer.Team   player.Team    
     player.Team == LocalPlayer.Team


 Team.(char)
     player = Team.(char)
      player   player.Team    
     player.Team.Name == 


 Team.(char)
     Cache.shields[char]  () < Cache.shields[char]


 Team.(char)
    Cache.shields[char] = () + Tuning.ShieldDuration


 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)
     tool = char:()
     tool   tool.Name 
     


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


 Util.(char)
     char:() ~= 


 Targets = {}

 Targets.()
     count = 
     _, player  (Players:()) 
         player ~= LocalPlayer  player.Character 
            count = count + 
             count >  
                Cache.visibility[player] = 
            
                Cache.visibility[player] = Util.(player.Character)
            
        
    


 Targets.()
     _, player  (Players:()) 
         player ~= LocalPlayer  player.Character 
            Cache.weapons[player] = Util.(player.Character)
        
    


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

 ESP.()
     skel = {}
     i = ,  
        skel[i] = .()
    
     {
        Box = {.(), .(), .(), .()},
        Name = .(),
        Dist = .(),
        Weapon = .(),
        Skel = skel,
        Offscreen = .(),
        AimLine = .(),
        LookingText = .(),
        ShieldText = .(),
        Tracer = .(),
        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 = 
     _, 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.ShieldText.Size = 
    esp.ShieldText.Font = .Fonts.Monospace
    esp.ShieldText.Center = 
    esp.ShieldText.Outline = 
    esp.ShieldText.Color = Colors.Shielded
    esp.Tracer.Thickness = 
    esp.Tracer.Color = Colors.Tracer
    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 = 
     _, l  (esp.Skel)  l.Visible =  
    esp.Offscreen.Visible = 
    esp.AimLine.Visible = 
    esp.LookingText.Visible = 
    esp.ShieldText.Visible = 
    esp.Tracer.Visible = 
    esp.VelLine.Visible = 
    esp.VelArrow.Visible = 


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


 ESP.()
     validPlayers = {}
     _, p  (Players:()) 
        validPlayers[p] = 
    
     player, esp  (ESP.cache) 
          validPlayers[player] 
            ESP.(esp)
            ESP.(esp)
            ESP.cache[player] = 
            ESP.velocityData[player] = 
        
    


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


 ESP.(cam, screenSize, screenCenter)
      Config.ESP_Enabled 
        ESP.()
        
    
    
    ESP.()
    
     _, player  (Players:()) 
         player == LocalPlayer   
        
         char = player.Character
          char   char:() 
             ESP.cache[player]  ESP.(ESP.cache[player]) 
        
             root = char:()
            
              ESP.cache[player] 
                ESP.cache[player] = ESP.()
                ESP.(ESP.cache[player])
            
             esp = ESP.cache[player]
            
             myChar = LocalPlayer.Character
             myRoot = myChar  myChar:()
             dist = myRoot  (root.Position - myRoot.Position).Magnitude  
             isLobby = player.Team  player.Team.Name == 
            
             dist > Config.ESP_MaxDist 
                ESP.(esp)
            
                ESP.(esp, player, char, root, , cam, screenSize, screenCenter, dist, , isLobby)
            
        
    


 ESP.(esp, player, char, root, hum, cam, screenSize, screenCenter, dist, isTeam, isLobby)
     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 > 
     visible = Cache.visibility[player]  
     shielded = Team.(char)
    
     col
     shielded  Config.ESP_Shield 
        col = Colors.Shielded
     isLobby 
        col = Colors.Lobby
    
        col = visible  Colors.EnemyVisible  Colors.Enemy
    
    
     skelCol = visible  Colors.SkeletonVisible  Colors.Skeleton
     lookingAtYou = visible  Util.(char)  
    
      onScreen 
        ESP.(esp)
         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 = 
     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 = player.Name
        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[player]
         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_Skeleton 
         bones = Util.(char)  R6Bones  Bones
         i, b  (bones) 
             esp.Skel[i] 
                 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 = 
                
            
        
         i = #bones + , #esp.Skel 
             esp.Skel[i]  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_Shield  shielded 
         remaining = Cache.shields[char] - ()
        esp.ShieldText.Text =  .. .(, .(, remaining)) .. 
        esp.ShieldText.Position = .(cx, hs.Y - Tuning.ShieldOffset)
        esp.ShieldText.Visible = 
    
        esp.ShieldText.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 = 
    
    
     vd = ESP.velocityData[player]
      vd 
        vd = {pos = root.Position, vel = .zero, time = ()}
        ESP.velocityData[player] = 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 
         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 = 
    


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


    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
    


 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 =  


 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 = 
    
     myChar = LocalPlayer.Character
     myRoot = myChar  myChar:()
     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 = 
    
     _, player  (Players:()) 
         player == LocalPlayer   
         idx > #Radar.dots   
         char = player.Character
         char 
             root = char:()
             root 
                 isLobby = player.Team  player.Team.Name == 
                 isShielded = Team.(char)
                 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 = isLobby  Colors.Lobby  (isShielded  Colors.Shielded  Colors.RadarEnemy)
                    dot.Visible = 
                    idx = idx + 
                
            
        
    
    
     i = idx, #Radar.dots  Radar.dots[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 = ,
    fov = .()
}

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

Connections.mb2down = Mouse.Button2Down:(()
    Aimbot.aiming = 
    Aimbot.locked = 
)

Connections.mb2up = Mouse.Button2Up:(()
    Aimbot.aiming = 
    Aimbot.locked = 
)

 Aimbot.(cam)
     center = .(cam.ViewportSize.X/, cam.ViewportSize.Y/)
     myChar = LocalPlayer.Character
     myRoot = myChar  myChar:()
      myRoot    
    
     best, bestDist = , .huge
    
     _, player  (Players:()) 
         player == LocalPlayer   
         char = player.Character
         char 
             root = char:()
             root 
                 isLobby = player.Team  player.Team.Name == 
                 shielded = Team.(char)
                
                 Config.AIM_IgnoreLobby  isLobby   
                 Config.AIM_IgnoreShielded  shielded   
                 Config.AIM_WallCheck   Cache.visibility[player]   
                
                 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
                            
                        
                    
                
            
        
    
    
     best


 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 = 
        
    
    
     cam = .CurrentCamera
      cam   
    
      Aimbot.locked   Aimbot.locked.Parent   Aimbot.locked:() 
        Aimbot.locked = Aimbot.(cam)
    
    
      Aimbot.locked   
    
     head = Aimbot.locked:()
     hum = Aimbot.locked:()
      head   hum  hum.Health <=  
        Aimbot.locked = 
        
    
    
     goal = .(cam.CFrame.Position, head.Position)
     newCF
     Config.AIM_Smooth <=  
        newCF = goal
    
         alpha = .( - (Config.AIM_Smooth/)*, , )
        newCF = cam.CFrame:(goal, alpha)
    
    cam.CFrame = newCF
)

 Trigger = {
    active = ,
    lastShot = 
}

 Trigger.(cam)
     center = .(cam.ViewportSize.X/, cam.ViewportSize.Y/)
     _, player  (Players:()) 
         player == LocalPlayer   
         char = player.Character
          char   
         isLobby = player.Team  player.Team.Name == 
         shielded = Team.(char)
         isLobby  shielded   
         visible = Cache.visibility[player]
          visible   
         _, pn  ({, , }) 
             p = char:(pn)
             p 
                 sp, on = cam:(p.Position)
                 on  sp.Z >   (.(sp.X, sp.Y) - center).Magnitude < Tuning.TriggerRadius 
                     
                
            
        
    
     


 Trigger.()
    (()
         mouse1click 
            ()
        
    )
    (()
         mousebuttonclick 
            ()
        
    )
    (()
         click 
            ()
        
    )


 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)
        
        .()
    
)

 Rage = {
    active = ,
    currentTarget = ,
    lastShot = ,
    indicator = .()
}

Rage.indicator.Size = 
Rage.indicator.Font = .Fonts.Monospace
Rage.indicator.Center = 
Rage.indicator.Outline = 
Rage.indicator.Color = .(, , )
Rage.indicator.Text = 
Rage.indicator.Visible = 

 Rage.(player, myRoot, cam)
     char = player.Character
      char   - 
    
     root = char:()
      root   - 
    
     hum = char:()
     hum  hum.Health <=    - 
    
     isLobby = player.Team  player.Team.Name == 
     isLobby   - 
    
     shielded = Team.(char)
     shielded   - 
    
     dist = (root.Position - myRoot.Position).Magnitude
     dist > Tuning.RageMaxDist   - 
    
     score = 
    
    score = score - (dist / Tuning.RageMaxDist) * Tuning.RageDistWeight
    
     visible = Cache.visibility[player]
     visible  Config.RAGE_PrioVisible 
        score = score + Tuning.RageVisibleWeight
    
    
     Config.RAGE_PrioThreat 
         head = char:()
         head  myRoot 
             myHead = LocalPlayer.Character  LocalPlayer.Character:()
             myHead 
                 toYou = (myHead.Position - head.Position).Unit
                 lookDot = toYou:(head.CFrame.LookVector)
                 lookDot >  
                    score = score + Tuning.RageThreatWeight * lookDot
                
            
        
    
    
     score


 Rage.(cam)
     myChar = LocalPlayer.Character
     myRoot = myChar  myChar:()
      myRoot    
    
     best, bestScore = , -
    
     _, player  (Players:()) 
         player == LocalPlayer   
         score = Rage.(player, myRoot, cam)
         score > bestScore 
            bestScore = score
            best = player.Character
        
    
    
     best


 Rage.(target, cam)
      target   
    
     head = target:()
      head   
    
     goal = .(cam.CFrame.Position, head.Position)
    cam.CFrame = goal


 Rage.()
    (()
         mouse1click  () 
    )
    (()
         mousebuttonclick  () 
    )
    (()
         click  () 
    )


 Rage.()
    Rage.active = 
     Config.RAGE_Enabled   Unloaded 
        (()
             cam = .CurrentCamera
              cam   
            
             target = Rage.(cam)
            
             target  target ~= Rage.currentTarget 
                Rage.currentTarget = target
            
            
              Rage.currentTarget   Rage.currentTarget.Parent 
                Rage.currentTarget = target
            
            
             Rage.currentTarget 
                 hum = Rage.currentTarget:()
                 hum  hum.Health <=  
                    Rage.currentTarget = target
                
                
                 Team.(Rage.currentTarget) 
                    Rage.currentTarget = target
                
            
            
             Rage.currentTarget 
                Rage.(Rage.currentTarget, cam)
                
                 Config.RAGE_AutoShoot 
                     now = () * 
                     now - Rage.lastShot >= Tuning.RageShootDelay 
                         visible = 
                         _, p  (Players:()) 
                             p.Character == Rage.currentTarget 
                                visible = Cache.visibility[p]
                                
                            
                        
                         visible 
                            Rage.()
                            Rage.lastShot = now
                        
                    
                
            
        )
        .()
    
    Rage.active = 
    Rage.currentTarget = 
    Rage.indicator.Visible = 


 Rage.(cam, screenCenter)
     Config.RAGE_Enabled 
        Rage.indicator.Position = .(screenCenter.X, )
        Rage.indicator.Visible = 
        
         Rage.currentTarget 
             name = 
             _, p  (Players:()) 
                 p.Character == Rage.currentTarget 
                    name = p.Name
                    
                
            
            Rage.indicator.Text =  .. name
        
            Rage.indicator.Text = 
        
    
        Rage.indicator.Visible = 
    


.(()
      Unloaded 
         Config.RAGE_Enabled   Rage.active 
            .(Rage.run)
        
        .()
    
)

 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 = ,  = , 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 = , key = ,  = , parent = },
        {name = ,  = },
        {name = , key = ,  = },
        {name = , key = ,  = , min = , max = , step = , parent = },
        {name = ,  = },
        {name = , key = ,  = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = , key = ,  = , parent = },
        {name = ,  = },
        {name = ,  = },
        {name = , key = ,  = , min = , max = , step = },
        {name = , key = ,  = , min = , max = , step = },
        {name = , key = ,  = },
        {name = , key = ,  = },
        {name = , key = ,  = }
    },
    bg = .(),
    border = .(),
    title = .(),
    stats = .(),
    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.stats.Size = 
Menu.stats.Font = .Fonts.Monospace
Menu.stats.Color = .(, , )
Menu.stats.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 = 
        Menu.stats.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 ==  
                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 = 
        
    
    
     statsY = y + 
     ping = 
    (()
        ping = .(Stats.Network.ServerStatsItem[]:())
    )
     health = 
     LocalPlayer.Character  LocalPlayer.Character:() 
        health = .(LocalPlayer.Character:().Health)
    
    Menu.stats.Text =  .. health ..  .. ping .. 
    Menu.stats.Position = .(, statsY)
    Menu.stats.Visible = 
    
    Menu.bg.Size = .(, statsY -  + )
    Menu.border.Size = .(, statsY -  + )
    Menu.bg.Visible = 
    Menu.border.Visible = 
    Menu.title.Visible = 


  ()
     LocalPlayer.Character 
         humanoid = LocalPlayer.Character:()
         humanoid 
            humanoid.WalkSpeed = Config.MISC_WalkSpeed
        
    
    
    .CurrentCamera.FieldOfView = Config.MISC_FOV
    
     Config.MISC_FullBright 
        .Lighting.Brightness = 
        .Lighting.Ambient = .(, , )
        .Lighting.OutdoorAmbient = .(, , )
    
        .Lighting.Brightness = OriginalLighting.Brightness
        .Lighting.Ambient = OriginalLighting.Ambient
        .Lighting.OutdoorAmbient = OriginalLighting.OutdoorAmbient
    
    
     Config.MISC_NoFog 
        .Lighting.FogEnd = 
        .Lighting.FogStart = 
    
        .Lighting.FogEnd = OriginalLighting.FogEnd
        .Lighting.FogStart = OriginalLighting.FogStart
    


 autoRespawnLastFire = 

  ()
      Config.MISC_AutoRespawn   
      :(LocalPlayer.Name) 
         () - autoRespawnLastFire >=  
             remotes = ReplicatedStorage:()
             remotes  remotes:() 
                remotes.Command:()
            
            autoRespawnLastFire = ()
        
    


  ()
     Unloaded   
    Unloaded = 
    Config.TRIGGER_Enabled = 
    Config.RAGE_Enabled = 
    Trigger.active = 
    Rage.active = 
    
    (() RunService:() )
    
     _, c  (Connections) 
        (() c:() )
    
    
     _, esp  (ESP.cache)  ESP.(esp) 
    
    Radar.bg:()
    Radar.circleBg:()
    Radar.border:()
    Radar.circleBorder:()
    Radar.cross1:()
    Radar.cross2:()
    Radar.center:()
     _, d  (Radar.dots)  d:() 
    
    Aimbot.fov:()
    Rage.indicator:()
    
    Menu.bg:()
    Menu.border:()
    Menu.title:()
    Menu.stats:()
     _, d  (Menu.drawings)  d:() 
    Menu.warning.bg:()
    Menu.warning.border:()
    Menu.warning.title:()
    Menu.warning.text1:()
    Menu.warning.text2:()
    
    .Lighting.Brightness = OriginalLighting.Brightness
    .Lighting.Ambient = OriginalLighting.Ambient
    .Lighting.OutdoorAmbient = OriginalLighting.OutdoorAmbient
    .Lighting.FogEnd = OriginalLighting.FogEnd
    .Lighting.FogStart = OriginalLighting.FogStart


Connections.input = UserInputService.InputBegan:((input, gp)
     input.KeyCode == .KeyCode.Home 
        ()
        
    
     input.KeyCode == .KeyCode.Insert   gp 
        Config.MenuOpen =  Config.MenuOpen
        
    
      Config.MenuOpen   
    
     input.KeyCode == .KeyCode.Up 
        
            Menu.selected = Menu.selected - 
             Menu.selected <   Menu.selected = #Menu.items 
         Menu.items[Menu.selected].type ~=   Menu.items[Menu.selected].type ~=   ( Menu.items[Menu.selected].parent  Config[Menu.items[Menu.selected].parent])
     input.KeyCode == .KeyCode.Down 
        
            Menu.selected = Menu.selected + 
             Menu.selected > #Menu.items  Menu.selected =  
         Menu.items[Menu.selected].type ~=   Menu.items[Menu.selected].type ~=   ( Menu.items[Menu.selected].parent  Config[Menu.items[Menu.selected].parent])
     input.KeyCode == .KeyCode.Left  input.KeyCode == .KeyCode.Right 
         item = Menu.items[Menu.selected]
         item  item.type ==  
            Config[item.key] =  Config[item.key]
             item.key ==   Config.AIM_Enabled 
                Menu.(.CurrentCamera)
            
             item.key ==   Config.RAGE_Enabled 
                Menu.warning.text1.Text = 
                Menu.warning.text2.Text = 
                Menu.(.CurrentCamera)
            
         item  item.type ==  
             input.KeyCode == .KeyCode.Left 
                Config[item.key] = .(item.min, Config[item.key] - item.step)
            
                Config[item.key] = .(item.max, Config[item.key] + item.step)
            
        
    
)

Connections.playerAdded = Players.PlayerAdded:((player)
    player.CharacterAdded:((char)
        Team.(char)
    )
)

Connections.playerRemoving = Players.PlayerRemoving:((player)
    Cache.visibility[player] = 
    Cache.weapons[player] = 
     player.Character 
        Cache.shields[player.Character] = 
    
     ESP.cache[player] 
        ESP.(ESP.cache[player])
        ESP.(ESP.cache[player])
        ESP.cache[player] = 
        ESP.velocityData[player] = 
    
)

 _, player  (Players:()) 
     player ~= LocalPlayer 
        player.CharacterAdded:((char)
            Team.(char)
        )
    


Connections.render = RunService.RenderStepped:(()
     Unloaded   
     cam = .CurrentCamera
      cam   
    
     screenSize = cam.ViewportSize
     screenCenter = .(screenSize.X/, screenSize.Y/)
     now = ()
    
     now - Timers.lastVisRefresh > Tuning.VisibilityRefreshRate 
        Timers.lastVisRefresh = now
        Targets.()
    
    
     now - Timers.lastWeaponRefresh > Tuning.WeaponRefreshRate 
        Timers.lastWeaponRefresh = now
        Targets.()
    
    
    ()
    ()
    
    ESP.(cam, screenSize, screenCenter)
    Radar.(cam)
    Aimbot.(cam, screenCenter)
    Rage.(cam, screenCenter)
    Menu.()
    Menu.()
)

Menu.()