simple drawing esp I open source

 Players = :()
 lp = Players.LocalPlayer
 camera = .Workspace.Camera
 UIS = :()

 espoverall = 

 espbox = 
 espboxoutline = 

 esptracer = 
 esptraceroutline = 
 tracertype =  

 esphealthbar = 
 esphealthbaroutline = 

 espname = 

 espdrone = 
 espdroneoutline = 

 espboxes = {}
 espboxoutlines = {}
 esptracers = {}
 esptraceroutlines = {}
 esphealthbars = {}
 esphealthbaroutlines = {}
 espnames = {}
 espdrones = {}
 espdroneoutlines = {}

 screensize = .Workspace.CurrentCamera.ViewportSize
 screenpositions = {.(screensize.X / , screensize.Y), .(screensize.X / , screensize.Y / ), .(screensize.X / , )}

  (name)
	 espboxes[name]  espboxes[name].Visible = ; espboxes[name]:(); espboxes[name] =  
	 espboxoutlines[name]  espboxoutlines[name].Visible = ; espboxoutlines[name]:(); espboxoutlines[name] =  
	 esptracers[name]  esptracers[name].Visible = ; esptracers[name]:(); esptracers[name] =  
	 esptraceroutlines[name]  esptraceroutlines[name].Visible = ; esptraceroutlines[name]:(); esptraceroutlines[name] =  
	 esphealthbars[name]  esphealthbars[name].Visible = ; esphealthbars[name]:(); esphealthbars[name] =  
	 esphealthbaroutlines[name]  esphealthbaroutlines[name].Visible = ; esphealthbaroutlines[name]:(); esphealthbaroutlines[name] =  
	 espnames[name]  espnames[name].Visible = ; espnames[name]:(); espnames[name] =  


  (drone)
	 espdrones[drone]  espdrones[drone].Visible = ; espdrones[drone]:(); espdrones[drone] =  
	 espdroneoutlines[drone]  espdroneoutlines[drone].Visible = ; espdroneoutlines[drone]:(); espdroneoutlines[drone] =  


  ()
	 team = lp.Team
	 enemies = {}
	 _,plr  (Players:()) 
		 espoverall  plr.Character  Players[plr.Name].Team ~= team 
			 hum = plr.Character:()
			 hum  hum.Health >  
				.(enemies, plr.Character)
			
		
	
	 drones = {}
	 _,v  (.Workspace:()) 
		 v.Name ==  
			.(drones, v)
		
	
	 enemies, drones


  (char)
	 minX, maxX = .huge, -.huge
	 minY, maxY = .huge, -.huge

	 _, part  (char:()) 
		 part:() 
			 cf = part.CFrame
			 size = part.Size / 

			
			 corners = {
				.(-size.X, -size.Y, -size.Z),
				.(-size.X, -size.Y,  size.Z),
				.(-size.X,  size.Y, -size.Z),
				.(-size.X,  size.Y,  size.Z),
				.( size.X, -size.Y, -size.Z),
				.( size.X, -size.Y,  size.Z),
				.( size.X,  size.Y, -size.Z),
				.( size.X,  size.Y,  size.Z),
			}

			 _, offset  (corners) 
				 worldPoint = cf:(offset)
				 screenPos, onScreen = camera:(worldPoint)
				 onScreen 
					minX = .(minX, screenPos.X)
					maxX = .(maxX, screenPos.X)
					minY = .(minY, screenPos.Y)
					maxY = .(maxY, screenPos.Y)
				
			
		
	

	 maxX, maxY, minX, minY


  (char) 
	 maxX, maxY, minX, minY = (char)
	 topleft = .(minX, minY)

	 boxCFrame, boxSize = char:()
	 topCenterWorld = boxCFrame.Position + boxCFrame.UpVector * (boxSize.Y / )

	 camLeft = -camera.CFrame.RightVector 
	 p0, on0 = camera:(topCenterWorld)
	 pL, onL = camera:(topCenterWorld + camLeft * )

	  (on0  onL) 
		 topleft, topleft
	

	 LOffset = .(pL.X - p0.X, pL.Y - p0.Y)

	 left2d = topleft + LOffset

	 topleft, left2d


  (target)
	 target ==   ( target) 
		
	
	  target:() 
		
	

	 maxX, maxY, minX, minY = (target)
	 outline

	
	 box

	 espboxoutlines[target.Name] 
		outline = espboxoutlines[target.Name]
	
		outline = .()
		outline.Visible = 
		outline.Transparency = 
		outline.Color = .(,,)
		outline.Thickness = 
		outline.Filled = 
		espboxoutlines[target.Name] = outline
	

	 espboxes[target.Name] 
		box = espboxes[target.Name]
	
		box = .()
		box.Visible = 
		box.Transparency = 
		box.Color = .(,,)
		box.Thickness = 
		box.Filled = 
		espboxes[target.Name] = box
	

	box.Size = .(maxX - minX, maxY - minY)
	box.Position = .(minX, minY)

	outline.Size = .(maxX - minX, maxY - minY)
	outline.Position = .(minX, minY)
	

	
	 line
	
	 esptraceroutlines[target.Name]  
		outline = esptraceroutlines[target.Name]
	 
		outline = .()
		outline.Visible = 
		outline.Color = .(,,)
		outline.Thickness =  
		esptraceroutlines[target.Name] = outline
	
	
	 esptracers[target.Name]  
		line = esptracers[target.Name]
	 
		line = .()
		line.Visible = 
		line.Color = .(,,)
		line.Thickness =  
		esptracers[target.Name] = line
	

	
	outline.From = screenpositions[tracertype]
	line.From = screenpositions[tracertype]

	outline.To = .(minX + (maxX - minX)/, minY) 
	line.To = .(minX + (maxX - minX)/, minY)
	

	

	 healthbar

	 esphealthbaroutlines[target.Name] 
		outline = esphealthbaroutlines[target.Name]
	
		outline = .()
		outline.Visible = 
		outline.Color = .(,,)
		outline.Thickness = 
		outline.Filled = 
		esphealthbaroutlines[target.Name] = outline
	

	 esphealthbars[target.Name] 
		healthbar = esphealthbars[target.Name]
	
		healthbar = .()
		healthbar.Visible = 
		healthbar.Color = .(,,)
		healthbar.Thickness = 
		healthbar.Filled = 
		esphealthbars[target.Name] = healthbar
	

	 topleft, width = (target)
	 hWidth = (topleft - width).Magnitude
	 targethealthloss = .(, (maxY - minY) * ( - target.Humanoid.Health/))

	healthbar.Size = .(hWidth, (maxY - minY)) - targethealthloss
	healthbar.Position = .(topleft.X - hWidth, minY) + targethealthloss

	outline.Size = .(hWidth, (maxY - minY)) - targethealthloss
	outline.Position = .(topleft.X - hWidth, minY) + targethealthloss
	

	
	 name

	 espnames[target.Name] 
		name = espnames[target.Name]
	
		name = .()
		name.Visible = 
		name.Color = .(,,)
		name.Text = target.Name
		name.Size = 
		name.Center = 
		name.Outline = 
		name.OutlineColor = .(,,)
		espnames[target.Name] = name
	

	name.Position = .(minX + (maxX - minX)/, minY - name.TextBounds.Y - )
	


  (target)
	 target ==   ( target) 
		
	
	  target:(.Workspace) 
		(target)
		
	
	  target:() 
		
	

	 maxX, maxY, minX, minY = (target)
	 outline

	
	 box

	 espdroneoutlines[target] 
		outline = espdroneoutlines[target]
	
		outline = .()
		outline.Visible = 
		outline.Transparency = 
		outline.Color = .(,,)
		outline.Thickness = 
		outline.Filled = 
		espdroneoutlines[target] = outline
	

	 espdrones[target] 
		box = espdrones[target]
	
		box = .()
		box.Visible = 
		box.Transparency = 
		box.Color = .(,,)
		box.Thickness = 
		box.Filled = 
		espdrones[target] = box
	

	box.Size = .(maxX - minX, maxY - minY)
	box.Position = .(minX, minY)

	outline.Size = .(maxX - minX, maxY - minY)
	outline.Position = .(minX, minY)
	


Players.PlayerRemoving:((plr)
	(plr.Name)
)

  (plr)
	 char = plr.Character
	  char   
	 hum = char:()
	 hum 
		hum.Died:(()
			(plr.Name)
		)
	


Players.PlayerAdded:((plr)
	plr.CharacterAdded:(()
		(plr)
	)
)

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


:().RenderStepped:(()
	 enemies, drones = ()

	 alive = {}
	 _,e  (enemies) 
		alive[e.Name] = 
		(e)
	

	 _,d  (drones) 
		(d)
	

	 name,_  (espboxes) 
		  alive[name]  (name) 
	
	 name,_  (espboxoutlines) 
	  alive[name]  (name) 
	
	 name,_  (esptracers) 
		  alive[name]  (name) 
	
	 name,_  (esptraceroutlines) 
		  alive[name]  (name) 
	
	 name,_  (esphealthbars) 
		  alive[name]  (name) 
	
	 name,_  (esphealthbaroutlines) 
		  alive[name]  (name) 
	
	 name,_  (espnames) 
		  alive[name]  (name) 
	

	 drone,_  (espdrones) 
		  drone   drone:(.Workspace) 
			(drone)
		
	
	 drone,_  (espdroneoutlines) 
		  drone   drone:(.Workspace) 
			(drone)
		
	
)