OG OP SOURCE CODE SILENT AIM LOBBY DESTROYER ESP AIMBOT HUD

 Players = :()
 RunService = :()
 UserInputService = :()
 Teams = :()

 LocalPlayer = Players.LocalPlayer
 camera = .CurrentCamera

 mousemoverel = mousemoverel  (Input  Input.MouseMove)  

 Config = {
    ESP_Enabled = ,
    ESP_Box = ,
    ESP_Name = ,
    ESP_Distance = ,
    ESP_Tracer = ,
    ESP_Rainbow = ,
    ESP_TeamCheck = ,
    
    AIM_Enabled = ,
    AIM_FOVEnabled = ,
    AIM_FOV = ,
    AIM_Smooth = ,
    
    SILENT_Enabled = ,
    SILENT_FOV = ,
    SILENT_TeamCheck = ,
    SILENT_Rage = ,
    
    RADAR_Enabled = ,
    RADAR_Mode = ,
    RADAR_Size = ,
    RADAR_Range = ,
    RADAR_MoveMode = ,
    
    MISC_Watermark = ,
    MISC_ActiveList = 
}

 Tuning = {
    FOVSegments = ,
    
    PanelWidth = ,
    PanelHeaderH = ,
    ItemHeight = ,
    FontSize = ,
    SliderHeight = ,
    
    RadarDotSize = ,
    RadarArrowSize = ,
    
    CompassWidth = ,
    CompassHeight = ,
    CompassTickHeight = ,
    CompassIndicatorSize = 
}

 Palette = {
    PanelBg = .(, , ),
    PanelHeader = .(, , ),
    PanelBorder = .(, , ),
    ItemOn = .(, , ),
    ItemOff = .(, , ),
    ItemHover = .(, , ),
    Text = .(, , ),
    TextDim = .(, , ),
    Accent = .(, , ),
    
    ESP_Enemy = .(, , ),
    ESP_Visible = .(, , ),
    
    FOV_Circle = .(, , ),
    FOV_Active = .(, , ),
    
    RadarBg = .(, , ),
    RadarBorder = .(, , ),
    RadarGrid = .(, , ),
    RadarYou = .(, , ),
    RadarEnemy = .(, , ),
    
    CompassBg = .(, , ),
    CompassText = .(, , ),
    CompassCardinal = .(, , ),
    CompassTick = .(, , ),
    CompassEnemy = .(, , )
}

 State = {
    Unloaded = ,
    RainbowHue = ,
    Aiming = ,
    
    Radar2D_Pos = ,
    RadarHUD_Pos = ,
    RadarDragging = ,
    RadarDragOffset = .(, )
}

 Cache = {
    Teams = {},
    TeamUpdateTime = ,
    Visibility = {},
    VisUpdateTime = ,
    CharactersFolder = ,
    LocalChar = ,
    LocalCharTime = 
}

 CacheIntervals = {
    Team = ,
    Visibility = ,
    LocalChar = 
}

 Connections = {}
 espObjects = {}
 targetEnemy = 

  (player)
      player    
     :() 
         vo = .VoiceOrigins
         vo:()  vo.ORANGE:(player.Name) 
             Teams:()  
         vo:()  vo.BLUE:(player.Name) 
             Teams:()  
        
    
     


  (player)
      player    
     now = ()
     now - Cache.TeamUpdateTime > CacheIntervals.Team 
        Cache.Teams = {}
        Cache.TeamUpdateTime = now
    
     Cache.Teams[player] ==  
        Cache.Teams[player] = (player)  
    
     result = Cache.Teams[player]
     result ~=   result  


  ()
      Cache.CharactersFolder 
        Cache.CharactersFolder = :()
    
     Cache.CharactersFolder


  ()
     now = ()
     now - Cache.LocalCharTime > CacheIntervals.LocalChar   Cache.LocalChar   Cache.LocalChar.Parent 
         chars = ()
        Cache.LocalChar = chars  chars:(LocalPlayer.Name)
        Cache.LocalCharTime = now
    
     Cache.LocalChar


  (character)
     parts = {, , , , , }
     _, name  (parts) 
         part = character:(name)
         part   part 
    
     _, part  (character:()) 
         part:()   part 
    
     


  (targetPart)
     localChar = ()
      localChar   targetPart    
     localPart = (localChar)
      localPart    
    
     targetChar = targetPart:()
    
     origin = localPart.Position
     direction = (targetPart.Position - origin)
     params = RaycastParams.()
    params.FilterDescendantsInstances = {localChar, targetChar}
    params.FilterType = .RaycastFilterType.Blacklist
    
     result = :(origin, direction, params)
     result == 


  (targetPart)
      targetPart    
     now = ()
     now - Cache.VisUpdateTime > CacheIntervals.Visibility 
        Cache.Visibility = {}
        Cache.VisUpdateTime = now
    
     Cache.Visibility[targetPart] ==  
        Cache.Visibility[targetPart] = (targetPart)
    
     Cache.Visibility[targetPart]


  (pos)
     char = ()
      char    
     root = (char)
      root    
     (pos - root.Position).Magnitude


  ()
     .(State.RainbowHue, , )


  ()
    camera = .CurrentCamera
      camera    
    
     localTeam = (LocalPlayer)
     closestPos = 
     closestDist = Config.AIM_FOVEnabled  Config.AIM_FOV  .huge
     mousePos = UserInputService:()
     charsFolder = ()
    
     _, player  (Players:()) 
         player == LocalPlayer   
        
         character = charsFolder  charsFolder:(player.Name)
          character   
        
         playerTeam = (player)
        
         isEnemy = 
         Config.ESP_TeamCheck  localTeam  playerTeam 
            isEnemy = localTeam ~= playerTeam
        
        
         isEnemy 
             part = (character)
             part 
                 screenPos, onScreen = camera:(part.Position)
                 onScreen 
                     screenVec = .(screenPos.X, screenPos.Y)
                     dist = (mousePos - screenVec).Magnitude
                     dist < closestDist 
                        closestDist = dist
                        closestPos = screenVec
                        targetEnemy = part
                    
                
            
        
    
    
     closestPos


  ()
    camera = .CurrentCamera
      camera   
    
      Config.AIM_Enabled   State.Aiming 
        targetEnemy = 
        
    
    
     mousePos = UserInputService:()
     aimPos = 
    
     targetEnemy  targetEnemy.Parent 
         screenPos, onScreen = camera:(targetEnemy.Position)
         onScreen 
            aimPos = .(screenPos.X, screenPos.Y)
        
            targetEnemy = 
        
    
    
      aimPos 
        aimPos = ()
    
    
      aimPos   
    
     deltaX = (aimPos.X - mousePos.X) / Config.AIM_Smooth
     deltaY = (aimPos.Y - mousePos.Y) / Config.AIM_Smooth
    
     mousemoverel 
        (deltaX, deltaY)
    
         currentCFrame = camera.CFrame
         worldPos = camera:(aimPos.X, aimPos.Y).Origin
         goalCFrame = .(currentCFrame.Position, worldPos)
        camera.CFrame = currentCFrame:(goalCFrame, )
    


 Silent = {
    Hooked = ,
    CurrentTarget = ,
    FOVCircle = ,
    Remote = 
}

  ()
    camera = .CurrentCamera
      camera    
    
     mousePos = UserInputService:()
     localTeam = (LocalPlayer)
     charsFolder = ()
     collisions = :()
     bestTarget = 
     bestDist = Config.SILENT_FOV
    
     _, player  (Players:()) 
         player == LocalPlayer   
        
         character = charsFolder  charsFolder:(player.Name)
          character   
        
         playerTeam = (player)
        
         isEnemy = 
         Config.SILENT_TeamCheck  localTeam  playerTeam 
            isEnemy = localTeam ~= playerTeam
        
        
          isEnemy   
        
         targetPart = 
         hitPartName = 
        
         collisions 
             playerHitbox = collisions:(player.Name)
             playerHitbox 
                targetPart = playerHitbox:() 
                     playerHitbox:()
                     playerHitbox:()
                     playerHitbox:()
                 targetPart 
                    hitPartName = targetPart.Name
                
            
        
        
          targetPart 
            targetPart = character:() 
                 character:()
                 character:()
                 character:()
            hitPartName = 
        
        
          targetPart   
        
         screenPos, onScreen = camera:(targetPart.Position)
          onScreen  screenPos.Z <=    
        
         screenVec = .(screenPos.X, screenPos.Y)
         dist = (mousePos - screenVec).Magnitude
        
         dist < bestDist 
            bestDist = dist
            bestTarget = {
                Player = player,
                Character = character,
                Head = targetPart,
                Position = targetPart.Position,
                HitPartName = hitPartName
            }
        
    
    
    Silent.CurrentTarget = bestTarget
     bestTarget


  (origin)
     target = ()
      target    
     (target.Position - origin).Unit


  ()
     Silent.Hooked   
    
    Silent.FOVCircle = .()
    Silent.FOVCircle.Thickness = 
    Silent.FOVCircle.NumSides = 
    Silent.FOVCircle.Filled = 
    Silent.FOVCircle.Color = .(, , )
    Silent.FOVCircle.Visible = 
    
     Remotes = :():()
     Remotes 
        Silent.Remote = Remotes:()[]
    
    
     getgc 
        (()
             _, v  (()) 
                 (v) ==  
                     fireUnsafe = (v, )
                     fireUnsafe  (fireUnsafe) ==  
                         oldFire = v.fireServerUnsafe
                        v.fireServerUnsafe = (eventName, data, ...)
                             Config.SILENT_Enabled   State.Unloaded 
                                 eventName ==   (data) ==   data.direction 
                                     cam = .CurrentCamera
                                     cam 
                                         newDir = (cam.CFrame.Position)
                                         newDir 
                                            data.direction = newDir
                                        
                                    
                                
                            
                             (eventName, data, ...)
                        
                        Silent.Hooked = 
                    
                    
                     newFunc = (v, )
                     newFunc  (newFunc) ==    Silent.Hooked 
                         info = debug.getinfo  debug.(newFunc)
                         info 
                             src = info.source  
                             src:()  src:() 
                                 oldNew = v.new
                                v.new = (params, ...)
                                     Config.SILENT_Enabled   State.Unloaded  params  (params) ==  
                                         params.direction  params.position  params.damaging 
                                             newDir = (params.position)
                                             newDir 
                                                params.direction = newDir
                                            
                                        
                                    
                                     (params, ...)
                                
                                Silent.Hooked = 
                            
                        
                    
                
            
        )
    
    
      Silent.Hooked    getnamecallmethod 
        (()
             oldNamecall
            oldNamecall = (, , (self, ...)
                 args = {...}
                 method = ()
                
                  State.Unloaded  Config.SILENT_Enabled 
                     method ==   Silent.Remote  self == Silent.Remote 
                         args[] ==   (args[]) ==   args[].direction 
                             cam = .CurrentCamera
                             cam 
                                 newDir = (cam.CFrame.Position)
                                 newDir 
                                    args[].direction = newDir
                                
                            
                             (self, (args))
                        
                    
                    
                     method ==   self ==  
                         origin = args[]
                         direction = args[]
                         origin  direction 
                             target = ()
                             target 
                                 newDir = (target.Position - origin).Unit * direction.Magnitude
                                 (self, origin, newDir, args[])
                            
                        
                    
                
                
                 (self, ...)
            )
            Silent.Hooked = 
        )
    
    
      Silent.Hooked   
        (()
             oldRaycast = .Raycast
             newRaycast = (self, origin, direction, params, ...)
                 Config.SILENT_Enabled   State.Unloaded  origin  direction 
                     target = ()
                     target 
                         newDir = (target.Position - origin).Unit * direction.Magnitude
                         (self, origin, newDir, params, ...)
                    
                
                 (self, origin, direction, params, ...)
            
            (.Raycast, newRaycast)
            Silent.Hooked = 
        )
    


  ()
      Silent.FOVCircle   
    
     Config.SILENT_Enabled 
         mousePos = UserInputService:()
        Silent.FOVCircle.Position = mousePos
        Silent.FOVCircle.Radius = Config.SILENT_FOV
        Silent.FOVCircle.Color = Silent.CurrentTarget  .(, , )  .(, , )
        Silent.FOVCircle.Visible = 
    
        Silent.FOVCircle.Visible = 
    


 WeaponList = {
    , , , , , , , , 
    , , , , , , , , 
    , , , , , , 
}

  ()
     myChar = ()
      myChar   , ,  
    
     loadoutData = myChar:()
     loadoutData 
         _, child  (loadoutData:()) 
             child:()  child:() 
                 val = (child.Value  child.Name)
                 _, wep  (WeaponList) 
                     val:():(wep:()) 
                          .. wep, , 
                    
                
            
        
    
    
     weaponRigs = :()
     weaponRigs 
         myRig = weaponRigs:(LocalPlayer.Name)
         myRig 
             _, child  (myRig:()) 
                 name = child.Name:()
                 _, wep  (WeaponList) 
                     name:(wep:()) 
                          .. wep, , 
                    
                
            
        
    
    
     cam = .CurrentCamera
     cam 
         viewModel = cam:()
         viewModel 
             _, child  (viewModel:()) 
                 name = child.Name:()
                 _, wep  (WeaponList) 
                     name:(wep:()) 
                          .. wep, , 
                    
                
            
        
    
    
     , , 


Silent.LastShotTime = 
Silent.RaycastHooked = 

  ()
     target = ()
      target   target.Player   target.Character    
    
    Cache.LocalChar = 
    Cache.LocalCharTime = 
    
     charsFolder = :()
      charsFolder    
    
     myChar = charsFolder:(LocalPlayer.Name)
      myChar   myChar.Parent    
    
     cam = .CurrentCamera
      cam    
    
     charIdValue = target.Character:()
     myCharIdValue = myChar:()
      charIdValue   myCharIdValue    
    
     Remotes = :():()
      Remotes    
     Remote = Remotes:()[]
      Remote    
    
     weapon, slot, silenced = ()
     hitPart = target.HitPartName  
     direction = (target.Position - cam.CFrame.Position).Unit
     impactCFrame = .(target.Position, target.Position + direction)
    
    (()
        Remote:(, {
            hitPartName = hitPart,
            raycastPos = target.Position,
            characterId = charIdValue.Value,
            ownCharacterId = myCharIdValue.Value,
            camPos = cam.CFrame.Position,
            damagePlayer = target.Player,
            silenced = silenced,
            scoped = ,
            weaponEquipSlot = slot,
            weapon = weapon
        })
    )
    
    (()
        Remote:(, {
            direction = direction,
            hitMaterial = ,
            impactCFrame = impactCFrame
        })
    )
    
    (()
         ctc = :():()
         ctc 
             hm = ctc:()
             hm  hm:() 
        
    )
    
     


Silent.IsShooting = 

  ()
     Silent.RaycastHooked   
         getnamecallmethod   
    
    (()
         oldNamecall
        oldNamecall = (, , (self, ...)
             method = ()
            
             method ==   self ==  
                 Config.SILENT_Enabled   Config.SILENT_Rage   State.Unloaded  Silent.IsShooting 
                     args = {...}
                     origin = args[]
                     direction = args[]
                    
                     origin  direction 
                         cam = .CurrentCamera
                         cam 
                             camPos = cam.CFrame.Position
                             distFromCam = (origin - camPos).Magnitude
                            
                             distFromCam <  
                                 now = ()
                                 now - Silent.LastShotTime >  
                                    Silent.LastShotTime = now
                                    .(InjectSilentDamage)
                                
                            
                        
                    
                
            
            
             (self, ...)
        )
        Silent.RaycastHooked = 
    )


  ()
     cam = .CurrentCamera
      cam   
    
     charsFolder = :()
      charsFolder   
    
     myChar = charsFolder:(LocalPlayer.Name)
      myChar   myChar.Parent   
    
     myCharIdValue = myChar:()
      myCharIdValue   
    
     localTeam = (LocalPlayer)
     collisions = :()
    
     Remotes = :():()
      Remotes   
     Remote = Remotes:()[]
      Remote   
    
     weapon, slot, silenced = ()
    
     _, player  (Players:()) 
         player == LocalPlayer   
        
         playerTeam = (player)
         isEnemy = 
         Config.SILENT_TeamCheck  localTeam  playerTeam 
            isEnemy = localTeam ~= playerTeam
        
          isEnemy   
        
         character = charsFolder:(player.Name)
          character   
        
         charIdValue = character:()
          charIdValue   
        
         hitPart, hitPartName = , 
         collisions 
             playerHitbox = collisions:(player.Name)
             playerHitbox 
                hitPart = playerHitbox:()  playerHitbox:()  playerHitbox:()
                 hitPart  hitPartName = hitPart.Name 
            
        
          hitPart 
            hitPart = character:()  character:()
        
          hitPart   
        
         direction = (hitPart.Position - cam.CFrame.Position).Unit
         impactCFrame = .(hitPart.Position, hitPart.Position + direction)
        
        (()
            Remote:(, {
                hitPartName = hitPartName,
                raycastPos = hitPart.Position,
                characterId = charIdValue.Value,
                ownCharacterId = myCharIdValue.Value,
                camPos = cam.CFrame.Position,
                damagePlayer = player,
                silenced = silenced,
                scoped = ,
                weaponEquipSlot = slot,
                weapon = weapon
            })
        )
        
        (()
            Remote:(, {
                direction = direction,
                hitMaterial = ,
                impactCFrame = impactCFrame
            })
        )
    
    
    (()
         ctc = :():()
         ctc 
             hm = ctc:()
             hm  hm:() 
        
    )


  ()
      State.Unloaded 
         Config.SILENT_Enabled  Config.SILENT_Rage 
            (InjectDamageToAll)
        
        .()
    


  ()


  ()


.(()
    .()
    (SetupSilentAim)
    (SetupSilentRaycastHook)
    .(RageLoop)
)

  ()
    Cache.LocalChar = 
    Cache.LocalCharTime = 
    Cache.CharactersFolder = 
    Cache.CharactersFolderTime = 
    Cache.TeamCache = {}
    Cache.VisCache = {}
    Silent.CurrentTarget = 
    Silent.IsShooting = 


  ()
    Cache.TeamCache = {}
    Cache.VisCache = {}
    Silent.CurrentTarget = 


LocalPlayer.CharacterAdded:(()
    ()
)

 LocalPlayer.Character 
    LocalPlayer.Character:():(()
          LocalPlayer.Character   LocalPlayer.Character.Parent 
            ()
        
    )


.(()
    .()
     charsFolder = :()
     charsFolder 
        charsFolder.ChildAdded:(()
            ()
        )
        charsFolder.ChildRemoved:(()
            ()
        )
    
    
     collisionsFolder = :()
     collisionsFolder 
        collisionsFolder.ChildAdded:(()
            ()
        )
        collisionsFolder.ChildRemoved:(()
            ()
        )
    
)

  (player)
     espObjects[player]   
    
     box = .()
      box   
    box.Color = .(, , )
    box.Thickness = 
    box.Filled = 
    box.Visible = 
    
     name = .()
      name  box:()  
    name.Text = player.Name
    name.Color = .(, , )
    name.Size = 
    name.Center = 
    name.Outline = 
    name.Visible = 
    
     tracer = .()
      tracer  box:() name:()  
    tracer.Color = .(, , )
    tracer.Thickness = 
    tracer.Visible = 
    
     dist = .()
      dist  box:() name:() tracer:()  
    dist.Size = 
    dist.Center = 
    dist.Outline = 
    dist.OutlineColor = .(, , )
    dist.Visible = 
    
    espObjects[player] = {
        Box = box,
        Name = name,
        Tracer = tracer,
        Distance = dist
    }


  (player)
     espObjects[player] 
         espObjects[player].Box  espObjects[player].Box:() 
         espObjects[player].Name  espObjects[player].Name:() 
         espObjects[player].Tracer  espObjects[player].Tracer:() 
         espObjects[player].Distance  espObjects[player].Distance:() 
        espObjects[player] = 
    


  ()
     player, esp  (espObjects) 
         esp.Box  esp.Box:() 
         esp.Name  esp.Name:() 
         esp.Tracer  esp.Tracer:() 
         esp.Distance  esp.Distance:() 
    
    espObjects = {}


  ()
    camera = .CurrentCamera
      camera   
    
      Config.ESP_Enabled 
        ()
        
    
    
     localTeam = (LocalPlayer)
     charsFolder = ()
    
     _, player  (Players:()) 
         player == LocalPlayer   
        
         character = charsFolder  charsFolder:(player.Name)
         playerTeam = (player)
        
          character   playerTeam 
             espObjects[player] 
                (player)
            
            
        
        
          espObjects[player] 
            (player)
        
        
         esp = espObjects[player]
          esp   esp.Box   esp.Name   esp.Tracer   esp.Distance 
            (player)
            (player)
            esp = espObjects[player]
              esp   
        
        
         targetPart = (character)
          targetPart 
            esp.Box.Visible = 
            esp.Name.Visible = 
            esp.Tracer.Visible = 
            esp.Distance.Visible = 
            
        
        
         rootPos, onScreen = camera:(targetPart.Position)
          onScreen 
            esp.Box.Visible = 
            esp.Name.Visible = 
            esp.Tracer.Visible = 
            esp.Distance.Visible = 
            
        
        
         distance = (targetPart.Position)
        
         isEnemy = 
         Config.ESP_TeamCheck  localTeam  playerTeam 
            isEnemy = localTeam ~= playerTeam
        
        
         isEnemy 
             visible = (targetPart)
             col = Config.ESP_Rainbow  ()  (visible  Palette.ESP_Visible  Palette.ESP_Enemy)
            
             boxHeight =  / .(rootPos.Z, )
            boxHeight = .(boxHeight, , )
             boxWidth = boxHeight * 
            
             Config.ESP_Box 
                esp.Box.Size = .(boxWidth, boxHeight)
                esp.Box.Position = .(rootPos.X - boxWidth / , rootPos.Y - boxHeight * )
                esp.Box.Color = col
                esp.Box.Visible = 
            
                esp.Box.Visible = 
            
            
             Config.ESP_Name 
                esp.Name.Position = .(rootPos.X, rootPos.Y - boxHeight *  - )
                esp.Name.Visible = 
            
                esp.Name.Visible = 
            
            
             Config.ESP_Tracer 
                esp.Tracer.From = .(rootPos.X, rootPos.Y + boxHeight * )
                esp.Tracer.To = .(rootPos.X, camera.ViewportSize.Y)
                esp.Tracer.Color = col
                esp.Tracer.Visible = 
            
                esp.Tracer.Visible = 
            
            
             Config.ESP_Distance 
                esp.Distance.Text = .(distance) .. 
                esp.Distance.Position = .(rootPos.X, rootPos.Y + boxHeight *  + )
                esp.Distance.Color = .(, , )
                esp.Distance.Visible = 
            
                esp.Distance.Visible = 
            
        
            esp.Box.Visible = 
            esp.Name.Visible = 
            esp.Tracer.Visible = 
            esp.Distance.Visible = 
        
    


 fovCircle = .()
fovCircle.Thickness = 
fovCircle.NumSides = Tuning.FOVSegments
fovCircle.Filled = 
fovCircle.Visible = 

  ()
     Config.AIM_Enabled  Config.AIM_FOVEnabled 
         mousePos = UserInputService:()
        fovCircle.Position = mousePos
        fovCircle.Radius = Config.AIM_FOV
        fovCircle.Color = State.Aiming  Palette.FOV_Active  Palette.FOV_Circle
        fovCircle.Visible = 
    
        fovCircle.Visible = 
    


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


    Radar.bg.Filled = 
    Radar.bg.Color = Palette.RadarBg
    Radar.bg.Transparency = 
    Radar.bg.Visible = 
    
    Radar.border.Filled = 
    Radar.border.Color = Palette.RadarBorder
    Radar.border.Thickness = 
    Radar.border.Visible = 
    
    Radar.cross1.Color = Palette.RadarGrid
    Radar.cross1.Thickness = 
    Radar.cross1.Visible = 
    
    Radar.cross2.Color = Palette.RadarGrid
    Radar.cross2.Thickness = 
    Radar.cross2.Visible = 
    
    Radar.center.Filled = 
    Radar.center.Color = Palette.RadarYou
    Radar.center.Visible = 
    
     i = ,  
         d = .()
        d.Filled = 
        d.Color = Palette.RadarEnemy
        d.Visible = 
        Radar.dots[i] = d
    


 Compass = {
    bg = .(),
    bgGrad = .(),
    texts = {},
    ticks = {},
    indicators = {},
    centerLine = .()
}


    Compass.bg.Filled = 
    Compass.bg.Color = Palette.CompassBg
    Compass.bg.Transparency = 
    Compass.bg.Visible = 
    
    Compass.bgGrad.Filled = 
    Compass.bgGrad.Transparency = 
    Compass.bgGrad.Visible = 
    
    Compass.centerLine.Color = Palette.RadarYou
    Compass.centerLine.Thickness = 
    Compass.centerLine.Visible = 
    
     cardinals = {, , , , , , , , , , , , , , , , , , , , , , , }
     i = ,  
         t = .()
        t.Size = 
        t.Font = .Fonts.Monospace
        t.Center = 
        t.Outline = 
        t.Text = cardinals[i]
        t.Visible = 
        Compass.texts[i] = t
    
    
     i = ,  
          = .()
        .Color = Palette.CompassTick
        .Thickness = 
        .Visible = 
        Compass.ticks[i] = 
    
    
     i = ,  
         ind = .()
        ind.Filled = 
        ind.Color = Palette.CompassEnemy
        ind.Visible = 
        Compass.indicators[i] = ind
    


  ()
    Radar.bg.Visible = 
    Radar.border.Visible = 
    Radar.cross1.Visible = 
    Radar.cross2.Visible = 
    Radar.center.Visible = 
     _, d  (Radar.dots)  d.Visible =  


  ()
    Compass.bg.Visible = 
    Compass.bgGrad.Visible = 
    Compass.centerLine.Visible = 
     _, t  (Compass.texts)  t.Visible =  
     _, t  (Compass.ticks)  t.Visible =  
     _, i  (Compass.indicators)  i.Visible =  


  ()
    camera = .CurrentCamera
      camera 
        ()
        
    
    
     myChar = ()
      myChar 
        ()
        
    
     myRoot = (myChar)
      myRoot 
        ()
        
    
     charsFolder = ()
    
     size = Config.RADAR_Size
     screenSize = camera.ViewportSize
     defaultPos = .(screenSize.X - size - , )
     pos = State.Radar2D_Pos  defaultPos
     center = pos + .(size/, size/)
    
    Radar.bg.Position = pos
    Radar.bg.Size = .(size, size)
    Radar.bg.Visible = 
    
    Radar.border.Position = pos
    Radar.border.Size = .(size, size)
    Radar.border.Color = Config.RADAR_MoveMode  .(, , )  Palette.RadarBorder
    Radar.border.Thickness = Config.RADAR_MoveMode    
    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 = 
    
     myLook = camera.CFrame.LookVector
     myAngle = .(-myLook.X, -myLook.Z)
     cosA, sinA = .(myAngle), .(myAngle)
     scale = (size/ - ) / Config.RADAR_Range
    
     localTeam = (LocalPlayer)
     dotIdx = 
    
     _, player  (Players:()) 
         player == LocalPlayer   
        
         character = charsFolder  charsFolder:(player.Name)
         playerTeam = (player)
        
          character   playerTeam   
        
         isEnemy = 
         Config.ESP_TeamCheck  localTeam  playerTeam 
            isEnemy = localTeam ~= playerTeam
        
        
          isEnemy   
        
         root = (character)
          root   
        
         rx = root.Position.X - myRoot.Position.X
         rz = root.Position.Z - myRoot.Position.Z
         dist2D = .(rx^ + rz^)
        
         dist2D < Config.RADAR_Range 
             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)
            
             dotIdx <= #Radar.dots 
                 dot = Radar.dots[dotIdx]
                 ds = 
                
                 eAngle = 
                 lookPart = character:() 
                     character:() 
                     character:()
                     character:()
                     character:()
                     root
                
                 lookPart  lookPart:() 
                     lookVec = lookPart.CFrame.LookVector
                    eAngle = .(-lookVec.X, -lookVec.Z) - myAngle
                
                
                 eFwd = .(-.(eAngle), -.(eAngle))
                 eRight = .(-eFwd.Y, eFwd.X)
                
                dot.PointA = dotPos + eFwd * ds
                dot.PointB = dotPos - eFwd * ds/ + eRight * ds/
                dot.PointC = dotPos - eFwd * ds/ - eRight * ds/
                
                 visible = (root)
                dot.Color = visible  Palette.ESP_Visible  Palette.ESP_Enemy
                dot.Visible = 
                dotIdx = dotIdx + 
            
        
    
    
     i = dotIdx, #Radar.dots  Radar.dots[i].Visible =  
    
     as = Tuning.RadarArrowSize
    Radar.center.PointA = center + .(, -as)
    Radar.center.PointB = center + .(-as/, as/)
    Radar.center.PointC = center + .(as/, as/)
    Radar.center.Visible = 


  ()
    camera = .CurrentCamera
      camera 
        ()
        
    
    
     myChar = ()
      myChar 
        ()
        
    
     myRoot = (myChar)
      myRoot 
        ()
        
    
     charsFolder = ()
    
     screenSize = camera.ViewportSize
     cw = Tuning.CompassWidth
     ch = Tuning.CompassHeight
     defaultCx = screenSize.X /  - cw / 
     defaultCy = 
     hudPos = State.RadarHUD_Pos  .(defaultCx, defaultCy)
     cx = hudPos.X
     cy = hudPos.Y
    
    Compass.bg.Position = .(cx, cy)
    Compass.bg.Size = .(cw, ch)
    Compass.bg.Color = Config.RADAR_MoveMode  .(, , )  Palette.CompassBg
    Compass.bg.Visible = 
    
     myLook = camera.CFrame.LookVector
     myYaw = .(.(-myLook.X, -myLook.Z))
     myYaw <   myYaw = myYaw +  
    
     centerX = cx + cw / 
    
    Compass.centerLine.From = .(centerX, cy + )
    Compass.centerLine.To = .(centerX, cy + ch - )
    Compass.centerLine.Color = Config.RADAR_MoveMode  .(, , )  Palette.RadarYou
    Compass.centerLine.Visible = 
    
     cardinalData = {
        [] = , [] = , [] = , [] = ,
        [] = , [] = , [] = , [] = 
    }
    
     textIdx = 
     tickIdx = 
     fov = 
     pixPerDeg = cw / fov
    
     deg = , ,  
         diff = deg - myYaw
         diff >   diff = diff -  
         diff < -  diff = diff +  
        
         .(diff) <= fov /  
             screenX = centerX - diff * pixPerDeg
             cardinalText = cardinalData[deg]
             isCardinal = cardinalText ~= 
            
             tickIdx <= #Compass.ticks 
                  = Compass.ticks[tickIdx]
                 tickH = isCardinal    
                .From = .(screenX, cy + ch - tickH - )
                .To = .(screenX, cy + ch - )
                .Color = isCardinal  .(, , )  Palette.CompassTick
                .Visible = 
                tickIdx = tickIdx + 
            
            
             textIdx <= #Compass.texts 
                 t = Compass.texts[textIdx]
                 isCardinal 
                    t.Text = cardinalText
                    t.Color = .(, , )
                    t.Size = 
                
                    t.Text = (deg)
                    t.Color = Palette.CompassText
                    t.Size = 
                
                t.Position = .(screenX, cy + )
                t.Visible = 
                textIdx = textIdx + 
            
        
    
    
     i = textIdx, #Compass.texts  Compass.texts[i].Visible =  
     i = tickIdx, #Compass.ticks  Compass.ticks[i].Visible =  
    
     localTeam = (LocalPlayer)
     indIdx = 
    
     _, player  (Players:()) 
         player == LocalPlayer   
        
         character = charsFolder  charsFolder:(player.Name)
         playerTeam = (player)
        
          character   playerTeam   
        
         isEnemy = 
         Config.ESP_TeamCheck  localTeam  playerTeam 
            isEnemy = localTeam ~= playerTeam
        
        
          isEnemy   
        
         root = (character)
          root   
        
         dx = root.Position.X - myRoot.Position.X
         dz = root.Position.Z - myRoot.Position.Z
         dist = .(dx^ + dz^)
        
         dist < Config.RADAR_Range 
             enemyYaw = .(.(-dx, -dz))
             enemyYaw <   enemyYaw = enemyYaw +  
            
             diff = enemyYaw - myYaw
             diff >   diff = diff -  
             diff < -  diff = diff +  
            
             .(diff) <= fov /  
                 screenX = centerX - diff * pixPerDeg
                
                 indIdx <= #Compass.indicators 
                     ind = Compass.indicators[indIdx]
                     sz = 
                     indY = cy + ch + 
                    
                     lookPart = character:() 
                         character:() 
                         character:()
                         character:()
                         character:()
                         root
                     facingAngle = 
                     lookPart  lookPart:() 
                         enemyLook = lookPart.CFrame.LookVector
                         enemyFacingYaw = .(.(-enemyLook.X, -enemyLook.Z))
                         enemyFacingYaw <   enemyFacingYaw = enemyFacingYaw +  
                        facingAngle = .(myYaw - enemyFacingYaw)
                    
                    
                     fwdX = .(facingAngle)
                     fwdY = -.(facingAngle)
                     rightX = fwdY
                     rightY = -fwdX
                    
                    ind.PointA = .(screenX + fwdX * sz, indY + fwdY * sz)
                    ind.PointB = .(screenX - fwdX * sz *  - rightX * sz * , indY - fwdY * sz *  - rightY * sz * )
                    ind.PointC = .(screenX - fwdX * sz *  + rightX * sz * , indY - fwdY * sz *  + rightY * sz * )
                    
                     visible = (root)
                    ind.Color = visible  Palette.ESP_Visible  Palette.ESP_Enemy
                    ind.Visible = 
                    indIdx = indIdx + 
                
            
        
    
    
     i = indIdx, #Compass.indicators  Compass.indicators[i].Visible =  


  ()
      Config.RADAR_Enabled 
        ()
        ()
        
    
    
     Config.RADAR_Mode ==  
        ()
        ()
    
        ()
        ()
    


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

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


  ()
     label = .()
    label.Name = 
    label.BackgroundTransparency = 
    label.Position = .(, , , )
    label.Size = .(, , , )
    label.Font = .Font.RobotoMono
    label.TextSize = 
    label.TextColor3 = Palette.Accent
    label.TextXAlignment = .TextXAlignment.Left
    label.TextStrokeTransparency = 
    label.Text = 
    label.Parent = UI.ScreenGui
     label


  ()
     frame = .()
    frame.Name = 
    frame.BackgroundTransparency = 
    frame.AnchorPoint = .(, )
    frame.Position = .(, -, , )
    frame.Size = .(, , , )
    frame.Parent = UI.ScreenGui
    
     layout = .()
    layout.FillDirection = .FillDirection.Vertical
    layout.HorizontalAlignment = .HorizontalAlignment.Right
    layout.SortOrder = .SortOrder.Name
    layout.Padding = .(, )
    layout.Parent = frame
    
     frame


  (frame)
     _, child  (frame:()) 
         child:()  child:() 
    
    
      Config.MISC_ActiveList   
    
     features = {}
     Config.ESP_Enabled  .(features, ) 
     Config.ESP_Box  .(features, ) 
     Config.ESP_Name  .(features, ) 
     Config.ESP_Distance  .(features, ) 
     Config.ESP_Tracer  .(features, ) 
     Config.AIM_Enabled  .(features, ) 
     Config.SILENT_Enabled  .(features, ) 
     Config.RADAR_Enabled  .(features,  .. Config.RADAR_Mode .. ) 
     Config.RADAR_MoveMode  .(features, ) 
    
     i, name  (features) 
         lbl = .()
        lbl.Name = .(, i) .. name
        lbl.BackgroundTransparency = 
        lbl.Size = .(, , , )
        lbl.Font = .Font.RobotoMono
        lbl.TextSize = 
        lbl.TextColor3 = Palette.ItemOn
        lbl.TextXAlignment = .TextXAlignment.Right
        lbl.TextStrokeTransparency = 
        lbl.Text = name
        lbl.Parent = frame
    


  (title, items, pos)
     totalHeight = Tuning.PanelHeaderH
     _, item  (items) 
         item.type ==  
            totalHeight = totalHeight + Tuning.SliderHeight
        
            totalHeight = totalHeight + Tuning.ItemHeight
        
    
    totalHeight = totalHeight + 
    
     panel = .()
    panel.Name = title
    panel.BackgroundColor3 = Palette.PanelBg
    panel.BackgroundTransparency = 
    panel.BorderSizePixel = 
    panel.Position = pos
    panel.Size = .(, Tuning.PanelWidth, , totalHeight)
    panel.Active = 
    panel.Draggable = 
    panel.Parent = UI.ScreenGui
    
     stroke = .()
    stroke.Color = Palette.PanelBorder
    stroke.Thickness = 
    stroke.Parent = panel
    
     header = .()
    header.Name = 
    header.BackgroundColor3 = Palette.PanelHeader
    header.BackgroundTransparency = 
    header.BorderSizePixel = 
    header.Size = .(, , , Tuning.PanelHeaderH)
    header.Parent = panel
    
     titleLabel = .()
    titleLabel.Name = 
    titleLabel.BackgroundTransparency = 
    titleLabel.Size = .(, , , )
    titleLabel.Font = .Font.GothamBold
    titleLabel.TextSize = Tuning.FontSize
    titleLabel.TextColor3 = Palette.Text
    titleLabel.Text = title
    titleLabel.Parent = header
    
     yOffset = Tuning.PanelHeaderH + 
    
     _, item  (items) 
         item.type ==  
             btn = .()
            btn.Name = item.key
            btn.BackgroundColor3 = Palette.ItemHover
            btn.BackgroundTransparency = 
            btn.BorderSizePixel = 
            btn.Position = .(, , , yOffset)
            btn.Size = .(, , , Tuning.ItemHeight)
            btn.Font = .Font.RobotoMono
            btn.TextSize = Tuning.FontSize
            btn.TextXAlignment = .TextXAlignment.Left
            btn.AutoButtonColor = 
            btn.Parent = panel
            
             pad = .()
            pad.PaddingLeft = .(, )
            pad.Parent = btn
            
              ()
                btn.TextColor3 = Config[item.key]  Palette.ItemOn  Palette.ItemOff
                btn.Text = item.name
            
            ()
            
            btn.MouseEnter:(() btn.BackgroundTransparency =  )
            btn.MouseLeave:(() btn.BackgroundTransparency =  )
            btn.MouseButton1Click:(()
                Config[item.key] =  Config[item.key]
                ()
                 UI.ActiveList  (UI.ActiveList) 
            )
            
            yOffset = yOffset + Tuning.ItemHeight
            
         item.type ==  
             btn = .()
            btn.Name = item.key
            btn.BackgroundColor3 = Palette.ItemHover
            btn.BackgroundTransparency = 
            btn.BorderSizePixel = 
            btn.Position = .(, , , yOffset)
            btn.Size = .(, , , Tuning.ItemHeight)
            btn.Font = .Font.RobotoMono
            btn.TextSize = Tuning.FontSize
            btn.TextXAlignment = .TextXAlignment.Left
            btn.AutoButtonColor = 
            btn.Parent = panel
            
             pad = .()
            pad.PaddingLeft = .(, )
            pad.Parent = btn
            
             idx = 
             i, opt  (item.options) 
                 opt == Config[item.key]  idx = i  
            
            
              ()
                btn.Text = item.name ..  .. Config[item.key]
                btn.TextColor3 = Palette.ItemOff
            
            ()
            
            btn.MouseEnter:(() btn.BackgroundTransparency =  )
            btn.MouseLeave:(() btn.BackgroundTransparency =  )
            btn.MouseButton1Click:(()
                idx = idx % #item.options + 
                Config[item.key] = item.options[idx]
                ()
            )
            
            yOffset = yOffset + Tuning.ItemHeight
            
         item.type ==  
             container = .()
            container.Name = item.key
            container.BackgroundTransparency = 
            container.Position = .(, , , yOffset)
            container.Size = .(, -, , Tuning.SliderHeight - )
            container.Parent = panel
            
             label = .()
            label.Name = 
            label.BackgroundTransparency = 
            label.Size = .(, , , )
            label.Font = .Font.RobotoMono
            label.TextSize = 
            label.TextColor3 = Palette.TextDim
            label.TextXAlignment = .TextXAlignment.Left
            label.Parent = container
            
             track = .()
            track.Name = 
            track.BackgroundColor3 = .(, , )
            track.BorderSizePixel = 
            track.Position = .(, , , )
            track.Size = .(, , , )
            track.Parent = container
            
             trackCorner = .()
            trackCorner.CornerRadius = .(, )
            trackCorner.Parent = track
            
             fill = .()
            fill.Name = 
            fill.BackgroundColor3 = Palette.Accent
            fill.BorderSizePixel = 
            fill.Size = .(, , , )
            fill.Parent = track
            
             fillCorner = .()
            fillCorner.CornerRadius = .(, )
            fillCorner.Parent = fill
            
              ()
                 val = Config[item.key]
                 pct = (val - item.min) / (item.max - item.min)
                fill.Size = .(pct, , , )
                label.Text = item.name ..  .. (.(val * ) / )
            
            ()
            
             dragging = 
            
            track.InputBegan:((input)
                 input.UserInputType == .UserInputType.MouseButton1 
                    dragging = 
                
            )
            
            track.InputEnded:((input)
                 input.UserInputType == .UserInputType.MouseButton1 
                    dragging = 
                
            )
            
            Connections[ .. item.key] = RunService.RenderStepped:(()
                 dragging 
                     mx = UserInputService:().X
                     tx = track.AbsolutePosition.X
                     tw = track.AbsoluteSize.X
                     pct = .((mx - tx) / tw, 0, 1)
                    local val = item.min + pct * (item.max - item.min)
                    val = math.floor(val / item.step + 0.5) * item.step
                    Config[item.key] = math.clamp(val, item.min, item.max)
                    UpdateSlider()
                end
            end)
            
            yOffset = yOffset + Tuning.SliderHeight
        end
    end
    
    return panel
end

UI.Watermark = CreateWatermark()
UI.ActiveList = CreateActiveList()
RefreshActiveList(UI.ActiveList)

UI.Panels = {}

UI.Panels.ESP = CreatePanel("ESP", {
    {type = "toggle", name = "Enabled", key = "ESP_Enabled"},
    {type = "toggle", name = "Box", key = "ESP_Box"},
    {type = "toggle", name = "Names", key = "ESP_Name"},
    {type = "toggle", name = "Distance", key = "ESP_Distance"},
    {type = "toggle", name = "Tracers", key = "ESP_Tracer"},
    {type = "toggle", name = "Rainbow", key = "ESP_Rainbow"},
    {type = "toggle", name = "TeamCheck", key = "ESP_TeamCheck"}
}, UDim2.new(0, 10, 0, 35))

UI.Panels.Aimbot = CreatePanel("Aimbot", {
    {type = "toggle", name = "Enabled", key = "AIM_Enabled"},
    {type = "toggle", name = "ShowFOV", key = "AIM_FOVEnabled"},
    {type = "slider", name = "FOV", key = "AIM_FOV", min = 30, max = 400, step = 5},
    {type = "slider", name = "Smooth", key = "AIM_Smooth", min = 1, max = 15, step = 0.5}
}, UDim2.new(0, 165, 0, 35))

UI.Panels.Silent = CreatePanel("Silent", {
    {type = "toggle", name = "Enabled", key = "SILENT_Enabled"},
    {type = "toggle", name = "Rage Mode", key = "SILENT_Rage"},
    {type = "slider", name = "FOV", key = "SILENT_FOV", min = 50, max = 400, step = 10},
    {type = "toggle", name = "TeamCheck", key = "SILENT_TeamCheck"}
}, UDim2.new(0, 165, 0, 180))

UI.Panels.Radar = CreatePanel("Radar", {
    {type = "toggle", name = "Enabled", key = "RADAR_Enabled"},
    {type = "dropdown", name = "Mode", key = "RADAR_Mode", options = {"2D", "HUD"}},
    {type = "toggle", name = "Move Mode", key = "RADAR_MoveMode"},
    {type = "slider", name = "Size", key = "RADAR_Size", min = 100, max = 200, step = 10},
    {type = "slider", name = "Range", key = "RADAR_Range", min = 50, max = 500, step = 25}
}, UDim2.new(0, 320, 0, 35))

UI.Panels.Misc = CreatePanel("Misc", {
    {type = "toggle", name = "Watermark", key = "MISC_Watermark"},
    {type = "toggle", name = "ActiveList", key = "MISC_ActiveList"}
}, UDim2.new(0, 475, 0, 35))

local function Unload()
    if State.Unloaded then return end
    State.Unloaded = true
    
    for _, conn in pairs(Connections) do
        pcall(function() conn:Disconnect() end)
    end
    
    CleanupAllESP()
    
    pcall(function() fovCircle:Remove() end)
    pcall(function() if Silent.FOVCircle then Silent.FOVCircle:Remove() end end)
    
    pcall(function()
        Radar.bg:Remove()
        Radar.border:Remove()
        Radar.cross1:Remove()
        Radar.cross2:Remove()
        Radar.center:Remove()
        for _, d in ipairs(Radar.dots) do d:Remove() end
    end)
    
    pcall(function()
        Compass.bg:Remove()
        Compass.bgGrad:Remove()
        Compass.centerLine:Remove()
        for _, t in ipairs(Compass.texts) do t:Remove() end
        for _, t in ipairs(Compass.ticks) do t:Remove() end
        for _, i in ipairs(Compass.indicators) do i:Remove() end
    end)
    
    pcall(function() UI.ScreenGui:Destroy() end)
end

local function IsMouseInRect(mousePos, rectPos, rectSize)
    return mousePos.X >= rectPos.X and mousePos.X <= rectPos.X + rectSize.X
        and mousePos.Y >= rectPos.Y and mousePos.Y <= rectPos.Y + rectSize.Y
end

Connections.inputDown = 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
        UI.ScreenGui.Enabled = not UI.ScreenGui.Enabled
        return
    end
    
    if input.UserInputType == Enum.UserInputType.MouseButton2 then
        State.Aiming = true
    end
    
    if input.UserInputType == Enum.UserInputType.MouseButton1 and not gp then
        Silent.IsShooting = true
        task.delay(0.15, function()
            Silent.IsShooting = false
        end)
    end
    
    if Config.RADAR_MoveMode and input.UserInputType == Enum.UserInputType.MouseButton1 then
        local mousePos = UserInputService:GetMouseLocation()
        local cam = workspace.CurrentCamera
        if not cam then return end
        local screenSize = cam.ViewportSize
        
        if Config.RADAR_Mode == "2D" then
            local size = Config.RADAR_Size
            local defaultPos = Vector2.new(screenSize.X - size - 160, 15)
            local pos = State.Radar2D_Pos or defaultPos
            if IsMouseInRect(mousePos, pos, Vector2.new(size, size)) then
                State.RadarDragging = "2D"
                State.RadarDragOffset = mousePos - pos
            end
        elseif Config.RADAR_Mode == "HUD" then
            local cw = Tuning.CompassWidth
            local ch = Tuning.CompassHeight
            local defaultPos = Vector2.new(screenSize.X / 2 - cw / 2, 70)
            local pos = State.RadarHUD_Pos or defaultPos
            if IsMouseInRect(mousePos, pos, Vector2.new(cw, ch)) then
                State.RadarDragging = "HUD"
                State.RadarDragOffset = mousePos - pos
            end
        end
    end
end)

Connections.inputUp = UserInputService.InputEnded:Connect(function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton2 then
        State.Aiming = false
        targetEnemy = nil
    end
    
    if input.UserInputType == Enum.UserInputType.MouseButton1 then
        State.RadarDragging = nil
    end
end)

Connections.inputChanged = UserInputService.InputChanged:Connect(function(input)
    if State.RadarDragging and input.UserInputType == Enum.UserInputType.MouseMovement then
        local mousePos = UserInputService:GetMouseLocation()
        local newPos = mousePos - State.RadarDragOffset
        if State.RadarDragging == "2D" then
            State.Radar2D_Pos = newPos
        elseif State.RadarDragging == "HUD" then
            State.RadarHUD_Pos = newPos
        end
    end
end)

Connections.render = RunService.RenderStepped:Connect(function()
    if State.Unloaded then return end
    
    State.RainbowHue = (State.RainbowHue + 0.004) % 1
    
    UpdateESP()
    UpdateAimbot()
    UpdateFOV()
    UpdateRadar()
    
    if Config.SILENT_Enabled then
        GetSilentTarget()
    end
    UpdateSilentFOV()
    UpdateSilentSnap()
    
    if UI.Watermark then
        UI.Watermark.Visible = Config.MISC_Watermark
    end
end)

for _, player in ipairs(Players:GetPlayers()) do
    if player ~= LocalPlayer then
        CreateESP(player)
    end
end

Connections.playerAdded = Players.PlayerAdded:Connect(function(player)
    CreateESP(player)
end)

Connections.playerRemoving = Players.PlayerRemoving:Connect(function(player)
    RemoveESP(player)
end)