Box Esp And Aimbot

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

 TEAMS = {
    []   = ,
    [] = ,
}

 TEAM_COLORS = {
    [] = .(, , ),
    []   = .(, , ),
}

 Boxes        = {}
 MAX_DISTANCE = 
.Sens               = 
.AIMBOT_SMOOTHNESS  = 
.aimbotActive       =  
.FOV_RADIUS         = 
.AIM_MODE           =    
.DRAW_FOV           = 
.TARGET_SWITCH_DELAY =   

 lastTarget         = 
 lastTargetLostTime = 

 localTeamName = TEAMS[(LocalPlayer.TeamColor)]  


 fovCircle           = .()
fovCircle.Radius          = .FOV_RADIUS
fovCircle.Color           = .(, , )
fovCircle.Thickness       = 
fovCircle.Filled          = 
fovCircle.Visible         = 
fovCircle.NumSides        = 

UserInputService.InputBegan:((input)
     input.UserInputType == .UserInputType.MouseButton1 
        .aimbotActive = 
        ()
    
)

UserInputService.InputEnded:((input)
     input.UserInputType == .UserInputType.MouseButton1 
        .aimbotActive = 
        ()
    
)

  (model)
     data = Boxes[model]
      data   
    (() data.sq:() )
    (() data.label:() )
    Boxes[model] = 


LocalPlayer:():(()
    localTeamName = TEAMS[(LocalPlayer.TeamColor)]  
     _, data  (Boxes) 
         enemyTeam = TEAMS[(data.player  data.player.TeamColor)]  
        data.isEnemy = enemyTeam ~= localTeamName
         color = TEAM_COLORS[enemyTeam]  .(, , )
        data.sq.Color    = color
        data.label.Color = color
          data.isEnemy 
            data.sq.Visible    = 
            data.label.Visible = 
        
    
)

  (model, rootPart)
     rootPart  (rootPart.Position - Camera.CFrame.Position).Magnitude > MAX_DISTANCE 
         
    

     minX, minY = .huge,  .huge
     maxX, maxY = -.huge, -.huge
     onScreen   = 

     _, part  (model:()) 
         part:() 
             s  = part.Size * 
             cf = part.CFrame
             _, offset  ({
                .( s.X,  s.Y,  s.Z), .(-s.X,  s.Y,  s.Z),
                .( s.X, -s.Y,  s.Z), .(-s.X, -s.Y,  s.Z),
                .( s.X,  s.Y, -s.Z), .(-s.X,  s.Y, -s.Z),
                .( s.X, -s.Y, -s.Z), .(-s.X, -s.Y, -s.Z),
            }) 
                 screen, visible = Camera:(cf:(offset))
                 visible 
                    onScreen = 
                    minX = .(minX, screen.X)
                    minY = .(minY, screen.Y)
                    maxX = .(maxX, screen.X)
                    maxY = .(maxY, screen.Y)
                
            
        
    

     onScreen  { minX, minY, maxX - minX, maxY - minY }  


  (model)
      model:()  Boxes[model]   

     tag = model:(, )
      tag   tag:()   

     name = tag.Text:()
     name == LocalPlayer.Name   

     player    = Players:(name)
     enemyTeam = TEAMS[(player  player.TeamColor)]  
     isEnemy   = enemyTeam ~= localTeamName
     color     = TEAM_COLORS[enemyTeam]  .(, , )

     sq       = .()
    sq.Filled      = 
    sq.Thickness   = 
    sq.Color       = color
    sq.Visible     = 

     label        = .()
    label.Text         = name
    label.Size         = 
    label.Font         = .Fonts.UI
    label.Color        = color
    label.Center       = 
    label.Outline      = 
    label.OutlineColor = .(, , )
    label.Visible      = 

     data = {
        sq      = sq,
        label   = label,
        root    = model:()  model:(),
        name    = name,
        player  = player,
        isEnemy = isEnemy,
    }
    Boxes[model] = data

     player 
        player:():(()
             newTeam  = TEAMS[(player.TeamColor)]  
            data.isEnemy   = newTeam ~= localTeamName
             newColor = TEAM_COLORS[newTeam]  .(, , )
            data.sq.Color    = newColor
            data.label.Color = newColor
              data.isEnemy 
                data.sq.Visible    = 
                data.label.Visible = 
            
        )
    



  (model)
     highestPart = 
     highestY    = -.huge
     _, v  (model:()) 
         v:()  v.Position.Y > highestY 
            highestY    = v.Position.Y
            highestPart = v
        
    
     highestPart  highestPart.Position  


  ()
     closest     = 
     closestDist = .huge
     camPos      = Camera.CFrame.Position
     center      = Camera.ViewportSize / 

     model, data  (Boxes) 
         data.isEnemy  model.Parent 
             pos = (model)
             pos 
                 screenPos, visible = Camera:(pos)
                 visible 
                     .AIM_MODE ==  
                        
                         screenDist = (.(screenPos.X, screenPos.Y) - center).Magnitude
                         screenDist < .FOV_RADIUS  screenDist < closestDist 
                            closestDist = screenDist
                            closest     = model
                        
                    
                        
                         dist = (pos - camPos).Magnitude
                         dist < closestDist  dist <= MAX_DISTANCE 
                            closestDist = dist
                            closest     = model
                        
                    
                
            
        
    

     closest



 _, v  (.Players:()) 
    (v)


.Players.DescendantAdded:(trackModel)
.Players.DescendantRemoving:(untrack)

Players.PlayerAdded:((player)
     player.Name == LocalPlayer.Name   
    player:():(()
         newTeam  = TEAMS[(player.TeamColor)]  
         newColor = TEAM_COLORS[newTeam]  .(, , )
         _, data  (Boxes) 
             data.name == player.Name 
                data.isEnemy  = newTeam ~= localTeamName
                data.player   = player
                data.sq.Color    = newColor
                data.label.Color = newColor
                  data.isEnemy 
                    data.sq.Visible    = 
                    data.label.Visible = 
                
            
        
    )
)

Players.PlayerRemoving:((player)
     toRemove = {}
     model, data  (Boxes) 
         data.name == player.Name 
            toRemove[#toRemove + ] = model
        
    
     _, model  (toRemove) 
        (model)
    
)

RunService.Heartbeat:(()
    frameTick += 

    
     center = Camera.ViewportSize / 
    fovCircle.Position = center
    fovCircle.Radius   = .FOV_RADIUS
    fovCircle.Visible  = .DRAW_FOV

	 .aimbotActive 
		 target = ()

		
		 target ~= lastTarget 
			 lastTarget ~=  
				
				 lastTargetLostTime ==  
					lastTargetLostTime = ()
				
				
				 (() - lastTargetLostTime) < .TARGET_SWITCH_DELAY 
					target = 
				
					lastTarget         = target
					lastTargetLostTime = 
				
			
				
				lastTarget         = target
				lastTargetLostTime = 
			
		
			
			lastTargetLostTime = 
		

		 target 
			 pos = (target)
			 pos 
				 screenPos, visible = Camera:(pos)
				 visible 
					 targetPos = .(screenPos.X, screenPos.Y)
					 delta     = (targetPos - center) * (.Sens * .AIMBOT_SMOOTHNESS)
					(delta.X, delta.Y)
				
			
		
	

     frameTick %  ~=    

     stale = {}
     model, data  (Boxes) 
          model.Parent 
            stale[#stale + ] = model
         data.isEnemy 
             bounds = (model, data.root)
             bounds 
                data.sq.Position    = .(bounds[], bounds[])
                data.sq.Size        = .(bounds[], bounds[])
                data.label.Position = .(bounds[] + bounds[] / , bounds[] - )
                data.sq.Visible     = 
                data.label.Visible  = 
            
                data.sq.Visible    = 
                data.label.Visible = 
            
        
    

     _, model  (stale) 
        (model)
    
)

()