universal trash aimbot

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


 GUI_NAME = 
 SNAP_TIME = 
 ESP_REFRESH = 
 CAMERA_BIND = 

 MAX_Y_DIFFERENCE =  
 CHECK_WALLS = 

 PANEL_SIZE = .(, )
 TOGGLE_SIZE = .(, )

 PANEL_COLOR = .(, , )
 HEADER_COLOR = .(, , )
 BUTTON_OFF = .(, , )
 BUTTON_ON = .(, , )

 ENEMY_COLOR = .(, , )
 TEAM_COLOR = .(, , )
 NPC_COLOR = .(, , )

 LocalPlayer = Players.LocalPlayer
 PlayerGui = LocalPlayer:()


 OldGui = PlayerGui:(GUI_NAME)
 OldGui 
    OldGui:()


RunService:(CAMERA_BIND)

 Connections = {}

  (signal, callback)
     connection = signal:(callback)
    .(Connections, connection)
     connection



 ScreenGui = .()
ScreenGui.Name = GUI_NAME
ScreenGui.ResetOnSpawn = 
ScreenGui.IgnoreGuiInset = 
ScreenGui.ZIndexBehavior = .ZIndexBehavior.Sibling
ScreenGui.Parent = PlayerGui

  (object, radius)
     corner = .()
    corner.CornerRadius = .(, radius)
    corner.Parent = object
     corner


  (object, color, thickness)
     stroke = .()
    stroke.Color = color
    stroke.Thickness = thickness
    stroke.Parent = object
     stroke



 MainPanel = .()
MainPanel.Name = 
MainPanel.Size = PANEL_SIZE
MainPanel.AnchorPoint = .(, )
MainPanel.Position = .(, , , -)
MainPanel.BackgroundColor3 = PANEL_COLOR
MainPanel.BorderSizePixel = 
MainPanel.Active = 
MainPanel.Parent = ScreenGui

(MainPanel, )
(MainPanel, .(, , ), )


 Header = .()
Header.Name = 
Header.Size = .(, , , )
Header.BackgroundColor3 = HEADER_COLOR
Header.BorderSizePixel = 
Header.Active = 
Header.Parent = MainPanel

(Header, )

 Title = .()
Title.Name = 
Title.Size = .(, -, , )
Title.Position = .(, )
Title.BackgroundTransparency = 
Title.Text = GUI_NAME
Title.TextColor3 = .(, , )
Title.TextSize = 
Title.Font = .Font.GothamBold
Title.TextXAlignment = .TextXAlignment.Left
Title.Parent = Header


  (name, text, y)
     button = .()
    button.Name = name
    button.Size = .(, -, , )
    button.Position = .(, y)
    button.BackgroundColor3 = BUTTON_OFF
    button.BorderSizePixel = 
    button.Text = text
    button.TextColor3 = .(, , )
    button.TextSize = 
    button.Font = .Font.GothamSemibold
    button.AutoButtonColor = 
    button.Parent = MainPanel

    (button, )
     button


 AimbotButton = (
    ,
    ,
    
)

 ClosestButton = (
    ,
    ,
    
)

 ESPButton = (
    ,
    ,
    
)


 ToggleButton = .()
ToggleButton.Name = 
ToggleButton.Size = TOGGLE_SIZE
ToggleButton.AnchorPoint = .(, )
ToggleButton.Position = .(, , , )
ToggleButton.BackgroundColor3 = .(, , )
ToggleButton.BorderSizePixel = 
ToggleButton.Text = GUI_NAME
ToggleButton.TextColor3 = .(, , )
ToggleButton.TextSize = 
ToggleButton.Font = .Font.GothamBold
ToggleButton.TextStrokeTransparency = 
ToggleButton.ZIndex = 
ToggleButton.Active = 
ToggleButton.Parent = ScreenGui

(ToggleButton, )
(ToggleButton, .(, , ), )

 RainbowGradient = .()
RainbowGradient.Color = ColorSequence.({
    ColorSequenceKeypoint.(, .(, , )),
    ColorSequenceKeypoint.(, .(, , )),
    ColorSequenceKeypoint.(, .(, , )),
    ColorSequenceKeypoint.(, .(, , )),
    ColorSequenceKeypoint.(, .(, , )),
    ColorSequenceKeypoint.(, .(, , )),
    ColorSequenceKeypoint.(, .(, , )),
})
RainbowGradient.Parent = ToggleButton


  (handle, target, onClick)
     dragging = 
     activeType = 
     activeTouch = 

     dragStart = .zero
     startTopLeft = .zero
     moved = 

      (input)
         inputType = input.UserInputType

         inputType ~= .UserInputType.MouseButton1
             inputType ~= .UserInputType.Touch 
            
        

         dragging 
            
        

        dragging = 
        activeType = inputType
        activeTouch = inputType == .UserInputType.Touch
             input  

        moved = 
        dragStart = .(input.Position.X, input.Position.Y)
        startTopLeft = target.AbsolutePosition
    

      (position)
          dragging 
            
        

         currentPosition = .(position.X, position.Y)
         delta = currentPosition - dragStart

         delta.Magnitude >  
            moved = 
        

          moved 
            
        

         camera = Workspace.CurrentCamera
         viewport = camera  camera.ViewportSize
             .(, )

         size = target.AbsoluteSize
         parentPosition = .zero

         target.Parent  target.Parent:() 
            parentPosition = target.Parent.AbsolutePosition
        

         localStart = startTopLeft - parentPosition

         maxX = .(, viewport.X - size.X - parentPosition.X)
         maxY = .(, viewport.Y - size.Y - parentPosition.Y)

         x = .(localStart.X + delta.X, , maxX)
         y = .(localStart.Y + delta.Y, , maxY)

        target.Position = .(
            x + size.X * target.AnchorPoint.X,
            y + size.Y * target.AnchorPoint.Y
        )
    

      (input)
          dragging 
            
        

         activeType == .UserInputType.MouseButton1 
             input.UserInputType ~= .UserInputType.MouseButton1 
                
            
         activeType == .UserInputType.Touch 
             input ~= activeTouch 
                
            
        
            
        

         wasClick =  moved

        dragging = 
        activeType = 
        activeTouch = 

         wasClick  onClick 
            ()
        
    

    (handle.InputBegan, beginDrag)

    (UserInputService.InputChanged, (input)
          dragging 
            
        

         activeType == .UserInputType.MouseButton1
             input.UserInputType == .UserInputType.MouseMovement 
            (input.Position)
        
    )

    (UserInputService.TouchMoved, (input)
         dragging
             activeType == .UserInputType.Touch
             input == activeTouch 
            (input.Position)
        
    )

    (UserInputService.InputEnded, (input)
         dragging
             activeType == .UserInputType.MouseButton1 
            (input)
        
    )

    (UserInputService.TouchEnded, (input)
         dragging
             activeType == .UserInputType.Touch 
            (input)
        
    )


(Header, MainPanel)

(ToggleButton, ToggleButton, ()
    MainPanel.Visible =  MainPanel.Visible
)


  (player)
      player  player == LocalPlayer 
         
    

     player.Team ~=   LocalPlayer.Team ~=  
         player.Team == LocalPlayer.Team
    

     player.Neutral  LocalPlayer.Neutral 
         
    

     player.TeamColor == LocalPlayer.TeamColor



 TrackedModels = {}
 HighlightsByModel = {}

  (instance)
     current = instance

     current  current ~= Workspace 
         current:()
             current:() 
            TrackedModels[current] = 
             current
        

        current = current.Parent
    

     


  ()
     _, instance  (Workspace:()) 
         instance:()
             instance:() 
            TrackedModels[instance] = 
        
    

     _, player  (Players:()) 
         player.Character 
            (player.Character)
        
    


(Workspace.DescendantAdded, (instance)
    (instance)
)

(Players.PlayerAdded, (player)
    (player.CharacterAdded, (character)
        (character)
    )
)

 _, player  (Players:()) 
    (player.CharacterAdded, (character)
        (character)
    )

     player.Character 
        (player.Character)
    


()


  (model)
      model
          model:()
         model == LocalPlayer.Character
          model:(Workspace) 
         
    

     humanoid = model:()

      humanoid  humanoid.Health <=  
         
    

     player = Players:(model)

     player  (player) 
         
    

    
     head = model:()

      head   head:() 
         
    

    
     root = model:()
     distancePart

     root  root:() 
        distancePart = root
     humanoid.RootPart 
        distancePart = humanoid.RootPart
    
        distancePart = head
    

     model, humanoid, head, distancePart, player



 AimRayParams = RaycastParams.()
AimRayParams.FilterType = .RaycastFilterType.Exclude
AimRayParams.IgnoreWater = 

  (model, head)
      CHECK_WALLS 
         
    

     camera = Workspace.CurrentCamera

      camera 
         
    

     origin = camera.CFrame.Position
     direction = head.Position - origin

     direction.Magnitude <  
         
    

     localCharacter = LocalPlayer.Character

    AimRayParams.FilterDescendantsInstances = localCharacter
         {localCharacter}
         {}

     result = Workspace:(
        origin,
        direction,
        AimRayParams
    )

    
      result 
         
    

     result.Instance:(model)



  ()
     character = LocalPlayer.Character
     root = character
         character:()

     root  root:() 
         root.Position
    

     camera = Workspace.CurrentCamera

     camera 
         camera.CFrame.Position
    

     


  (model)
     validModel, humanoid, head, distancePart, player =
        (model)

      validModel 
         
    

     localPosition = ()

      localPosition 
         
    

    
     verticalDifference = .(
        distancePart.Position.Y - localPosition.Y
    )

     verticalDifference > MAX_Y_DIFFERENCE 
         
    

    
      (validModel, head) 
         
    

     , validModel, humanoid, head, distancePart, player



  ()
     origin = ()

      origin 
         
    

     _, player  (Players:()) 
         player.Character 
            (player.Character)
        
    

     closestModel = 
     closestDistance = .huge

     model  (TrackedModels) 
         eligible, validModel, _, _, distancePart =
            (model)

         eligible  validModel  distancePart 
             distance = (
                distancePart.Position - origin
            ).Magnitude

             distance < closestDistance 
                closestDistance = distance
                closestModel = validModel
            
        
    

     closestModel



 AimMode = 
 LockedModel = 

 CurrentTargetModel = 
 SnapStartTime = 
 SnapStartCFrame = 

  (requestedMode)
     AimMode == requestedMode 
        AimMode = 
    
        AimMode = requestedMode
    

    LockedModel = 
    CurrentTargetModel = 
    SnapStartCFrame = 

     AimMode ==  
        LockedModel = ()
    



  ()
     AimMode ==  
        CurrentTargetModel = 
        SnapStartCFrame = 
        
    

     targetModel = 

     AimMode ==  
        
        
        
         LockedModel 
             eligible = (LockedModel)

              eligible 
                LockedModel = 
            
        

          LockedModel 
            LockedModel = ()
        

        targetModel = LockedModel

     AimMode ==  
        
        targetModel = ()
    

     camera = Workspace.CurrentCamera

      camera   targetModel 
        CurrentTargetModel = 
        SnapStartCFrame = 
        
    

     eligible, validModel, _, head = (targetModel)

      eligible   validModel   head 
         AimMode ==  
            LockedModel = 
        

        CurrentTargetModel = 
        SnapStartCFrame = 
        
    

    
     CurrentTargetModel ~= targetModel 
        CurrentTargetModel = targetModel
        SnapStartTime = .()
        SnapStartCFrame = camera.CFrame
    

     cameraPosition = camera.CFrame.Position
     direction = head.Position - cameraPosition

     direction.Magnitude <  
        
    

     desiredCFrame = .(
        cameraPosition,
        head.Position
    )

     elapsed = .() - SnapStartTime
     alpha = .(elapsed / SNAP_TIME, , )

     SnapStartCFrame  alpha <  
         startRotation = SnapStartCFrame.Rotation
         startCFrame = .(cameraPosition) * startRotation

        camera.CFrame = startCFrame:(desiredCFrame, alpha)
    
        
        camera.CFrame = desiredCFrame
    


RunService:(
    CAMERA_BIND,
    .RenderPriority.Camera.Value + ,
    updateAimCamera
)


 ESPEnabled = 

  (model)
     highlight = HighlightsByModel[model]

     highlight 
        highlight:()
        HighlightsByModel[model] = 
    


  ()
     model, highlight  (HighlightsByModel) 
        highlight:()
        HighlightsByModel[model] = 
    


  (model, color)
     highlight = HighlightsByModel[model]

      highlight   highlight.Parent 
        highlight = .()
        highlight.Name = 
        highlight.Adornee = model
        highlight.DepthMode = .HighlightDepthMode.AlwaysOnTop
        highlight.FillTransparency = 
        highlight.OutlineTransparency = 
        highlight.Parent = model

        HighlightsByModel[model] = highlight
    

    highlight.Adornee = model
    highlight.Enabled = 
    highlight.FillColor = color
    highlight.OutlineColor = color


  ()
     model  (TrackedModels) 
         inWorkspace = model:(Workspace)
         humanoid = model:()

          inWorkspace   humanoid 
            (model)
            TrackedModels[model] = 

         model == LocalPlayer.Character 
            (model)

          ESPEnabled 
            (model)

        
             player = Players:(model)
             color = NPC_COLOR

             player 
                 (player) 
                    color = TEAM_COLOR
                
                    color = ENEMY_COLOR
                
            

            (model, color)
        
    


.(()
     ScreenGui.Parent 
        ()
        .(ESP_REFRESH)
    
)


  ()
     AimMode ==  
        AimbotButton.Text = 
        AimbotButton.BackgroundColor3 = BUTTON_ON
    
        AimbotButton.Text = 
        AimbotButton.BackgroundColor3 = BUTTON_OFF
    

     AimMode ==  
        ClosestButton.Text = 
        ClosestButton.BackgroundColor3 = BUTTON_ON
    
        ClosestButton.Text = 
        ClosestButton.BackgroundColor3 = BUTTON_OFF
    

     ESPEnabled 
        ESPButton.Text = 
        ESPButton.BackgroundColor3 = .(, , )
    
        ESPButton.Text = 
        ESPButton.BackgroundColor3 = BUTTON_OFF
    



(AimbotButton.Activated, ()
    ()
    ()
)

(ClosestButton.Activated, ()
    ()
    ()
)

(ESPButton.Activated, ()
    ESPEnabled =  ESPEnabled

     ESPEnabled 
        ()
        ()
    
        ()
    

    ()
)


(RunService.RenderStepped, (deltaTime)
    RainbowGradient.Rotation =
        (RainbowGradient.Rotation + deltaTime * ) % 
)


(ScreenGui.Destroying, ()
    RunService:(CAMERA_BIND)
    ()

     _, connection  (Connections) 
        connection:()
    
)

()