Universal ESP

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

 ESP = {
    Enabled = ,
    TeamCheck = ,
    VisibleOnly = ,
    MaxDistance = ,
    
    Box = {
        Enabled = ,
        Color = .(, , ),
        Thickness = ,
        Filled = 
    },
    
    Tracer = {
        Enabled = ,
        Color = .(, , ),
        Thickness = ,
        Origin = 
    },
    
    Name = {
        Enabled = ,
        Color = .(, , ),
        Size = ,
        ShowDistance = ,
        ShowHealth = 
    },
    
    HealthBar = {
        Enabled = ,
        Width = ,
        ColorFrom = .(, , ),
        ColorTo = .(, , )
    },
    
    Weapon = {
        Enabled = ,
        Color = .(, , ),
        Size = 
    }
}

 Settings = {
    ToggleKey = ,
    RefreshRate = 
}

 ESPObjects = {}
 LastUpdate = ()

  (, properties)
     drawing = .()
     prop, value  (properties) 
        drawing[prop] = value
    
     drawing


  (Player)
     Drawings = {}
    
    Drawings.Box = (, {
        Visible = ,
        Color = ESP.Box.Color,
        Thickness = ESP.Box.Thickness,
        Filled = ESP.Box.Filled
    })
    
    Drawings.Tracer = (, {
        Visible = ,
        Color = ESP.Tracer.Color,
        Thickness = ESP.Tracer.Thickness
    })
    
    Drawings.Name = (, {
        Visible = ,
        Color = ESP.Name.Color,
        Size = ESP.Name.Size,
        Center = ,
        Outline = 
    })
    
    Drawings.HealthBarOutline = (, {
        Visible = ,
        Color = .(, , ),
        Thickness = ,
        Filled = 
    })
    
    Drawings.HealthBar = (, {
        Visible = ,
        Color = ESP.HealthBar.ColorTo,
        Thickness = ,
        Filled = 
    })
    
    Drawings.Weapon = (, {
        Visible = ,
        Color = ESP.Weapon.Color,
        Size = ESP.Weapon.Size,
        Center = ,
        Outline = 
    })
    
    ESPObjects[Player] = Drawings


  ()
     screenSize = Camera.ViewportSize
     ESP.Tracer.Origin ==  
         .(screenSize.X / , screenSize.Y)
     ESP.Tracer.Origin ==  
         .(screenSize.X / , screenSize.Y / )
    
         .(screenSize.X / , )
    


  (Character)
     _, tool  (Character:()) 
         tool:()  tool:() 
             tool.Name
        
    
     


  (Player, Drawings)
      Player.Character   
    
     Humanoid = Player.Character:()
     RootPart = Player.Character:()
      Humanoid   RootPart   
    
     ESP.TeamCheck  Player.Team  LocalPlayer.Team  Player.Team == LocalPlayer.Team 
         _, drawing  (Drawings) 
            drawing.Visible = 
        
        
    
    
     distance = (LocalPlayer.Character  LocalPlayer.Character:()) 
         (RootPart.Position - LocalPlayer.Character.HumanoidRootPart.Position).Magnitude 
         
    
     distance > ESP.MaxDistance 
         _, drawing  (Drawings) 
            drawing.Visible = 
        
        
    
    
     ESP.VisibleOnly 
         rayOrigin = Camera.CFrame.Position
         rayDirection = (RootPart.Position - rayOrigin).Unit * distance
         raycastResult = :(rayOrigin, rayDirection)
        
         raycastResult 
             hitPart = raycastResult.Instance
             hitPart   hitPart:(Player.Character) 
                 _, drawing  (Drawings) 
                    drawing.Visible = 
                
                
            
        
    
    
     pos, onScreen = Camera:(RootPart.Position)
      onScreen 
         _, drawing  (Drawings) 
            drawing.Visible = 
        
        
    
    
     boxSize = .( / pos.Z,  / pos.Z)
     boxPos = .(pos.X - boxSize.X / , pos.Y - boxSize.Y / )
    
     ESP.Box.Enabled 
        Drawings.Box.Size = boxSize
        Drawings.Box.Position = boxPos
        Drawings.Box.Visible = 
    
        Drawings.Box.Visible = 
    
    
     ESP.Tracer.Enabled 
        Drawings.Tracer.From = ()
        Drawings.Tracer.To = .(pos.X, pos.Y)
        Drawings.Tracer.Visible = 
    
        Drawings.Tracer.Visible = 
    
    
     ESP.HealthBar.Enabled 
         health = Humanoid.Health / Humanoid.MaxHealth
         healthBarHeight = boxSize.Y * .(health, , )
        
        Drawings.HealthBarOutline.Size = .(ESP.HealthBar.Width, boxSize.Y + )
        Drawings.HealthBarOutline.Position = .(boxPos.X - ESP.HealthBar.Width - , boxPos.Y - )
        Drawings.HealthBarOutline.Visible = 
        
        Drawings.HealthBar.Size = .(ESP.HealthBar.Width, healthBarHeight)
        Drawings.HealthBar.Position = .(
            boxPos.X - ESP.HealthBar.Width - , 
            boxPos.Y + boxSize.Y - healthBarHeight
        )
        Drawings.HealthBar.Color = ESP.HealthBar.ColorFrom:(ESP.HealthBar.ColorTo, health)
        Drawings.HealthBar.Visible = 
    
        Drawings.HealthBarOutline.Visible = 
        Drawings.HealthBar.Visible = 
    
    
     ESP.Name.Enabled 
         infoText = Player.Name
         ESP.Name.ShowDistance 
            infoText = infoText .. .(, .(distance))
        
         ESP.Name.ShowHealth 
            infoText = infoText .. .(, Humanoid.Health)
        
        
        Drawings.Name.Text = infoText
        Drawings.Name.Position = .(pos.X, boxPos.Y - )
        Drawings.Name.Visible = 
    
        Drawings.Name.Visible = 
    
    
     ESP.Weapon.Enabled 
         weaponName = (Player.Character)
        Drawings.Weapon.Text = weaponName
        Drawings.Weapon.Position = .(pos.X, boxPos.Y + boxSize.Y + )
        Drawings.Weapon.Visible = 
    
        Drawings.Weapon.Visible = 
    


  ()
      ESP.Enabled 
         _, Drawings  (ESPObjects) 
             _, drawing  (Drawings) 
                drawing.Visible = 
            
        
        
    
    
     Player, Drawings  (ESPObjects) 
         Player  Player.Parent 
            (Player, Drawings)
        
             _, drawing  (Drawings) 
                drawing.Visible = 
            
        
    


 _, Player  (Players:()) 
     Player ~= LocalPlayer 
        (Player)
    


Players.PlayerAdded:((Player)
    (Player)
)

Players.PlayerRemoving:((Player)
     ESPObjects[Player] 
         _, drawing  (ESPObjects[Player]) 
            drawing:()
        
        ESPObjects[Player] = 
    
)

UserInputService.InputBegan:((input)
     input.KeyCode == .KeyCode[Settings.ToggleKey:()] 
        ESP.Enabled =  ESP.Enabled
        ( .. (ESP.Enabled    ))
    
)

RunService.RenderStepped:(()
     () - LastUpdate >= Settings.RefreshRate 
        ()
        LastUpdate = ()
    
)


( .. Settings.ToggleKey:() .. )
()