Universal 3D ESP

 P = :()
 R = :()
 C = .CurrentCamera
 L = P.LocalPlayer

 e =        
 b =    
 o = {}         
 c = {} 

 E_C = .(, , )      
 T_C = .(, , )     
 B_C = .(, , )       
 W_C = .(, , )

 g = .()
g.ResetOnSpawn = 
g.Parent = L:()

 S = .(, , , ) 
 G_C = .(, , ) 
 S_C = .(, , ) 

 F = .()
F.Size = S
F.Position = .(, , , ) 
F.BackgroundColor3 = G_C
F.BorderSizePixel = 
F.Parent = g

 S_1 = .(, F)
S_1.Color = S_C
S_1.Thickness = 

 B_1 = .()
B_1.Size = .(, , , ) 
B_1.Position = .(, , , )
B_1.BackgroundColor3 = e  T_C  E_C
B_1.Text = e    
B_1.TextColor3 = .(, , )
B_1.TextSize = 
B_1.Font = .Font.GothamBold
B_1.Parent = F

B_1.MouseButton1Click:(()
    e =  e
    B_1.Text = e    
    B_1.BackgroundColor3 = e  T_C  E_C
)

 F_2 = .()
F_2.Size = S
F_2.Position = .(, , ,  + S.Y.Offset + ) 
F_2.BackgroundColor3 = G_C
F_2.BorderSizePixel = 
F_2.Parent = g

 S_2 = .(, F_2)
S_2.Color = S_C
S_2.Thickness = 

 B_2 = .()
B_2.Size = .(, , , ) 
B_2.Position = .(, , , )
B_2.BackgroundColor3 = b  B_C  .(, , ) 
B_2.Text = b    
B_2.TextColor3 = .(, , )
B_2.TextSize = 
B_2.Font = .Font.GothamBold
B_2.Parent = F_2

B_2.MouseButton1Click:(()
    b =  b
    B_2.Text = b    
    B_2.BackgroundColor3 = b  B_C  .(, , )
)

  (p)
      L   L.Team    
     p == L    
     L.Team ~= p.Team


  (p)
      L.Character   E_C 
     (p)  E_C  T_C


  (p, char)
     p == L  o[p]   
    
     c_i = (p)
    
     d_c, f_b = {}, {}

     i=,   
        d_c[i] = .() 
        d_c[i].Thickness = 
        d_c[i].Color = c_i
        d_c[i].Transparency =  
      
     i=,   
        f_b[i] = .() 
        f_b[i].Thickness = 
        f_b[i].Color = c_i
        f_b[i].Transparency =  
      
    
     beam = .() 
    beam.Thickness = 
    beam.Color = B_C 
    beam.Transparency = 
    
     n_t = .() 
    n_t.Size =  
    n_t.Center =  
    n_t.Outline =  
    n_t.Color = W_C 
    n_t.Font = 
    
     s_t = .() 
    s_t.Size =  
    s_t.Center =  
    s_t.Outline =  
    s_t.Color = W_C 
    s_t.Font = 
    
     h_o = .() 
    h_o.Thickness =  
    h_o.Color = .(, , ) 
    h_o.Transparency = 
    
     h_f = .() 
    h_f.Thickness =  
    h_f.Color = .(, , ) 
    h_f.Transparency = 
    

    o[p] = {
        corners = d_c, 
        fullBox = f_b, 
        beam = beam, 
        nameText = n_t, 
        statusText = s_t, 
        healthBarOutline = h_o, 
        healthBarFill = h_f
    }


  (p)
     o[p] 
         _, v  (o[p].corners  {})   v  v.Remove  v:()  
         _, v  (o[p].fullBox  {})   v  v.Remove  v:()  
         o[p].beam  o[p].beam.Remove  o[p].beam:() 
         o[p].nameText  o[p].nameText.Remove  o[p].nameText:() 
         o[p].statusText  o[p].statusText.Remove  o[p].statusText:() 
         o[p].healthBarOutline  o[p].healthBarOutline.Remove  o[p].healthBarOutline:() 
         o[p].healthBarFill  o[p].healthBarFill.Remove  o[p].healthBarFill:() 
        o[p] = 
    


  ()
     p, _  (o)  
          P:(p.Name)  
            (p) 
         
    


 d = R.RenderStepped:(()
     lc = L.Character
     lr = lc  lc:()
    
     x = C.ViewportSize.X
     y = C.ViewportSize.Y
    
     h = .(x / , ) 

     p, v  (o) 
         char = p.Character
         rt = char  char:()
         hd = char  char:()
         hum = char  char:()
        
         is_e = (p)
         c_b = is_e  E_C  T_C 
         t_c = W_C

         b  rt  lr   
             rp, on = C:(rt.Position)  
            v.beam.Visible = on  
             on   
                v.beam.To = .(rp.X, rp.Y)  
                v.beam.From = h
                v.beam.Color = B_C 
              
         v.beam.Visible =    

          e   
             _, line  (v.corners  {})  line.Visible =    
             _, line  (v.fullBox  {})  line.Visible =    
             v.nameText  v.nameText.Visible =    
             v.statusText  v.statusText.Visible =    
             v.healthBarOutline  v.healthBarOutline.Visible =    
             v.healthBarFill  v.healthBarFill.Visible =    
              
          

          char   rt   hd   hum  hum.Health <=    
             _, line  (v.corners  {})  line.Visible =    
             _, line  (v.fullBox  {})  line.Visible =    
             v.nameText  v.nameText.Visible =    
             v.statusText  v.statusText.Visible =    
             v.healthBarOutline  v.healthBarOutline.Visible =    
             v.healthBarFill  v.healthBarFill.Visible =    
              
          

         rp, on = C:(rt.Position)  
        
         ho =  
         lpo =  
        
         hp = C:(hd.Position + .(, ho, )) 
         lp = C:(rt.Position - .(, lpo, )) 

         on   
             _, line  (v.corners)  line.Color = c_b   
             _, line  (v.fullBox)  line.Color = c_b   
            
            v.nameText.Color = t_c  
            v.statusText.Color = t_c  

             dist = .((lr.Position - rt.Position).Magnitude)  
             health = .(hum.Health)  
             max = hum.MaxHealth  
            
            v.nameText.Text = p.DisplayName  
            v.nameText.Position = .(rp.X, hp.Y - ) 
            v.nameText.Visible =   

             H = .(hp.Y - lp.Y) 
             W = H *  
             c_l = .(W, H) * 
            
             tl = .(rp.X - W / , hp.Y)  
             tr = .(rp.X + W / , hp.Y)  
             bl = .(rp.X - W / , hp.Y + H)  
             br = .(rp.X + W / , hp.Y + H)  

            v.fullBox[].From = tl 
            v.fullBox[].To = tr  
            v.fullBox[].From = tr 
            v.fullBox[].To = br  
            v.fullBox[].From = br 
            v.fullBox[].To = bl  
            v.fullBox[].From = bl 
            v.fullBox[].To = tl  
             _, line  (v.fullBox)  line.Visible =    

            v.corners[].From = tl 
            v.corners[].To = .(tl.X + c_l, tl.Y)  
            v.corners[].From = tl 
            v.corners[].To = .(tl.X, tl.Y + c_l)  
            v.corners[].From = tr 
            v.corners[].To = .(tr.X - c_l, tr.Y)  
            v.corners[].From = tr 
            v.corners[].To = .(tr.X, tr.Y + c_l)  
            v.corners[].From = bl 
            v.corners[].To = .(bl.X + c_l, bl.Y)  
            v.corners[].From = bl 
            v.corners[].To = .(bl.X, bl.Y - c_l)  
            v.corners[].From = br 
            v.corners[].To = .(br.X - c_l, br.Y)  
            v.corners[].From = br 
            v.corners[].To = .(br.X, br.Y - c_l)  
             _, line  (v.corners)  line.Visible =    

             hb_y = bl.Y +  
             hb_w = W
             hb_e = bl.X + hb_w
            
            v.healthBarOutline.From = .(bl.X, hb_y)
            v.healthBarOutline.To = .(hb_e, hb_y)
            v.healthBarOutline.Visible = 

             hf_e = bl.X + (hb_w * (health / max))
            v.healthBarFill.From = .(bl.X, hb_y)
            v.healthBarFill.To = .(hf_e, hb_y)
            v.healthBarFill.Color = .( - (health / max), health / max, )
            v.healthBarFill.Visible = 

            v.statusText.Text =  .. health ..  .. dist ..   
            v.statusText.Position = .(rp.X, hb_y + )  
            v.statusText.Visible =   

          
             _, line  (v.corners  {})  line.Visible =    
             _, line  (v.fullBox  {})  line.Visible =    
             v.nameText  v.nameText.Visible =    
             v.statusText  v.statusText.Visible =    
             v.healthBarOutline  v.healthBarOutline.Visible =    
             v.healthBarFill  v.healthBarFill.Visible =    
          
    
)

R.Heartbeat:(cl)

  (p)
     p == L  o[p]   

      (char)
         char:()   o[p]  
            (p, char) 
        
    
    
     ca_c = p.CharacterAdded:(hh)
    c[p] = ca_c 
    
     p.Character  
        (p.Character) 
    


  (p)
    (p) 
     c[p]  c[p].Disconnect 
        c[p]:()
        c[p] = 
    


  ()
     _, p  (P:()) 
         p ~= L   o[p] 
            (p)
        
    


  ()
     .() 
        ()
    


.(loop_p) 

P.PlayerAdded:(ap)
P.PlayerRemoving:(rp)

 _, p  (P:())  
     p ~= L  
        (p) 
     


g.Destroying:(()
     d  d:() 
    
     p  (o)  (p) 
     p, con  (c) 
         con  con.Disconnect  con:() 
    
)