AIM ESP NO BAN TP KILL ALL SOURCE CODE

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

 LocalPlayer = Players.LocalPlayer
 Camera = Workspace.CurrentCamera

 Config = {
    ESP_Enabled = ,
    ESP_Box = ,
    ESP_Name = ,
    ESP_Health = ,
    ESP_Distance = ,
    ESP_TeamCheck = ,
    ESP_MaxDistance = ,
    ESP_HideSpawn = ,
    ESP_SpawnY = -,
    
    DRONE_ESP = ,
    DRONE_MaxDistance = ,
    
    CHAMS_Enabled = ,
    CHAMS_FillTransparency = ,
    CHAMS_OutlineTransparency = ,
    
    AIM_Enabled = ,
    AIM_FOV = ,
    AIM_Smooth = ,
    AIM_TeamCheck = ,
    AIM_TargetPart = ,
    AIM_Key = .UserInputType.MouseButton2,
    AIM_ShowFOV = ,
    AIM_Prediction = ,
    AIM_PredictionAmount = ,
    
    RECOIL_Enabled = ,
    RECOIL_Strength = ,
    
    NO_CAMSHAKE = ,
    NO_GUNBOB = ,
    
    TP_Enabled = ,
    TP_Key = .KeyCode.T,
    TP_Distance = ,
    TP_AutoShoot = ,
    
    MenuOpen = ,
    MenuKey = .KeyCode.Insert
}

 RecoilProfiles = {
    [] = {
        kickStrength = , horizontalStrength = , gunRise = , cameraShake = ,
        horizontalRandomness = , kickRandomness = , crouchMultiplier = , aimMultiplier = ,
        sprayIncrease = , returnSpeed = , patternScale = , firstShotMultiplier = ,
        moveMultiplier = , rpm = 
    },
    [] = {
        kickStrength = , horizontalStrength = , gunRise = , cameraShake = ,
        horizontalRandomness = , kickRandomness = , crouchMultiplier = , aimMultiplier = ,
        sprayIncrease = , returnSpeed = , patternScale = , firstShotMultiplier = ,
        moveMultiplier = , rpm = 
    },
    [] = {
        kickStrength = , horizontalStrength = , gunRise = , cameraShake = ,
        horizontalRandomness = , kickRandomness = , crouchMultiplier = , aimMultiplier = ,
        sprayIncrease = , returnSpeed = , patternScale = , firstShotMultiplier = ,
        moveMultiplier = , rpm = 
    },
    [] = {
        kickStrength = , horizontalStrength = , gunRise = , cameraShake = ,
        horizontalRandomness = , kickRandomness = , crouchMultiplier = , aimMultiplier = ,
        sprayIncrease = , returnSpeed = , patternScale = , firstShotMultiplier = ,
        moveMultiplier = , rpm = 
    },
    [] = {
        kickStrength = , horizontalStrength = , gunRise = , cameraShake = ,
        horizontalRandomness = , kickRandomness = , crouchMultiplier = , aimMultiplier = ,
        sprayIncrease = , returnSpeed = , patternScale = , firstShotMultiplier = ,
        moveMultiplier = , rpm = 
    },
    [] = {
        kickStrength = , horizontalStrength = , gunRise = , cameraShake = ,
        horizontalRandomness = , kickRandomness = , crouchMultiplier = , aimMultiplier = ,
        sprayIncrease = , returnSpeed = , patternScale = , firstShotMultiplier = ,
        moveMultiplier = , rpm = 
    },
    [] = {
        kickStrength = , horizontalStrength = , gunRise = , cameraShake = ,
        horizontalRandomness = , kickRandomness = , crouchMultiplier = , aimMultiplier = ,
        sprayIncrease = , returnSpeed = , patternScale = , firstShotMultiplier = ,
        moveMultiplier = , rpm = 
    },
    [] = {
        kickStrength = , horizontalStrength = , gunRise = , cameraShake = ,
        horizontalRandomness = , kickRandomness = , crouchMultiplier = , aimMultiplier = ,
        sprayIncrease = , returnSpeed = , patternScale = , firstShotMultiplier = ,
        moveMultiplier = , rpm = 
    }
}

 BulletPhysics = {
    Speed = ,
    Drop = ,
    Gravity = 
}

 VelocityCache = {}
 PositionCache = {}
 LastAimPos = 
 AimSmoothing = 

 WeaponToProfile = {
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = ,
    [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = ,
    
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = ,
    
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = ,
    
    [] = , [] = , [] = ,
    [] = , [] = , [] = ,
    [] = , [] = , [] = ,
    [] = , [] = , [] = ,
    
    [] = , [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = , [] = ,
    [] = , [] = , [] = 
}

 Tuning = {
    BoxRatio = ,
    NameSize = ,
    DistSize = ,
    HealthBarWidth = ,
    BoxThickness = 
}

 Palette = {
    Enemy = .(, , ),
    EnemyVisible = .(, , ),
    Friendly = .(, , ),
    FOV = .(, , ),
    Drone = .(, , )
}

 State = {
    Unloaded = ,
    CurrentRecoilProfile = ,
    ShotsFired = ,
    LastShotTime = ,
    IsAiming = ,
    IsCrouching = ,
    IsFiring = ,
    LastFireTick = ,
    SprayTime = ,
    AccumulatedRecoil = .(, ),
    LastCameraShake = .(),
    OriginalCamCF = ,
    LockedCameraCF = ,
    LastCameraCF = ,
    RecoilModulesPatched = ,
    PatchedTables = {}
}

 ESP = { cache = {} }
 Chams = { cache = {} }
 DroneESP = { cache = {} }
 VelocityCache = {}
 Connections = {}

 FOVCircle = .()
FOVCircle.Thickness = 
FOVCircle.Color = Palette.FOV
FOVCircle.Filled = 
FOVCircle.Transparency = 
FOVCircle.Radius = 
FOVCircle.Visible = Config.AIM_ShowFOV  Config.AIM_Enabled

  (class)
     .(class)


 ESP.()
     {
        BoxTop = (),
        BoxBottom = (),
        BoxLeft = (),
        BoxRight = (),
        Name = (),
        Distance = (),
        HealthBarBG = (),
        HealthBar = ()
    }


 ESP.(esp)
     _, line  ({esp.BoxTop, esp.BoxBottom, esp.BoxLeft, esp.BoxRight}) 
        line.Thickness = 
        line.Visible = 
    
    
    esp.Name.Size = Tuning.NameSize
    esp.Name.Center = 
    esp.Name.Outline = 
    esp.Name.Font = .Fonts.Monospace
    esp.Name.Visible = 
    
    esp.Distance.Size = Tuning.DistSize
    esp.Distance.Center = 
    esp.Distance.Outline = 
    esp.Distance.Font = .Fonts.Monospace
    esp.Distance.Visible = 
    
    esp.HealthBarBG.Thickness = Tuning.HealthBarWidth + 
    esp.HealthBarBG.Color = .(, , )
    esp.HealthBarBG.Visible = 
    
    esp.HealthBar.Thickness = Tuning.HealthBarWidth
    esp.HealthBar.Visible = 


 ESP.(player)
      ESP.cache[player] 
         e = ESP.()
        ESP.(e)
        ESP.cache[player] = e
    
     ESP.cache[player]


 ESP.(esp)
      esp   
    esp.BoxTop.Visible = 
    esp.BoxBottom.Visible = 
    esp.BoxLeft.Visible = 
    esp.BoxRight.Visible = 
    esp.Name.Visible = 
    esp.Distance.Visible = 
    esp.HealthBar.Visible = 
    esp.HealthBarBG.Visible = 


 ESP.(esp)
      esp   
    (()
        esp.BoxTop:()
        esp.BoxBottom:()
        esp.BoxLeft:()
        esp.BoxRight:()
        esp.Name:()
        esp.Distance:()
        esp.HealthBar:()
        esp.HealthBarBG:()
    )


 ESP.(player)
     e = ESP.cache[player]
     e 
        ESP.(e)
        ESP.(e)
        ESP.cache[player] = 
    


 Chams.(char, isEnemy, isVisible)
     Chams.cache[char]   
    
     highlight = .()
    highlight.Name = 
    highlight.Adornee = char
    highlight.DepthMode = .HighlightDepthMode.AlwaysOnTop
    highlight.FillTransparency = Config.CHAMS_FillTransparency
    highlight.OutlineTransparency = Config.CHAMS_OutlineTransparency
    
     color = Palette.Friendly
     isEnemy 
        color = isVisible  Palette.EnemyVisible  Palette.Enemy
    
    highlight.FillColor = color
    highlight.OutlineColor = color
    highlight.Parent = char
    
    Chams.cache[char] = highlight


 Chams.(char, isEnemy, isVisible)
     h = Chams.cache[char]
      h   
    
     color = Palette.Friendly
     isEnemy 
        color = isVisible  Palette.EnemyVisible  Palette.Enemy
    
    h.FillColor = color
    h.OutlineColor = color
    h.FillTransparency = Config.CHAMS_FillTransparency
    h.OutlineTransparency = Config.CHAMS_OutlineTransparency


 Chams.(char)
     h = Chams.cache[char]
     h 
        (() h:() )
        Chams.cache[char] = 
    


 Chams.()
     char, h  (Chams.cache) 
        (() h:() )
    
    Chams.cache = {}


 DroneESP.()
     {
        Box = .(),
        Name = .(),
        Distance = .()
    }


 DroneESP.(d)
    d.Box.Thickness = 
    d.Box.Filled = 
    d.Box.Color = Palette.Drone
    d.Box.Visible = 
    
    d.Name.Size = 
    d.Name.Center = 
    d.Name.Outline = 
    d.Name.Font = .Fonts.Monospace
    d.Name.Color = Palette.Drone
    d.Name.Visible = 
    
    d.Distance.Size = 
    d.Distance.Center = 
    d.Distance.Outline = 
    d.Distance.Font = .Fonts.Monospace
    d.Distance.Color = Palette.Drone
    d.Distance.Visible = 


 DroneESP.(drone)
      DroneESP.cache[drone] 
         d = DroneESP.()
        DroneESP.(d)
        DroneESP.cache[drone] = d
    
     DroneESP.cache[drone]


 DroneESP.(d)
      d   
    d.Box.Visible = 
    d.Name.Visible = 
    d.Distance.Visible = 


 DroneESP.(d)
      d   
    (()
        d.Box:()
        d.Name:()
        d.Distance:()
    )


 DroneESP.(drone)
     d = DroneESP.cache[drone]
     d 
        DroneESP.(d)
        DroneESP.(d)
        DroneESP.cache[drone] = 
    


 DroneESP.()
     drone, d  (DroneESP.cache) 
        DroneESP.(d)
        DroneESP.(d)
    
    DroneESP.cache = {}


  (player, part)
      part   .zero 
      player   .zero 
    
     vel = .zero
    (() vel = part.AssemblyLinearVelocity )
     vel


  (targetPos, targetVel, myPos)
     bulletSpeed = BulletPhysics.Speed
     gravityDrop = BulletPhysics.Gravity * BulletPhysics.Drop
    
     toTarget = targetPos - myPos
     dist = toTarget.Magnitude
    
     dist <  
         targetPos
    
    
     flightTime = dist / bulletSpeed
    
     i = ,  
         predictedPos = targetPos + targetVel * flightTime
         newDist = (predictedPos - myPos).Magnitude
        flightTime = newDist / bulletSpeed
    
    
    flightTime = flightTime * Config.AIM_PredictionAmount
    
     leadX = targetPos.X + targetVel.X * flightTime
     leadZ = targetPos.Z + targetVel.Z * flightTime
     leadY = targetPos.Y + targetVel.Y * flightTime
    
     drop =  * gravityDrop * flightTime * flightTime
    leadY = leadY + drop
    
     .(leadX, leadY, leadZ)


  (player)
      player   LocalPlayer    
     myTeam = LocalPlayer.Team
     theirTeam = player.Team
      myTeam   theirTeam    
     myTeam ~= theirTeam


  (player)
     player  player.Character


  (char)
     char  char:()


  (char)
     char  char:()


  (char)
     char  char:()


  (pos)
     myChar = (LocalPlayer)
     myRoot = (myChar)
      myRoot    
     (pos - myRoot.Position).Magnitude


  (hrp)
      Config.ESP_HideSpawn    
      hrp    
     hrp.Position.Y < Config.ESP_SpawnY


  (pos)
     screenPos, onScreen = Camera:(pos)
     .(screenPos.X, screenPos.Y), onScreen, screenPos.Z


  (targetPos, targetChar)
     myChar = (LocalPlayer)
      myChar    
     myHead = myChar:()
      myHead    
    
     origin = myHead.Position
     direction = targetPos - origin
    
     params = RaycastParams.()
    params.FilterType = .RaycastFilterType.Exclude
    params.FilterDescendantsInstances = {myChar, targetChar, Camera}
    
     result = Workspace:(origin, direction, params)
     result == 


  ()
     char = (LocalPlayer)
      char   ,  
    
     _, child  (char:()) 
         child:() 
             child.Name, child
        
    
     , 


  ()
     weaponName = ()
      weaponName    
    
     profileName = WeaponToProfile[weaponName]
     profileName 
         RecoilProfiles[profileName], profileName
    
    
     name, profile  (WeaponToProfile) 
         .(.(weaponName), .(name)) 
             RecoilProfiles[profile], profile
        
    
    
     RecoilProfiles[], 


  (profile, shotNum, deltaTime)
     baseVertical = profile.kickStrength + profile.gunRise
     baseHorizontal = profile.horizontalStrength
    
     sprayFactor =  + .(shotNum * profile.sprayIncrease, )
     firstShotMult = shotNum ==   profile.firstShotMultiplier  
    
     verticalRecoil = baseVertical * sprayFactor * firstShotMult
     horizontalRecoil = baseHorizontal * sprayFactor
    
     patternPhase = (shotNum * profile.patternSpeed) % 
     patternOffset = .(.(patternPhase)) * profile.patternScale
    horizontalRecoil = horizontalRecoil + patternOffset
    
     multiplier = 
     State.IsAiming 
        multiplier = multiplier * profile.aimMultiplier
    
     State.IsCrouching 
        multiplier = multiplier * profile.crouchMultiplier
    
    
    verticalRecoil = verticalRecoil * multiplier
    horizontalRecoil = horizontalRecoil * multiplier
    
     verticalRecoil, horizontalRecoil


  (deltaX, deltaY)
      Config.RECOIL_Enabled   deltaX, deltaY 
    
     profile, profileName = ()
      profile  
        profile = RecoilProfiles[]
    
    
     now = ()
     timeSinceLastShot = now - State.LastShotTime
    
     timeSinceLastShot <  / (profile.rpm  ) *  
        State.ShotsFired = State.ShotsFired + 
        State.SprayTime = State.SprayTime + timeSinceLastShot
    
        State.ShotsFired = 
        State.SprayTime = 
        State.AccumulatedRecoil = .(, )
    
    State.LastShotTime = now
    
     vertComp, horzComp = (profile, State.ShotsFired, timeSinceLastShot)
    
     screenScale = Camera.ViewportSize.Y / 
     baseScale =  * Config.RECOIL_Strength * screenScale
    
    vertComp = vertComp * baseScale
    horzComp = horzComp * baseScale * 
    
    State.AccumulatedRecoil = State.AccumulatedRecoil + .(horzComp, vertComp)
    
     deltaX - horzComp, deltaY - vertComp


  ()
      Config.RECOIL_Enabled   
    
     mouse1Down = UserInputService:(.UserInputType.MouseButton1)
    
      mouse1Down  
        State.IsFiring = 
        State.ShotsFired = 
        State.SprayTime = 
         
    
    
     profile = RecoilProfiles[]
     weaponName = ()
     weaponName 
         pName = WeaponToProfile[weaponName]
         pName  RecoilProfiles[pName] 
            profile = RecoilProfiles[pName]
        
    
    
     now = ()
     rpm = profile.rpm  
     fireInterval =  / rpm
    
      State.IsFiring 
        State.IsFiring = 
        State.ShotsFired = 
        State.LastFireTick = now
        State.SprayTime = 
    
         now - State.LastFireTick >= fireInterval 
            State.ShotsFired = State.ShotsFired + 
            State.LastFireTick = now
        
        State.SprayTime = State.SprayTime + (/)
    
    
     baseKick = profile.kickStrength + profile.gunRise
     sprayMult =  + .(State.ShotsFired * profile.sprayIncrease * , )
    
     State.ShotsFired ==  
        baseKick = baseKick * (profile.firstShotMultiplier  )
    
    
     State.IsAiming 
        baseKick = baseKick * (profile.aimMultiplier  )
    
    
     State.IsCrouching 
        baseKick = baseKick * (profile.crouchMultiplier  )
    
    
     perFrameComp = baseKick * sprayMult *  * Config.RECOIL_Strength
    
     mousemoverel 
        (, perFrameComp)
    



  ()


  ()


  ()
      Config.NO_CAMSHAKE   
    
    (()
         char = LocalPlayer.Character
          char   
        
         humanoid = char:()
         humanoid 
            humanoid.CameraOffset = .(, , )
        
    )


  ()
      Config.NO_GUNBOB   




  ()
      Config.AIM_Enabled    
    
     mousePos = UserInputService:()
     bestTarget = 
     bestScore = .huge
    
     _, player  (Players:()) 
         player == LocalPlayer   
         Config.AIM_TeamCheck   (player)   
        
         char = (player)
          char   
        
         hum = (char)
          hum  hum.Health <=    
        
         hrp = (char)
         (hrp)   
        
         targetPart = char:(Config.AIM_TargetPart)  (char)  hrp
          targetPart   
        
         screenPos, onScreen, depth = (targetPart.Position)
          onScreen  depth <=    
        
         dist = (targetPart.Position)
         dist > Config.ESP_MaxDistance   
        
         screenDist = (screenPos - mousePos).Magnitude
         screenDist > Config.AIM_FOV   
        
         score = screenDist + (dist * )
        
         score < bestScore 
            bestScore = score
            bestTarget = {
                Player = player,
                Part = targetPart,
                ScreenPos = screenPos,
                Distance = dist,
                Health = hum.Health
            }
        
    
    
     bestTarget


  (target)
      target   target.Part   
    
     myPos = Camera.CFrame.Position
     targetPos = target.Part.Position
     distance = target.Distance
    
     char = target.Player.Character
     hrp = (char)
     velocity = .zero
    
     hrp 
        velocity = (target.Player, hrp)
    
    
     Config.AIM_Prediction 
        targetPos = (targetPos, velocity, myPos)
    
    
     screenPos = Camera:(targetPos)
     screenPos.Z <=    
    
     screenCenter = Camera.ViewportSize / 
     deltaX = screenPos.X - screenCenter.X
     deltaY = screenPos.Y - screenCenter.Y
     deltaMag = .(deltaX * deltaX + deltaY * deltaY)
    
     deltaMag <    
    
     smooth = Config.AIM_Smooth
    
     moveX = deltaX * smooth
     moveY = deltaY * smooth
    
     deltaMag >  
        moveX = deltaX * .(smooth * , )
        moveY = deltaY * .(smooth * , )
    
    
     mousemoverel 
        (moveX, moveY)
    


 LastChamsClean = 
 ESPFrameCounter = 
 VisibilityCache = {}
 LastVisibilityCheck = 

  ()
     State.Unloaded   
    
    ESPFrameCounter = ESPFrameCounter + 
    
    Camera = Workspace.CurrentCamera
      Camera   
    
     screenSize = Camera.ViewportSize
    
    FOVCircle.Position = UserInputService:()
    FOVCircle.Radius = Config.AIM_FOV
    FOVCircle.Visible = Config.AIM_ShowFOV  Config.AIM_Enabled
    
     now = ()
    
     now - LastChamsClean >  
        LastChamsClean = now
         oldChar, _  (Chams.cache) 
              oldChar   oldChar.Parent 
                Chams.(oldChar)
            
        
    
    
     doVisibilityCheck = now - LastVisibilityCheck > 
     doVisibilityCheck 
        LastVisibilityCheck = now
    
    
     _, player  (Players:()) 
         player == LocalPlayer   
        
         esp = ESP.(player)
         char = (player)
        
          char   char.Parent 
            ESP.(esp)
            
        
        
         hum = (char)
         hrp = (char)
         head = (char)
        
          hum   hrp  hum.Health <=  
            ESP.(esp)
            Chams.(char)
            
        
        
         rootPos, onScreen, depth = (hrp.Position)
          onScreen  depth <=  
            ESP.(esp)
            
        
        
         dist = (hrp.Position)
         dist > Config.ESP_MaxDistance 
            ESP.(esp)
            Chams.(char)
            
        
        
         isEnemy = (player)
         Config.ESP_TeamCheck   isEnemy 
            ESP.(esp)
            Chams.(char)
            
        
        
         (hrp) 
            ESP.(esp)
            Chams.(char)
            
        
        
         isVisible = VisibilityCache[player]
         doVisibilityCheck 
            isVisible = (hrp.Position, char)
            VisibilityCache[player] = isVisible
        
        isVisible = isVisible  
        
         color = Palette.Friendly
         isEnemy 
            color = isVisible  Palette.EnemyVisible  Palette.Enemy
        
        
         boxHeight = .( / .(depth, ), , )
         boxWidth = boxHeight * Tuning.BoxRatio
        
         halfW = boxWidth / 
         halfH = boxHeight / 
         topY = rootPos.Y - halfH * 
         bottomY = rootPos.Y + halfH * 
        
         topLeft = .(rootPos.X - halfW, topY)
         topRight = .(rootPos.X + halfW, topY)
         bottomLeft = .(rootPos.X - halfW, bottomY)
         bottomRight = .(rootPos.X + halfW, bottomY)
        
         Config.ESP_Enabled  Config.ESP_Box 
            esp.BoxTop.From = topLeft
            esp.BoxTop.To = topRight
            esp.BoxTop.Color = color
            esp.BoxTop.Visible = 
            
            esp.BoxBottom.From = bottomLeft
            esp.BoxBottom.To = bottomRight
            esp.BoxBottom.Color = color
            esp.BoxBottom.Visible = 
            
            esp.BoxLeft.From = topLeft
            esp.BoxLeft.To = bottomLeft
            esp.BoxLeft.Color = color
            esp.BoxLeft.Visible = 
            
            esp.BoxRight.From = topRight
            esp.BoxRight.To = bottomRight
            esp.BoxRight.Color = color
            esp.BoxRight.Visible = 
        
            esp.BoxTop.Visible = 
            esp.BoxBottom.Visible = 
            esp.BoxLeft.Visible = 
            esp.BoxRight.Visible = 
        
        
         Config.ESP_Enabled  Config.ESP_Name 
            esp.Name.Text = player.Name
            esp.Name.Position = .(rootPos.X, topY - )
            esp.Name.Color = color
            esp.Name.Visible = 
        
            esp.Name.Visible = 
        
        
         Config.ESP_Enabled  Config.ESP_Distance 
            esp.Distance.Text = .(, .(dist))
            esp.Distance.Position = .(rootPos.X, bottomY + )
            esp.Distance.Color = color
            esp.Distance.Visible = 
        
            esp.Distance.Visible = 
        
        
         Config.ESP_Enabled  Config.ESP_Health 
             healthPercent = .(hum.Health / hum.MaxHealth, , )
             barFullHeight = bottomY - topY
             barHeight = barFullHeight * healthPercent
             barTop = bottomY - barHeight
            
            esp.HealthBarBG.From = .(topLeft.X - , topY)
            esp.HealthBarBG.To = .(topLeft.X - , bottomY)
            esp.HealthBarBG.Visible = 
            
             healthColor = .(
                .( * ( - healthPercent)),
                .( * healthPercent),
                
            )
            
            esp.HealthBar.From = .(topLeft.X - , barTop)
            esp.HealthBar.To = .(topLeft.X - , bottomY)
            esp.HealthBar.Color = healthColor
            esp.HealthBar.Visible = 
        
            esp.HealthBar.Visible = 
            esp.HealthBarBG.Visible = 
        
        
         Config.CHAMS_Enabled 
              Chams.cache[char] 
                Chams.(char, isEnemy, isVisible)
            
                Chams.(char, isEnemy, isVisible)
            
        
            Chams.(char)
        
    


 DroneCache = {}
 LastDroneScan = 

  ()
     now = ()
     now - LastDroneScan <  
         DroneCache
    
    LastDroneScan = now
    DroneCache = {}
    
     droneFolder = Workspace:()
     droneFolder 
         _, obj  (droneFolder:()) 
             obj:() 
                .(DroneCache, obj)
            
        
    
    
     DroneCache


 DroneESPFrame = 

  ()
     State.Unloaded   
      Config.DRONE_ESP 
         drone, d  (DroneESP.cache) 
            DroneESP.(d)
        
        
    
    
    DroneESPFrame = DroneESPFrame + 
     DroneESPFrame %  ~=    
    
     drones = ()
     activeDrones = {}
    
     _, drone  (drones) 
        activeDrones[drone] = 
         d = DroneESP.(drone)
        
         primary = drone.PrimaryPart  drone:()
          primary 
            DroneESP.(d)
            
        
        
         screenPos, onScreen, depth = (primary.Position)
          onScreen  depth <=  
            DroneESP.(d)
            
        
        
         dist = (primary.Position)
         dist > Config.DRONE_MaxDistance 
            DroneESP.(d)
            
        
        
         boxSize = .( / .(depth, ), , )
        
        d.Box.Position = .(screenPos.X - boxSize/, screenPos.Y - boxSize/)
        d.Box.Size = .(boxSize, boxSize)
        d.Box.Visible = 
        
        d.Name.Text = drone.Name
        d.Name.Position = .(screenPos.X, screenPos.Y - boxSize/ - )
        d.Name.Visible = 
        
        d.Distance.Text = .(, .(dist))
        d.Distance.Position = .(screenPos.X, screenPos.Y + boxSize/ + )
        d.Distance.Visible = 
    
    
     drone, d  (DroneESP.cache) 
          activeDrones[drone] 
            DroneESP.(drone)
        
    


  ()
     closest = 
     closestDist = .huge
     myChar = (LocalPlayer)
     myRoot = (myChar)
      myRoot    
    
     _, player  (Players:()) 
         player == LocalPlayer   
         Config.AIM_TeamCheck   (player)   
        
         char = (player)
          char   
        
         hum = (char)
          hum  hum.Health <=    
        
         hrp = (char)
          hrp   
        
         (hrp)   
        
         dist = (hrp.Position - myRoot.Position).Magnitude
         dist < closestDist 
            closestDist = dist
            closest = {Player = player, Character = char, HRP = hrp, Distance = dist}
        
    
    
     closest


 TPTarget = 
 TPActive = 
 TPKeyDebounce = 
 TPLastShot = 
 TPFrameSkip = 
 TPShotCount = 
 TPLastReload = 
 TPMagSize = 

  (target)
      target   target.HRP   
    
     myChar = (LocalPlayer)
      myChar   
    
     myRoot = (myChar)
      myRoot   
    
     enemyHRP = target.HRP
      enemyHRP   enemyHRP.Parent   
    
     enemyPos = enemyHRP.Position
     enemyLook = enemyHRP.CFrame.LookVector
    
     behindPos = enemyPos - (enemyLook * Config.TP_Distance)
    behindPos = .(behindPos.X, enemyPos.Y, behindPos.Z)
    
    myRoot.CFrame = .(behindPos)
    
    (()
        myRoot.AssemblyLinearVelocity = .zero
    )
    
     head = target.Character:()
     aimTarget = head  head.Position  enemyPos
    
     camPos = behindPos + .(, , )
    Camera.CFrame = .(camPos, aimTarget)


  ()
     weaponName = ()
      weaponName    
    
     name = .(weaponName)
    
     name:()  name:()  name:()   
     name:()   
     name:()  name:()  name:()   
     name:()  name:()  name:()   
     name:()  name:()  name:()   
     name:()  name:()  name:()   
     name:()  name:()   
     name:()  name:()  name:()   
       


  ()
     now = ()
     now - TPLastReload <     
    
    TPLastReload = now
    TPShotCount = 
    TPMagSize = ()
    
    (()
         keypress 
            ()
            .(, ()
                 keyrelease  () 
            )
        
    )
    
     


  ()
      Config.TP_AutoShoot   
    
     now = ()
    
     now - TPLastReload <  
        
    
    
     TPShotCount >= TPMagSize 
        ()
        
    
    
     now - TPLastShot <    
    TPLastShot = now
    TPShotCount = TPShotCount + 
    
    (()
         mouse1click 
            ()
        
    )


  ()
      Config.TP_Enabled  
        TPActive = 
         
    
    
     keyDown = UserInputService:(Config.TP_Key)
    
     keyDown   TPKeyDebounce 
        TPKeyDebounce = 
        TPActive =  TPActive
        
         TPActive 
            TPTarget = ()
            TPShotCount = 
            TPMagSize = ()
        
            TPTarget = 
        
      keyDown 
        TPKeyDebounce = 
    
    
      TPActive   
    
    TPFrameSkip = TPFrameSkip + 
     TPFrameSkip <    
    TPFrameSkip = 
    
     TPTarget 
         char = TPTarget.Player.Character
         char 
             hrp = char:()
             hum = char:()
            
             hrp  hum  hum.Health >    (hrp) 
                TPTarget.HRP = hrp
                TPTarget.Character = char
                (TPTarget)
                ()
            
                TPTarget = ()
            
        
            TPTarget = ()
        
    
        TPTarget = ()
    


  ()
     State.Unloaded   
      Config.AIM_Enabled   
    
     holdingAimKey = UserInputService:(Config.AIM_Key)
     holdingFire = UserInputService:(.UserInputType.MouseButton1)
    
      holdingAimKey   holdingFire   
    
     target = ()
     target 
        (target)
    


  ()
     char = (LocalPlayer)
      char   
    
     hum = (char)
     hum 
        State.IsCrouching = hum:() == .HumanoidStateType.None
    
    
    State.IsAiming = UserInputService:(.UserInputType.MouseButton2)


  ()
     State.Unloaded   
    
    ()
    ()
    ()
    ()
    ()
    ()


 Unload
 ScreenGui = 
 MobileTPBtn = 

  ()
     isMobile = UserInputService.TouchEnabled   UserInputService.KeyboardEnabled
    
    ScreenGui = .()
    ScreenGui.Name = 
    ScreenGui.ResetOnSpawn = 
    ScreenGui.ZIndexBehavior = .ZIndexBehavior.Sibling
    ScreenGui.IgnoreGuiInset = 
    
    (()
          
            .(ScreenGui)
         gethui 
            ScreenGui.Parent = ()
            
        
    )
    
    ScreenGui.Parent = LocalPlayer:()
    
     Accent = .(, , )
     GlassBg = .(, , )
     GlassCard = .(, , )
     TextPrimary = .(, , )
     TextSecondary = .(, , )
    
     MainContainer = .()
    MainContainer.Name = 
    MainContainer.AnchorPoint = .(, )
    MainContainer.Position = .(, , , )
    MainContainer.Size = isMobile  .(, , , )  .(, , , )
    MainContainer.BackgroundColor3 = GlassBg
    MainContainer.BackgroundTransparency = 
    MainContainer.BorderSizePixel = 
    MainContainer.ClipsDescendants = 
    MainContainer.Parent = ScreenGui
    
     MainCorner = .()
    MainCorner.CornerRadius = .(, )
    MainCorner.Parent = MainContainer
    
     TopBar = .()
    TopBar.Size = .(, , , )
    TopBar.BackgroundColor3 = .(, , )
    TopBar.BackgroundTransparency = 
    TopBar.BorderSizePixel = 
    TopBar.Parent = MainContainer
    
     TopCorner = .()
    TopCorner.CornerRadius = .(, )
    TopCorner.Parent = TopBar
    
     Tabs = {, , }
     TabButtons = {}
     TabPanels = {}
    
     i, tabName  (Tabs) 
         TabBtn = .()
        TabBtn.Size = .(, , , )
        TabBtn.Position = .(,  + (i-) * , , -)
        TabBtn.BackgroundColor3 = i ==   Accent  GlassCard
        TabBtn.BackgroundTransparency = i ==     
        TabBtn.BorderSizePixel = 
        TabBtn.Text = tabName
        TabBtn.TextSize = 
        TabBtn.Font = i ==   .Font.GothamBold  .Font.GothamMedium
        TabBtn.TextColor3 = i ==   TextPrimary  TextSecondary
        TabBtn.Parent = TopBar
        
         TabCorner = .()
        TabCorner.CornerRadius = .(, )
        TabCorner.Parent = TabBtn
        
         Panel = .()
        Panel.Name = tabName .. 
        Panel.Size = .(, -, , -)
        Panel.Position = .(, , , )
        Panel.BackgroundTransparency = 
        Panel.ScrollBarThickness = 
        Panel.ScrollBarImageColor3 = Accent
        Panel.BorderSizePixel = 
        Panel.Visible = i == 
        Panel.Parent = MainContainer
        
         PanelLayout = .()
        PanelLayout.SortOrder = .SortOrder.LayoutOrder
        PanelLayout.Padding = .(, )
        PanelLayout.Parent = Panel
        
        TabButtons[tabName] = TabBtn
        TabPanels[tabName] = Panel
    
    
     PowerBtn = .()
    PowerBtn.Size = .(, , , )
    PowerBtn.Position = .(, -, , -)
    PowerBtn.BackgroundColor3 = .(, , )
    PowerBtn.BackgroundTransparency = 
    PowerBtn.BorderSizePixel = 
    PowerBtn.Image = 
    PowerBtn.ImageColor3 = TextPrimary
    PowerBtn.Parent = TopBar
    
     PowerCorner = .()
    PowerCorner.CornerRadius = .(, )
    PowerCorner.Parent = PowerBtn
    
    PowerBtn.MouseButton1Click:(()
        ()
    )
    
     tabName, btn  (TabButtons) 
        btn.MouseButton1Click:(()
             name, b  (TabButtons) 
                 isActive = name == tabName
                TweenService:(b, TweenInfo.(), {
                    BackgroundTransparency = isActive    ,
                    BackgroundColor3 = isActive  Accent  GlassCard
                }):()
                b.TextColor3 = isActive  TextPrimary  TextSecondary
                b.Font = isActive  .Font.GothamBold  .Font.GothamMedium
                TabPanels[name].Visible = isActive
            
        )
    
    
      (parent, label, default, callback, layoutOrder)
         Frame = .()
        Frame.Size = .(, , , )
        Frame.BackgroundColor3 = GlassCard
        Frame.BackgroundTransparency = 
        Frame.BorderSizePixel = 
        Frame.LayoutOrder = layoutOrder  
        Frame.Parent = parent
        
         Corner = .()
        Corner.CornerRadius = .(, )
        Corner.Parent = Frame
        
         Label = .()
        Label.Size = .(, -, , )
        Label.Position = .(, , , )
        Label.BackgroundTransparency = 
        Label.Text = label
        Label.TextSize = 
        Label.Font = .Font.GothamMedium
        Label.TextColor3 = TextPrimary
        Label.TextXAlignment = .TextXAlignment.Left
        Label.Parent = Frame
        
         ToggleBg = .()
        ToggleBg.Size = .(, , , )
        ToggleBg.Position = .(, -, , -)
        ToggleBg.BackgroundColor3 = default  Accent  .(, , )
        ToggleBg.BorderSizePixel = 
        ToggleBg.Parent = Frame
        
         BgCorner = .()
        BgCorner.CornerRadius = .(, )
        BgCorner.Parent = ToggleBg
        
         Circle = .()
        Circle.Size = .(, , , )
        Circle.Position = default  .(, -, , -)  .(, , , -)
        Circle.BackgroundColor3 = TextPrimary
        Circle.BorderSizePixel = 
        Circle.Parent = ToggleBg
        
         CircleCorner = .()
        CircleCorner.CornerRadius = .(, )
        CircleCorner.Parent = Circle
        
         enabled = default
         Btn = .()
        Btn.Size = .(, , , )
        Btn.BackgroundTransparency = 
        Btn.Text = 
        Btn.Parent = Frame
        
        Btn.MouseButton1Click:(()
            enabled =  enabled
            TweenService:(ToggleBg, TweenInfo.(), {
                BackgroundColor3 = enabled  Accent  .(, , )
            }):()
            TweenService:(Circle, TweenInfo.(, .EasingStyle.Back), {
                Position = enabled  .(, -, , -)  .(, , , -)
            }):()
            (enabled)
        )
        
         Frame, (val)
            enabled = val
            ToggleBg.BackgroundColor3 = enabled  Accent  .(, , )
            Circle.Position = enabled  .(, -, , -)  .(, , , -)
        
    
    
      (parent, label, min, max, default, callback, layoutOrder)
         Frame = .()
        Frame.Size = .(, , , )
        Frame.BackgroundColor3 = GlassCard
        Frame.BackgroundTransparency = 
        Frame.BorderSizePixel = 
        Frame.LayoutOrder = layoutOrder  
        Frame.Parent = parent
        
         Corner = .()
        Corner.CornerRadius = .(, )
        Corner.Parent = Frame
        
         Label = .()
        Label.Size = .(, , , )
        Label.Position = .(, , , )
        Label.BackgroundTransparency = 
        Label.Text = label
        Label.TextSize = 
        Label.Font = .Font.GothamMedium
        Label.TextColor3 = TextPrimary
        Label.TextXAlignment = .TextXAlignment.Left
        Label.Parent = Frame
        
         Value = .()
        Value.Size = .(, , , )
        Value.Position = .(, -, , )
        Value.BackgroundTransparency = 
        Value.Text = (default)
        Value.TextSize = 
        Value.Font = .Font.GothamBold
        Value.TextColor3 = Accent
        Value.TextXAlignment = .TextXAlignment.Right
        Value.Parent = Frame
        
         SliderBg = .()
        SliderBg.Size = .(, -, , )
        SliderBg.Position = .(, , , )
        SliderBg.BackgroundColor3 = .(, , )
        SliderBg.BorderSizePixel = 
        SliderBg.Parent = Frame
        
         BgCorner = .()
        BgCorner.CornerRadius = .(, )
        BgCorner.Parent = SliderBg
        
         Fill = .()
        Fill.Size = .((default - min) / (max - min), , , )
        Fill.BackgroundColor3 = Accent
        Fill.BorderSizePixel = 
        Fill.Parent = SliderBg
        
         FillCorner = .()
        FillCorner.CornerRadius = .(, )
        FillCorner.Parent = Fill
        
         dragging = 
        
         SliderBtn = .()
        SliderBtn.Size = .(, , , )
        SliderBtn.Position = .(, , , )
        SliderBtn.BackgroundTransparency = 
        SliderBtn.Text = 
        SliderBtn.Parent = Frame
        
          (inputPos)
             pct = .((inputPos - SliderBg.AbsolutePosition.X) / SliderBg.AbsoluteSize.X, , )
             value = min + (max - min) * pct
             max >=  
                value = .(value)
            
                value = .(value * ) / 
            
            Fill.Size = .(pct, , , )
            Value.Text = (value)
            (value)
        
        
        SliderBtn.InputBegan:((input)
             input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
                dragging = 
                (input.Position.X)
            
        )
        
        SliderBtn.InputEnded:((input)
             input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
                dragging = 
            
        )
        
        Connections[ .. label] = UserInputService.InputChanged:((input)
             dragging  (input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch) 
                (input.Position.X)
            
        )
        
         Frame
    
    
      (parent, text, layoutOrder)
         Section = .()
        Section.Size = .(, , , )
        Section.BackgroundTransparency = 
        Section.Text = text
        Section.TextSize = 
        Section.Font = .Font.GothamBold
        Section.TextColor3 = Accent
        Section.LayoutOrder = layoutOrder  
        Section.Parent = parent
         Section
    
    
     ESP_Panel = TabPanels[]
    (ESP_Panel, , )
    (ESP_Panel, , Config.ESP_Enabled, (v) Config.ESP_Enabled = v , )
    (ESP_Panel, , Config.ESP_Box, (v) Config.ESP_Box = v , )
    (ESP_Panel, , Config.ESP_Name, (v) Config.ESP_Name = v , )
    (ESP_Panel, , Config.ESP_Health, (v) Config.ESP_Health = v , )
    (ESP_Panel, , Config.ESP_Distance, (v) Config.ESP_Distance = v , )
    (ESP_Panel, , Config.CHAMS_Enabled, (v) 
        Config.CHAMS_Enabled = v 
          v  Chams.() 
    , )
    (ESP_Panel, , , , Config.CHAMS_FillTransparency, (v) Config.CHAMS_FillTransparency = v , )
    (ESP_Panel, , Config.DRONE_ESP, (v) 
        Config.DRONE_ESP = v 
          v  DroneESP.() 
    , )
    (ESP_Panel, , , , Config.ESP_MaxDistance, (v) Config.ESP_MaxDistance = v , )
    
    ESP_Panel.CanvasSize = .(, , , )
    
     AIM_Panel = TabPanels[]
    (AIM_Panel, , )
    (AIM_Panel, , Config.AIM_Enabled, (v) 
        Config.AIM_Enabled = v 
        FOVCircle.Visible = Config.AIM_ShowFOV  v
    , )
    (AIM_Panel, , Config.AIM_ShowFOV, (v) 
        Config.AIM_ShowFOV = v 
        FOVCircle.Visible = v  Config.AIM_Enabled
    , )
    (AIM_Panel, , Config.AIM_Prediction, (v) Config.AIM_Prediction = v , )
    (AIM_Panel, , , , Config.AIM_FOV, (v) 
        Config.AIM_FOV = v 
        FOVCircle.Radius = v
    , )
    (AIM_Panel, , , , Config.AIM_Smooth, (v) Config.AIM_Smooth = v , )
    (AIM_Panel, , , , Config.AIM_PredictionAmount, (v) Config.AIM_PredictionAmount = v , )
    
    (AIM_Panel, , )
    (AIM_Panel, , Config.RECOIL_Enabled, (v) Config.RECOIL_Enabled = v , )
    (AIM_Panel, , , , Config.RECOIL_Strength, (v) Config.RECOIL_Strength = v , )
    (AIM_Panel, , Config.NO_CAMSHAKE, (v) Config.NO_CAMSHAKE = v , )
    
    AIM_Panel.CanvasSize = .(, , , )
    
     MISC_Panel = TabPanels[]
    (MISC_Panel, , )
     _, tpToggleSetter = (MISC_Panel, , Config.TP_Enabled, (v) Config.TP_Enabled = v , )
    (MISC_Panel, , , , Config.TP_Distance, (v) Config.TP_Distance = v , )
    (MISC_Panel, , Config.TP_AutoShoot, (v) Config.TP_AutoShoot = v , )
    
    (MISC_Panel, , )
    (MISC_Panel, , Config.ESP_HideSpawn, (v) Config.ESP_HideSpawn = v , )
    (MISC_Panel, , -, , Config.ESP_SpawnY, (v) Config.ESP_SpawnY = v , )
    
    (MISC_Panel, , )
    
     UnloadBtn = .()
    UnloadBtn.Size = .(, , , )
    UnloadBtn.BackgroundColor3 = .(, , )
    UnloadBtn.BackgroundTransparency = 
    UnloadBtn.BorderSizePixel = 
    UnloadBtn.Text = 
    UnloadBtn.TextSize = 
    UnloadBtn.Font = .Font.GothamBold
    UnloadBtn.TextColor3 = TextPrimary
    UnloadBtn.LayoutOrder = 
    UnloadBtn.Parent = MISC_Panel
    
     UnloadCorner = .()
    UnloadCorner.CornerRadius = .(, )
    UnloadCorner.Parent = UnloadBtn
    
    UnloadBtn.MouseButton1Click:(()
        ()
    )
    
    MISC_Panel.CanvasSize = .(, , , )
    
    MainContainer.Visible = Config.MenuOpen
    
     dragging = 
     dragStart, startPos
    
      (input)
         input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
            dragging = 
            dragStart = input.Position
            startPos = MainContainer.Position
        
    
    
      (input)
         input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
            dragging = 
        
    
    
    TopBar.InputBegan:(StartDrag)
    TopBar.InputEnded:(StopDrag)
    
    Connections[] = UserInputService.InputChanged:((input)
         dragging  (input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch) 
             delta = input.Position - dragStart
            MainContainer.Position = .(
                startPos.X.Scale, startPos.X.Offset + delta.X,
                startPos.Y.Scale, startPos.Y.Offset + delta.Y
            )
        
    )
    
     isMobile 
         MobileToggle = .()
        MobileToggle.Name = 
        MobileToggle.Size = .(, , , )
        MobileToggle.Position = .(, -, , )
        MobileToggle.BackgroundColor3 = GlassBg
        MobileToggle.BackgroundTransparency = 
        MobileToggle.BorderSizePixel = 
        MobileToggle.Text = 
        MobileToggle.TextSize = 
        MobileToggle.Font = .Font.GothamBold
        MobileToggle.TextColor3 = TextPrimary
        MobileToggle.Parent = ScreenGui
        
         MobileCorner = .()
        MobileCorner.CornerRadius = .(, )
        MobileCorner.Parent = MobileToggle
        
         MobileStroke = .()
        MobileStroke.Color = Accent
        MobileStroke.Thickness = 
        MobileStroke.Parent = MobileToggle
        
         visible = 
         mobileDragging = 
         mobileDragStart, mobileStartPos
        
        MobileToggle.MouseButton1Click:(()
              mobileDragging 
                visible =  visible
                MainContainer.Visible = visible
            
        )
        
        MobileToggle.InputBegan:((input)
             input.UserInputType == .UserInputType.Touch 
                mobileDragging = 
                mobileDragStart = input.Position
                mobileStartPos = MobileToggle.Position
            
        )
        
        MobileToggle.InputChanged:((input)
             input.UserInputType == .UserInputType.Touch 
                 delta = input.Position - mobileDragStart
                 delta.Magnitude >  
                    mobileDragging = 
                     screenSize = ScreenGui.AbsoluteSize
                     btnSize = MobileToggle.AbsoluteSize
                     newX = .(mobileStartPos.X.Offset + delta.X, , screenSize.X - btnSize.X - )
                     newY = .(mobileStartPos.Y.Offset + delta.Y, , screenSize.Y - btnSize.Y - )
                    MobileToggle.Position = .(, newX, , newY)
                
            
        )
        
        MobileToggle.InputEnded:((input)
             input.UserInputType == .UserInputType.Touch 
                .()
                mobileDragging = 
            
        )
        
        MobileTPBtn = .()
        MobileTPBtn.Name = 
        MobileTPBtn.Size = .(, , , )
        MobileTPBtn.Position = .(, -, , -)
        MobileTPBtn.BackgroundColor3 = .(, , )
        MobileTPBtn.BackgroundTransparency = 
        MobileTPBtn.BorderSizePixel = 
        MobileTPBtn.Text = 
        MobileTPBtn.TextSize = 
        MobileTPBtn.Font = .Font.GothamBold
        MobileTPBtn.TextColor3 = TextPrimary
        MobileTPBtn.Visible = Config.TP_Enabled
        MobileTPBtn.Parent = ScreenGui
        
         TPCorner = .()
        TPCorner.CornerRadius = .(, )
        TPCorner.Parent = MobileTPBtn
        
         TPStroke = Instance.new("UIStroke")
        TPStroke.Color = Accent
        TPStroke.Thickness = 2
        TPStroke.Parent = MobileTPBtn
        
        local tpDragging = false
        local tpDragStart, tpStartPos
        
        MobileTPBtn.MouseButton1Click:Connect(function()
            if not tpDragging then
                TPActive = not TPActive
                
                if TPActive then
                    TPTarget = GetClosestEnemy()
                    TPShotCount = 0
                    TPMagSize = GetMagSize()
                    MobileTPBtn.BackgroundColor3 = Accent
                    MobileTPBtn.Text = "ON"
                else
                    TPTarget = nil
                    MobileTPBtn.BackgroundColor3 = Color3.fromRGB(60, 65, 75)
                    MobileTPBtn.Text = "TP"
                end
            end
        end)
        
        MobileTPBtn.InputBegan:Connect(function(input)
            if input.UserInputType == Enum.UserInputType.Touch then
                tpDragging = false
                tpDragStart = input.Position
                tpStartPos = MobileTPBtn.Position
            end
        end)
        
        MobileTPBtn.InputChanged:Connect(function(input)
            if input.UserInputType == Enum.UserInputType.Touch then
                local delta = input.Position - tpDragStart
                if delta.Magnitude > 10 then
                    tpDragging = true
                    local screenSize = ScreenGui.AbsoluteSize
                    local btnSize = MobileTPBtn.AbsoluteSize
                    local newX = math.clamp(tpStartPos.X.Offset + delta.X, 10, screenSize.X - btnSize.X - 10)
                    local newY = math.clamp(tpStartPos.Y.Offset + delta.Y, 50, screenSize.Y - btnSize.Y - 10)
                    MobileTPBtn.Position = UDim2.new(0, newX, 0, newY)
                end
            end
        end)
        
        MobileTPBtn.InputEnded:Connect(function(input)
            if input.UserInputType == Enum.UserInputType.Touch then
                task.wait(0.1)
                tpDragging = false
            end
        end)
    end
    
    return ScreenGui, MainContainer
end

Unload = function()
    if State.Unloaded then return end
    State.Unloaded = true
    
    Config.TP_Enabled = false
    TPActive = false
    
    for _, conn in pairs(Connections) do
        pcall(function() conn:Disconnect() end)
    end
    Connections = {}
    
    for player, esp in pairs(ESP.cache) do
        ESP.Hide(esp)
        ESP.Destroy(esp)
    end
    ESP.cache = {}
    
    Chams.ClearAll()
    DroneESP.ClearAll()
    
    pcall(function() FOVCircle:Remove() end)
    
    if ScreenGui then
        pcall(function() ScreenGui:Destroy() end)
        ScreenGui = nil
    end
    
    pcall(function()
        local gui = game:GetService("CoreGui"):FindFirstChild("WarfareESP")
        if gui then gui:Destroy() end
    end)
    pcall(function()
        local gui = LocalPlayer.PlayerGui:FindFirstChild("WarfareESP")
        if gui then gui:Destroy() end
    end)
    
    State.PatchedTables = {}
    State.RecoilModulesPatched = false
    
    getgenv().WarfareESP = nil
end

local function UpdateMobileTPButton()
    if MobileTPBtn then
        MobileTPBtn.Visible = Config.TP_Enabled
        if not Config.TP_Enabled then
            TPActive = false
            MobileTPBtn.BackgroundColor3 = Color3.fromRGB(60, 65, 75)
            MobileTPBtn.Text = "TP"
        end
        if TPActive then
            MobileTPBtn.BackgroundColor3 = Color3.fromRGB(220, 60, 60)
            MobileTPBtn.Text = "ON"
        else
            MobileTPBtn.BackgroundColor3 = Color3.fromRGB(60, 65, 75)
            MobileTPBtn.Text = "TP"
        end
    end
end

local function Init()
    local gui, mainFrame = CreateMenu()
    
    Connections.Render = RunService.RenderStepped:Connect(function()
        MainLoop()
        UpdateMobileTPButton()
    end)
    
    Connections.PlayerRemoving = Players.PlayerRemoving:Connect(function(player)
        ESP.Remove(player)
        VisibilityCache[player] = nil
        local char = player.Character
        if char then Chams.Remove(char) end
    end)
    
    Connections.CharacterAdded = LocalPlayer.CharacterAdded:Connect(function(char)
        State.RecoilModulesPatched = false
        State.ShotsFired = 0
        State.IsFiring = false
    end)
    
    for _, player in pairs(Players:GetPlayers()) do
        if player ~= LocalPlayer then
            player.CharacterAdded:Connect(function(char)
                ESP.Remove(player)
                Chams.Remove(player.Character)
            end)
        end
    end
    
    Connections.PlayerAdded = Players.PlayerAdded:Connect(function(player)
        player.CharacterAdded:Connect(function(char)
            ESP.Remove(player)
        end)
    end)
    
    Connections.Input = UserInputService.InputBegan:Connect(function(input, processed)
        if processed then return end
        
        if input.KeyCode == Config.MenuKey or input.KeyCode == Enum.KeyCode.RightShift then
            Config.MenuOpen = not Config.MenuOpen
            mainFrame.Visible = Config.MenuOpen
        end
        
        if input.KeyCode == Enum.KeyCode.End then
            Unload()
        end
    end)
end

Init()

getgenv().WarfareESP = {
    Config = Config,
    Unload = Unload,
    State = State
}