BOX ESP

 ESP = {
    Enabled = ,
    Boxes = ,
    BoxShift = .(, -, ),
    BoxSize = .(, , ),
    Color = .(, , ),
    Thickness = ,
    AttachShift = ,
    
    Objects = ({}, {__mode=}),
    Overrides = {}
}

 cam = .CurrentCamera
 plrs = :()
 plr = plrs.LocalPlayer
 mouse = plr:()

 V3new = .new
 WorldToViewportPoint = cam.WorldToViewportPoint

  (obj, props)
     new = .(obj)
    
    props = props  {}
     i, v  (props) 
        new[i] = v
    
     new


 ESP:(obj)
     ov = self.Overrides.GetColor
     ov 
         (obj)
    
     p = self:(obj)
     p  self.Color


 ESP:(char)
     ov = self.Overrides.GetPlrFromChar
     ov 
         (char)
    
    
     plrs:(char)


 ESP:(bool)
    self.Enabled = bool
      bool 
         i, v  (self.Objects) 
             v.Type ==  
                 v.Temporary 
                    v:()
                
                     i, v  (v.Components) 
                        v.Visible = 
                    
                
            
        
    


 ESP:(obj)
     self.Objects[obj]


 ESP:(parent, options)
      parent 
        
    

      (c)
         (options.Type) ==   c:(options.Type)  options.Type ==  
             (options.Name) ==   c.Name == options.Name  options.Name ==  
                  options.Validator  options.(c) 
                     c.Parent  :(c) 
                         box = ESP:(c, {
                            PrimaryPart = (options.PrimaryPart) ==   c:(options.PrimaryPart)  (options.PrimaryPart) ==   options.(c),
                            Color = (options.Color) ==   options.(c)  options.Color,
                            ColorDynamic = options.ColorDynamic,
                            IsEnabled = options.IsEnabled,
                            RenderInNil = options.RenderInNil
                        })
                         options.OnAdded 
                            .(options.OnAdded)(box)
                        
                    
                    
                
            
        
    
    
     options.Recursive 
        parent.DescendantAdded:(NewListener)
         i, v  (parent:()) 
            (v)
        
    
        parent.ChildAdded:(NewListener)
         i, v  (parent:()) 
            (v)
        
    


 boxBase = {}
boxBase.__index = boxBase

 boxBase:()
    ESP.Objects[self.Object] = 
     i, v  (self.Components) 
         v 
            v.Visible = 
            v:()
            self.Components[i] = 
        
    


 boxBase:()
      self.PrimaryPart 
         self:()
    

     allow = 

     ESP.Overrides.UpdateAllow   ESP.Overrides.(self) 
        allow = 
    
     self.IsEnabled  ((self.IsEnabled) ==    ESP[self.IsEnabled]  (self.IsEnabled) ==    self:()) 
        allow = 
    
      :(self.PrimaryPart)   self.RenderInNil 
        allow = 
    

      allow 
         i, v  (self.Components) 
             v 
                v.Visible = 
            
        
        
    

     size = self.Size
     cf = self.PrimaryPart.CFrame

     locs = {
        TopLeft = (cam, (cf * ESP.BoxShift * .(size.X / , size.Y / , )).Position),
        TopRight = (cam, (cf * ESP.BoxShift * .(-size.X / , size.Y / , )).Position),
        BottomLeft = (cam, (cf * ESP.BoxShift * .(size.X / , -size.Y / , )).Position),
        BottomRight = (cam, (cf * ESP.BoxShift * .(-size.X / , -size.Y / , )).Position)
    }

     self.Components.Quad 
         locs.TopRight.Z >   locs.TopLeft.Z >   locs.BottomLeft.Z >   locs.BottomRight.Z >  
            self.Components.Quad.Visible = 
            self.Components.Quad.PointA = .(locs.TopRight.X, locs.TopRight.Y)
            self.Components.Quad.PointB = .(locs.TopLeft.X, locs.TopLeft.Y)
            self.Components.Quad.PointC = .(locs.BottomLeft.X, locs.BottomLeft.Y)
            self.Components.Quad.PointD = .(locs.BottomRight.X, locs.BottomRight.Y)
            self.Components.Quad.Color = self.Color  ESP.Color
        
            self.Components.Quad.Visible = 
        
        self.Components.Quad.Color = self.Color  ESP.Color
    


 ESP:(obj, options)
      obj.Parent   options.RenderInNil 
        
    

     box = ({
        Type = ,
        Color = options.Color,
        Size = options.Size  self.BoxSize,
        Object = obj,
        Player = options.Player  plrs:(obj),
        PrimaryPart = options.PrimaryPart  obj.ClassName ==   (obj.PrimaryPart  obj:()  obj:())  obj:()  obj,
        Components = {},
        IsEnabled = options.IsEnabled,
        Temporary = options.Temporary,
        ColorDynamic = options.ColorDynamic,
        RenderInNil = options.RenderInNil
    }, boxBase)

      box.PrimaryPart 
        
    

     self:(obj) 
        self:(obj):()
    

    box.Components[] = (, {
        Thickness = self.Thickness,
        Color = box.Color,
        Transparency = ,
        Filled = ,
        Visible = self.Enabled  self.Boxes
    })

    self.Objects[obj] = box

    obj.AncestryChanged:((_, parent)
         parent ==   ESP.AutoRemove ~=  
            box:()
        
    )
    obj:():(()
         obj.Parent ==   ESP.AutoRemove ~=  
            box:()
        
    )

     hum = obj:()
     hum 
        hum.Died:(()
             ESP.AutoRemove ~=  
                box:()
            
        )
    

     box


  (char)
     p = plrs:(char)
      char:() 
         ev
        ev = char.ChildAdded:((c)
             c.Name ==  
                ev:()
                ESP:(char, {
                    Player = p,
                    PrimaryPart = c
                })
            
        )
    
        ESP:(char, {
            Player = p,
            PrimaryPart = char.HumanoidRootPart
        })
    


  (p)
    p.CharacterAdded:(CharAdded)
     p.Character 
        .(CharAdded)(p.Character)
    

plrs.PlayerAdded:(PlayerAdded)
 i, v  (plrs:()) 
     v ~= plr 
        (v)
    


:().RenderStepped:(()
    cam = .CurrentCamera
     i, v  (ESP.Objects) 
         v.Update 
             s, e = (v.Update, v)
              s 
            
        
    
)

ESP:()
ESP.Boxes = 

 charBodies

 _, folder  (:()) 
     folder:() 
         humanoidFound = 
         _, model  (folder:()) 
             model:() 
                humanoidFound = 
                
            
        
         humanoidFound 
            charBodies = folder
            
        
    


ESP:(charBodies, {
    Type = ,
    Color = .(, , ),
    PrimaryPart = (obj)
         obj:()  obj:()
    , 
    Validator = (obj)
        .()
          
    , 
    IsEnabled = 
}); ESP.player =