Aimbot and Esp by DeepSeek AI Lol

 Players = :()
 RunService = :()
 UserInputService = :()
 Camera = .CurrentCamera
 LocalPlayer = Players.LocalPlayer

 Sense = (:())()
 Rayfield = (:())()

 Window = Rayfield:({
    Name = ,
    LoadingTitle = ,
    LoadingSubtitle = ,
    ConfigurationSaving = {
        Enabled = ,
        FolderName = ,
        FileName = 
    },
    Discord = {
        Enabled = ,
        Invite = ,
        RememberJoins = 
    },
    KeySystem = 
})

 ESPTab = Window:(, )
 AimbotTab = Window:(, )

 aimbotSettings = {
    enabled = ,
    wallCheck = ,
    teamCheck = ,
    ignoreDead = ,
    targetPart = ,
    fov = ,
    maxDistance = .huge,
    smoothness = ,
    prioritizeClosest = ,
    mouseMoveRel = ,
}

 targetLocked = 

ESPTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        Sense.teamSettings.enemy.enabled = value
        Sense.teamSettings.friendly.enabled = value
    
})

ESPTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        Sense.sharedSettings.useTeamColor = value
    
})

ESPTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        Sense.teamSettings.enemy.box = value
        Sense.teamSettings.friendly.box = value
    
})

ESPTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        Sense.teamSettings.enemy.tracer = value
        Sense.teamSettings.friendly.tracer = value
    
})

ESPTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        Sense.teamSettings.enemy.healthBar = value
        Sense.teamSettings.friendly.healthBar = value
    
})

ESPTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        Sense.teamSettings.enemy.name = value
        Sense.teamSettings.friendly.name = value
    
})

Sense.teamSettings.enemy.boxColor = {.(, , ), }
Sense.teamSettings.enemy.tracerColor = {.(, , ), }
Sense.teamSettings.enemy.nameColor = {.(, , ), }
Sense.()

AimbotTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        aimbotSettings.enabled = value
          value 
            targetLocked = 
        
    
})

AimbotTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        aimbotSettings.wallCheck = value
    
})

AimbotTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        aimbotSettings.teamCheck = value
    
})

AimbotTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        aimbotSettings.ignoreDead = value
    
})

AimbotTab:({
    Name = ,
    Options = {, , , , , , },
    CurrentOption = ,
    Callback = (value)
        aimbotSettings.targetPart = value
    
})

AimbotTab:({
    Name = ,
    PlaceholderText = ,
    Callback = (value)
         num = (value)
         num 
            aimbotSettings.fov = num
        
            aimbotSettings.fov = 
        
    
})

AimbotTab:({
    Name = ,
    PlaceholderText = ,
    RemoveTextAfterFocusLost = ,
    Callback = (text)
        aimbotSettings.targetPart = text
    
})

AimbotTab:({
    Name = ,
    PlaceholderText = ,
    Callback = (value)
         num = (value)
         num 
            aimbotSettings.smoothness = .(num, , )
        
            aimbotSettings.smoothness = 
        
    
})

AimbotTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        aimbotSettings.prioritizeClosest = value
    
})

AimbotTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        aimbotSettings.mouseMoveRel = value
    
})

  (targetPos, targetChar)
      aimbotSettings.wallCheck    
     origin = Camera.CFrame.Position
     direction = (targetPos - origin).Unit
     distance = (targetPos - origin).Magnitude

     raycastParams = RaycastParams.()
    raycastParams.FilterDescendantsInstances = {LocalPlayer.Character, targetChar}
    raycastParams.FilterType = .RaycastFilterType.Blacklist
    raycastParams.IgnoreWater = 

     raycastResult = :(origin, direction * distance, raycastParams)
     raycastResult   raycastResult.Instance:(targetChar) 
         
    

     


  (player)
      aimbotSettings.teamCheck    
     player.Team ~= LocalPlayer.Team


  (player)
     player == LocalPlayer    
      (player)    
     char = player.Character
      char    
     humanoid = char:()
     rootPart = char:()
      humanoid   rootPart    
     aimbotSettings.ignoreDead  humanoid.Health <=     
     , char, rootPart


  (character)
     character:(aimbotSettings.targetPart)  character:()


  ()
     closestTarget = 
     closestFov = aimbotSettings.fov
     localChar = LocalPlayer.Character
      localChar    
     localRoot = localChar:()
      localRoot    

     _, player  (Players:()) 
         valid, char, rootPart = (player)
         valid 
             part = (char)
             part 
                 screenPos, onScreen = Camera:(part.Position)
                 onScreen 
                     mousePos = UserInputService:()
                     dist = (.(screenPos.X, screenPos.Y) - .(mousePos.X, mousePos.Y)).Magnitude
                     magnitudeCheck = (part.Position - localRoot.Position).Magnitude

                     dist <= closestFov  magnitudeCheck <= aimbotSettings.maxDistance  (part.Position, char) 
                          closestTarget  (aimbotSettings.prioritizeClosest  magnitudeCheck < (closestTarget.Distance  .huge)) 
                            closestTarget = {Player = player, Part = part, Distance = magnitudeCheck, ScreenDistance = dist}
                        
                    
                
            
        
    

     closestTarget 
         closestTarget.Part, closestTarget.Player
    
     , 


  ()
      aimbotSettings.enabled 
        targetLocked = 
        
    

     targetLocked 
         valid, char = (targetLocked)
          valid   char 
            targetLocked = 
        
             part = (char)
              part   (part.Position, char) 
                targetLocked = 
            
        
    

      targetLocked 
         part, player = ()
        targetLocked = player
    

     targetLocked  targetLocked.Character 
         part = (targetLocked.Character)
         part 
             aimbotSettings.mouseMoveRel 
                 mousePos = UserInputService:()
                 screenPos, onScreen = Camera:(part.Position)
                 onScreen 
                     dx = (screenPos.X - mousePos.X) * aimbotSettings.smoothness
                     dy = (screenPos.Y - mousePos.Y) * aimbotSettings.smoothness
                    (dx, dy)
                
            
                 currentCF = Camera.CFrame
                 targetPos = part.Position
                 newCF = .(currentCF.Position, targetPos)
                Camera.CFrame = currentCF:(newCF,  - aimbotSettings.smoothness)
            
        
    


RunService.RenderStepped:(updateAimbot)