UNIVERSAL ESP AIMLOCK V2

 Players = :()
 RunService = :()
 TweenService = :()
 UIS = :()
 LocalPlayer = Players.LocalPlayer





 GameDataSystem = {}

 GameDataSystem.()
      Players   Players.GetPlayers   {} 
     success, players = (()  Players:() )
     success  players  {}


 GameDataSystem.()
     LocalPlayer  


 GameDataSystem.()
         .CurrentCamera    
     .CurrentCamera


 GameDataSystem.(player)
     player  player:(Players)


 GameDataSystem.(player)
      GameDataSystem.(player)    
     player.Character


 GameDataSystem.(character)
     character  character:()


 GameDataSystem.(character)
      GameDataSystem.(character)    
     character:()


 GameDataSystem.(character)
      GameDataSystem.(character)    
     character:()


 GameDataSystem.(character)
      GameDataSystem.(character)    
     character:()


 GameDataSystem.(player)
      GameDataSystem.(player)    
     player.Team


 GameDataSystem.(part)
      part   part:()   part:() 
         .zero
    
     success, pos = (()  part.Position )
     success  pos  (pos) ==   pos  .zero


 GameDataSystem.(part)
      part   part:()   part:() 
         .zero
    
     success, vel = (()  part.AssemblyLinearVelocity )
     success  vel  (vel) ==   vel  .zero


 GameDataSystem.(humanoid)
      humanoid   humanoid:()    
     success, health = (()  humanoid.Health )
     success  (health) ==   health > 


 GameDataSystem.(camera)
      camera   .zero 
     success, size = (()  camera.ViewportSize )
     success  size  .zero


 GameDataSystem.()
      UIS   UIS.GetMouseLocation   .zero 
     success, pos = (()  UIS:() )
     success  pos  .zero





 Config = {
    AIM_ENABLED = ,
    FOV_SIZE = ,         
    SMOOTHNESS = ,     
    HEAD_PRIORITY = ,  
    PREDICTION_ENABLED = , 
    PREDICTION_TIME = , 
    UI_VISIBLE = ,
    WINDOW_ACTIVE = ,
    HEAD_BONUS_STRENGTH =   
}




().ESP_Settings = {
    Enabled = ,              
    ToggleKey = .KeyCode.RightShift,

    DistanciaLimite = ,       

    TeamCheck = ,            
    TeamColor = .(, , ),      
    EnemyColor = .(, , ),     

    TextSize = ,
    BoxThickness = ,

    
    ButtonConfig = {
        Size = .(, ),
        TextColor = .(, , ),
        EnabledColor = .(, , ),
        DisabledColor = .(, , ),
        TextFont = ,
        TextSize = 
    }
}




 WindowFocus = {
    janelaEmFoco = ,
    aimAtivo = ,
    alvoAtual = 
}

 WindowFocus.()
    UIS.WindowFocused:(()
        WindowFocus.janelaEmFoco = 
        ()
    )

    UIS.WindowFocusReleased:(()
        WindowFocus.janelaEmFoco = 
        WindowFocus.aimAtivo = 
        WindowFocus.alvoAtual = 
        ()
    )

    WindowFocus.janelaEmFoco = 





 EnemyDetector = {}

 EnemyDetector.(player)
    
      GameDataSystem.(player)  player == LocalPlayer    

     playerTeam = GameDataSystem.(player)
     localTeam = GameDataSystem.(GameDataSystem.())

     playerTeam  localTeam 
         playerTeam ~= localTeam
    

    
     success1, playerAttrs = (()  player:() )
     success2, localAttrs = (()  LocalPlayer:() )

     success1  success2  playerAttrs  localAttrs 
         attrName, attrValue  (playerAttrs) 
             (attrName) ==   (attrName:():()  attrName:():()) 
                 localAttrValue = localAttrs[attrName]
                 localAttrValue  attrValue ~= localAttrValue 
                      
                
            
        
    

      


 EnemyDetector.(player)
    
      GameDataSystem.(player)    

     character = GameDataSystem.(player)
      character   GameDataSystem.(character)    

     humanoid = GameDataSystem.(character)
     GameDataSystem.(humanoid)





 BodyPartSelector = {}


 BodyPartSelector.(character)
    
      GameDataSystem.(character)    

    
     head = character:()
     head  head:()  head:(character) 
         head
    

    
     headNames = {, , }
     _, name  (headNames) 
         (name) ==  
             found = character:(name)
             found  found:()  found:(character) 
                 found
            
        
    

     



 BodyPartSelector.(bodyPart, predictionTime)
    
      bodyPart   bodyPart:()   bodyPart:() 
         GameDataSystem.(bodyPart)
    

      Config.PREDICTION_ENABLED  (predictionTime) ~=   predictionTime <=  
         GameDataSystem.(bodyPart)
    

    
     position = GameDataSystem.(bodyPart)
     velocity = GameDataSystem.(bodyPart)

    
     position ~= .zero  velocity ~= .zero 
         position + (velocity * predictionTime)
    

     position



 BodyPartSelector.(character)
    
      GameDataSystem.(character)    

    
     Config.HEAD_PRIORITY 
         head = BodyPartSelector.(character)
         head 
             head 
        
    

    
     fallbacks = {
        character:(),
        character:(),
        character:()
    }

     _, part  (fallbacks) 
         part  part:()  part:(character) 
             part
        
    

     





 FOVSystem = {
    circulo = 
}

 FOVSystem.()
     FOVSystem.circulo  FOVSystem.circulo:() 

    FOVSystem.circulo = .()
    FOVSystem.circulo.Thickness = 
    FOVSystem.circulo.NumSides = 
    FOVSystem.circulo.Radius = Config.FOV_SIZE
    FOVSystem.circulo.Filled = 
    FOVSystem.circulo.Color = .(, , )
    FOVSystem.circulo.Transparency = 
    FOVSystem.circulo.Visible = 


 FOVSystem.(posicaoMundo, camera)
    
      posicaoMundo  (posicaoMundo) ~=    camera    

     centroTela = GameDataSystem.(camera)
     centroTela == .zero    
    centroTela = centroTela / 

     success, screenPos, visible = (()
         camera:(posicaoMundo)
    )

      success   visible   screenPos    

     distancia = (.(screenPos.X, screenPos.Y) - centroTela).Magnitude
     distancia <= Config.FOV_SIZE


 FOVSystem.()
      FOVSystem.circulo   

     camera = GameDataSystem.()
      camera   

     centro = GameDataSystem.(camera)
     centro == .zero   
    centro = centro / 

    FOVSystem.circulo.Position = centro
    FOVSystem.circulo.Radius = Config.FOV_SIZE
    FOVSystem.circulo.Visible = WindowFocus.aimAtivo  WindowFocus.janelaEmFoco





 TargetSelector = {}

 TargetSelector.(camera)
    
      camera    

     melhorAlvo = 
     menorDistancia = Config.FOV_SIZE
     centroTela = GameDataSystem.(camera)
     centroTela == .zero    
    centroTela = centroTela / 

     _, player  (GameDataSystem.()) 
        
          EnemyDetector.(player)   EnemyDetector.(player) 
            
        

        
         character = GameDataSystem.(player)
          character   

         head = BodyPartSelector.(character)
          head   

        
         targetPosition = BodyPartSelector.(head, Config.PREDICTION_TIME)
         targetPosition == .zero   

        
          FOVSystem.(targetPosition, camera) 
            
        

        
         success, screenPos, visible = (()
             camera:(targetPosition)
        )

          success   visible   screenPos   

         distancia = (.(screenPos.X, screenPos.Y) - centroTela).Magnitude

         distancia < menorDistancia 
            menorDistancia = distancia
            melhorAlvo = player
        
    

     melhorAlvo





 AimController = {
    suavizacao = Config.SMOOTHNESS
}

 AimController.(alvoAtual, camera)
    
      WindowFocus.janelaEmFoco   WindowFocus.aimAtivo 
        
    

    
      alvoAtual   alvoAtual:(Players) 
        WindowFocus.alvoAtual = 
        
    

      EnemyDetector.(alvoAtual) 
        WindowFocus.alvoAtual = 
        
    

     character = alvoAtual.Character
      character   character:() 
        WindowFocus.alvoAtual = 
        
    

    
     head = BodyPartSelector.(character)
      head   head:(character) 
        
        head = character:()  character:()
          head 
            WindowFocus.alvoAtual = 
            
        
    

    
     targetPosition = BodyPartSelector.(head, Config.PREDICTION_TIME)

    
      FOVSystem.(targetPosition, camera) 
        
         currentPos = GameDataSystem.(head)
         currentPos == .zero   FOVSystem.(currentPos, camera) 
            WindowFocus.alvoAtual = 
            
        
        targetPosition = currentPos
    

    
     success, screenPos, visible = (()
         camera:(targetPosition)
    )

      success   visible   screenPos 
        WindowFocus.alvoAtual = 
        
    

    
     screenCenter = GameDataSystem.(camera)
     screenCenter == .zero   
    screenCenter = screenCenter / 

     screenDistance = (.(screenPos.X, screenPos.Y) - screenCenter).Magnitude
     screenDistance > Config.FOV_SIZE *    
        WindowFocus.alvoAtual = 
        
    

    
     mousePos = GameDataSystem.()
     mousePos == .zero   

    
     delta = .(screenPos.X, screenPos.Y) - mousePos

    
    
     distanceFactor = screenDistance / Config.FOV_SIZE
     adaptiveThreshold = .(,  - (distanceFactor * )) 

     .(delta.X) > adaptiveThreshold  .(delta.Y) > adaptiveThreshold 
        
         adaptiveSmoothness = Config.SMOOTHNESS * ( + distanceFactor * ) 

        
         headBonus = Config.HEAD_BONUS_STRENGTH 
        adaptiveSmoothness = adaptiveSmoothness * headBonus

        
         maxMove = .( + (distanceFactor * ), , ) 
         moveX = .(delta.X * adaptiveSmoothness, -maxMove, maxMove)
         moveY = .(delta.Y * adaptiveSmoothness, -maxMove, maxMove)

        
         moveX == moveX  moveY == moveY  
           .(moveX) >   .(moveY) >   

            
             moveSuccess = (()
                (moveX, moveY)
            )

             moveSuccess 
                
                 FOVSystem.circulo 
                    
                     colorIntensity =  - .(distanceFactor, )
                    FOVSystem.circulo.Color = .(, colorIntensity, ) 
                
            
                (, alvoAtual.Name)
            
        
    
        
         FOVSystem.circulo 
            FOVSystem.circulo.Color = .(, , )
        
    





 UIController = {
    painel = ,
    gui = ,
    dragging = ,
    dragStart = ,
    startPos = 
}



 UIController.()
     playerGui = LocalPlayer:(, )
      playerGui   

    UIController.gui = .()
    UIController.gui.Name = 
    UIController.gui.ResetOnSpawn = 
    UIController.gui.Enabled = 
    UIController.gui.Parent = playerGui

    
    UIController.painel = .()
    UIController.painel.Size = .(, , , )
    UIController.painel.Position = .(, -, , )
    UIController.painel.AnchorPoint = .(, )
    UIController.painel.BackgroundColor3 = .(, , )
    UIController.painel.BackgroundTransparency =  
    UIController.painel.BorderSizePixel = 
    UIController.painel.BorderColor3 = .(, , )
    UIController.painel.Parent = UIController.gui
    UIController.painel.Active = 
    UIController.painel.Visible = 

    
     corner = .()
    corner.CornerRadius = .(, )
    corner.Parent = UIController.painel

    
     header = .()
    header.Size = .(, , , )
    header.BackgroundTransparency = 
    header.Parent = UIController.painel

     title = .()
    title.Size = .(, -, , )
    title.Position = .(, , , )
    title.BackgroundTransparency = 
    title.Text = 
    title.Font = .Font.GothamBold
    title.TextSize = 
    title.TextColor3 = .(, , )
    title.TextXAlignment = .TextXAlignment.Left
    title.Parent = header

    
     content = .()
    content.Size = .(, -, , -)
    content.Position = .(, , , )
    content.BackgroundTransparency = 
    content.Parent = UIController.painel

    
     yOffset = 

    
     aimSection = .()
    aimSection.Size = .(, , , )
    aimSection.Position = .(, , , yOffset)
    aimSection.BackgroundTransparency = 
    aimSection.Parent = content

    
     aimTitle = .()
    aimTitle.Size = .(, , , )
    aimTitle.BackgroundTransparency = 
    aimTitle.Text = 
    aimTitle.Font = .Font.GothamMedium
    aimTitle.TextSize = 
    aimTitle.TextColor3 = .(, , )
    aimTitle.TextXAlignment = .TextXAlignment.Left
    aimTitle.Parent = aimSection

    
     aimToggle = .()
    aimToggle.Size = .(, , , )
    aimToggle.Position = .(, , , )
    aimToggle.BackgroundColor3 = WindowFocus.aimAtivo  .(, , )  .(, , )
    aimToggle.BackgroundTransparency =  
    aimToggle.Text = WindowFocus.aimAtivo    
    aimToggle.Font = .Font.GothamBold
    aimToggle.TextSize = 
    aimToggle.TextColor3 = .(, , )
    aimToggle.BorderSizePixel = 
    aimToggle.Parent = aimSection

     aimCorner = .()
    aimCorner.CornerRadius = .(, )
    aimCorner.Parent = aimToggle

    

    yOffset = yOffset + 

    
     espSection = .()
    espSection.Size = .(, , , )
    espSection.Position = .(, , , yOffset)
    espSection.BackgroundTransparency = 
    espSection.Parent = content

    
     espTitle = .()
    espTitle.Size = .(, , , )
    espTitle.BackgroundTransparency = 
    espTitle.Text = 
    espTitle.Font = .Font.GothamMedium
    espTitle.TextSize = 
    espTitle.TextColor3 = .(, , )
    espTitle.TextXAlignment = .TextXAlignment.Left
    espTitle.Parent = espSection

    
     espToggle = .()
    espToggle.Size = .(, , , )
    espToggle.Position = .(, , , )
    espToggle.BackgroundColor3 = ().ESP_Settings.Enabled  .(, , )  .(, , )
    espToggle.BackgroundTransparency =  
    espToggle.Text = ().ESP_Settings.Enabled    
    espToggle.Font = .Font.GothamBold
    espToggle.TextSize = 
    espToggle.TextColor3 = .(, , )
    espToggle.BorderSizePixel = 
    espToggle.Parent = espSection

     espCorner = .()
    espCorner.CornerRadius = .(, )
    espCorner.Parent = espToggle

    

    yOffset = yOffset + 

    
     fovSection = .()
    fovSection.Size = .(, , , )
    fovSection.Position = .(, , , yOffset)
    fovSection.BackgroundTransparency = 
    fovSection.Parent = content

    
     fovTitle = .()
    fovTitle.Size = .(, , , )
    fovTitle.BackgroundTransparency = 
    fovTitle.Text = 
    fovTitle.Font = .Font.GothamMedium
    fovTitle.TextSize = 
    fovTitle.TextColor3 = .(, , )
    fovTitle.TextXAlignment = .TextXAlignment.Left
    fovTitle.Parent = fovSection

    
     fovValue = .()
    fovValue.Size = .(, , , )
    fovValue.Position = .(, -, , )
    fovValue.BackgroundTransparency = 
    fovValue.Text = (Config.FOV_SIZE)
    fovValue.Font = .Font.GothamMedium
    fovValue.TextSize = 
    fovValue.TextColor3 = .(, , )
    fovValue.TextXAlignment = .TextXAlignment.Right
    fovValue.Parent = fovSection

    
     sliderBg = .()
    sliderBg.Size = .(, -, , ) 
    sliderBg.Position = .(, , , )
    sliderBg.BackgroundColor3 = .(, , )
    sliderBg.BackgroundTransparency =  
    sliderBg.BorderSizePixel = 
    sliderBg.Parent = fovSection

     sliderCorner = .()
    sliderCorner.CornerRadius = .(, ) 
    sliderCorner.Parent = sliderBg

    
     sliderFill = .()
    sliderFill.Size = .((Config.FOV_SIZE - ) / , )
    sliderFill.BackgroundColor3 = .(, , )
    sliderFill.BackgroundTransparency =  
    sliderFill.BorderSizePixel = 
    sliderFill.Parent = sliderBg

     fillCorner = .()
    fillCorner.CornerRadius = .(, )
    fillCorner.Parent = sliderFill

    
     sliderHandle = .()
    sliderHandle.Size = .(, , , ) 
    sliderHandle.Position = .((Config.FOV_SIZE - ) /  - , -)
    sliderHandle.BackgroundColor3 = .(, , )
    sliderHandle.BackgroundTransparency = 
    sliderHandle.BorderSizePixel = 
    sliderHandle.Parent = sliderBg

     handleCorner = .()
    handleCorner.CornerRadius = .(, ) 
    handleCorner.Parent = sliderHandle

    
     handleShadow = .()
    handleShadow.Size = .(, , , )
    handleShadow.Position = .(, -, , -)
    handleShadow.BackgroundColor3 = .(, , )
    handleShadow.BackgroundTransparency = 
    handleShadow.BorderSizePixel = 
    handleShadow.ZIndex = -
     shadowCorner = .()
    shadowCorner.CornerRadius = .(, )
    shadowCorner.Parent = handleShadow
    handleShadow.Parent = sliderHandle

    
     minFOV = 
     maxFOV = 
     draggingSlider = 

    
      ()
         percent = (Config.FOV_SIZE - minFOV) / (maxFOV - minFOV)
        sliderFill.Size = .(.(percent, , ), )
        sliderHandle.Position = .(.(percent - , -, ), -)
        fovValue.Text = (Config.FOV_SIZE)
    

    
    sliderBg.InputBegan:((input)
         input.UserInputType == .UserInputType.MouseButton1 
            draggingSlider = 
             percent = .((input.Position.X - sliderBg.AbsolutePosition.X) / sliderBg.AbsoluteSize.X, , )
            Config.FOV_SIZE = .(minFOV + (maxFOV - minFOV) * percent)
            ()
        
    )

    sliderBg.InputEnded:((input)
         input.UserInputType == .UserInputType.MouseButton1 
            draggingSlider = 
        
    )

    sliderHandle.InputBegan:((input)
         input.UserInputType == .UserInputType.MouseButton1 
            draggingSlider = 
        
    )

    sliderHandle.InputEnded:((input)
         input.UserInputType == .UserInputType.MouseButton1 
            draggingSlider = 
        
    )

    
    UIS.InputChanged:((input)
         draggingSlider  input.UserInputType == .UserInputType.MouseMovement 
             percent = .((input.Position.X - sliderBg.AbsolutePosition.X) / sliderBg.AbsoluteSize.X, , )
            Config.FOV_SIZE = .(minFOV + (maxFOV - minFOV) * percent)
            ()
        
    )

    
    header.InputBegan:((input)
         input.UserInputType == .UserInputType.MouseButton1 
            UIController.dragging = 
            UIController.dragStart = input.Position
            UIController.startPos = UIController.painel.Position
        
    )

    header.InputEnded:((input)
         input.UserInputType == .UserInputType.MouseButton1 
            UIController.dragging = 
        
    )

    UIS.InputChanged:((input)
         UIController.dragging  input.UserInputType == .UserInputType.MouseMovement 
             camera = .CurrentCamera
              camera   

             delta = (input.Position - UIController.dragStart)
             newPos = .(
                UIController.startPos.X.Scale + (delta.X / camera.ViewportSize.X),
                ,
                UIController.startPos.Y.Scale + (delta.Y / camera.ViewportSize.Y),
                
            )

            UIController.painel.Position = .(
                .(newPos.X.Scale, , ),
                .(newPos.Y.Scale, , )
            )
        
    )

    
    
    aimToggle.MouseButton1Click:(()
        
        WindowFocus.aimAtivo =  WindowFocus.aimAtivo

        
        aimToggle.BackgroundColor3 = WindowFocus.aimAtivo  .(, , )  .(, , )
        aimToggle.Text = WindowFocus.aimAtivo    

        
          WindowFocus.aimAtivo 
            WindowFocus.alvoAtual = 
        

        (, WindowFocus.aimAtivo    )
    )

    
    espToggle.MouseButton1Click:(()
        
        ().ESP_Settings.Enabled =  ().ESP_Settings.Enabled

        
        espToggle.BackgroundColor3 = ().ESP_Settings.Enabled  .(, , )  .(, , )
        espToggle.Text = ().ESP_Settings.Enabled    

        (, ().ESP_Settings.Enabled    )
    )

    

    
    UIS.InputBegan:((input, gameProcessed)
         gameProcessed   
         input.KeyCode == .KeyCode.Insert 
            UIController.painel.Visible =  UIController.painel.Visible
        
    )





  ()
    ()

    
    ().ESP_Settings = ().ESP_Settings  {
        Enabled = ,
        ToggleKey = .KeyCode.RightShift,
        DistanciaLimite = ,
        TeamCheck = ,
        TeamColor = .(, , ),
        EnemyColor = .(, , ),
        TextSize = ,
        BoxThickness = 
    }

    
     success,  = (()
        (:())()
    )

     success 
        ()
        ()
        ()
        ()
        ()
    
        (, )
        ()
    





()


WindowFocus.()
FOVSystem.()
UIController.()


()

()
()
( .. Config.FOV_SIZE)
( .. Config.SMOOTHNESS)
( .. .(Config.HEAD_BONUS_STRENGTH * ) .. )
()
()
()
()




RunService.RenderStepped:(()
    
    

    
     camera = GameDataSystem.()
      camera   

     viewportCenter = GameDataSystem.(camera)
     viewportCenter == .zero   
    viewportCenter = viewportCenter / 

    
    
     WindowFocus.aimAtivo 
        
          WindowFocus.janelaEmFoco 
             
        

        
         WindowFocus.alvoAtual   EnemyDetector.(WindowFocus.alvoAtual) 
            WindowFocus.alvoAtual = 
        

        
          WindowFocus.alvoAtual 
            WindowFocus.alvoAtual = TargetSelector.(camera)
        

        
         WindowFocus.alvoAtual 
            AimController.(WindowFocus.alvoAtual, camera)
        
    

    
    FOVSystem.()
)

()
()
()
()
( .. .(Config.HEAD_BONUS_STRENGTH * ) .. )
()
()
()
()
()