Phusion Advanced Esp

 Fluent = (:())()
 SaveManager = (:())()
 InterfaceManager = (:())()

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

 Drawings = {
    ESP = {},
    Tracers = {},
    Boxes = {},
    Healthbars = {},
    Names = {},
    Distances = {},
    Snaplines = {},
    Skeleton = {}
}

 Colors = {
    Enemy = .(, , ),
    Ally = .(, , ),
    Neutral = .(, , ),
    Selected = .(, , ),
    Health = .(, , ),
    Distance = .(, , ),
    Rainbow = 
}

 Highlights = {}

 Settings = {
    Enabled = ,
    TeamCheck = ,
    ShowTeam = ,
    VisibilityCheck = ,
    BoxESP = ,
    BoxStyle = ,
    BoxOutline = ,
    BoxFilled = ,
    BoxFillTransparency = ,
    BoxThickness = ,
    TracerESP = ,
    TracerOrigin = ,
    TracerStyle = ,
    TracerThickness = ,
    HealthESP = ,
    HealthStyle = ,
    HealthBarSide = ,
    HealthTextSuffix = ,
    NameESP = ,
    NameMode = ,
    ShowDistance = ,
    DistanceUnit = ,
    TextSize = ,
    TextFont = ,
    RainbowSpeed = ,
    MaxDistance = ,
    RefreshRate = /,
    Snaplines = ,
    SnaplineStyle = ,
    RainbowEnabled = ,
    RainbowBoxes = ,
    RainbowTracers = ,
    RainbowText = ,
    ChamsEnabled = ,
    ChamsOutlineColor = .(, , ),
    ChamsFillColor = .(, , ),
    ChamsOccludedColor = .(, , ),
    ChamsTransparency = ,
    ChamsOutlineTransparency = ,
    ChamsOutlineThickness = ,
    SkeletonESP = ,
    SkeletonColor = .(, , ),
    SkeletonThickness = ,
    SkeletonTransparency = 
}

  (player)
     player == LocalPlayer   
    
     box = {
        TopLeft = .(),
        TopRight = .(),
        BottomLeft = .(),
        BottomRight = .(),
        Left = .(),
        Right = .(),
        Top = .(),
        Bottom = .()
    }
    
     _, line  (box) 
        line.Visible = 
        line.Color = Colors.Enemy
        line.Thickness = Settings.BoxThickness
         line == box.Fill 
            line.Filled = 
            line.Transparency = Settings.BoxFillTransparency
        
    
    
     tracer = .()
    tracer.Visible = 
    tracer.Color = Colors.Enemy
    tracer.Thickness = Settings.TracerThickness
    
     healthBar = {
        Outline = .(),
        Fill = .(),
        Text = .()
    }
    
     _, obj  (healthBar) 
        obj.Visible = 
         obj == healthBar.Fill 
            obj.Color = Colors.Health
            obj.Filled = 
         obj == healthBar.Text 
            obj.Center = 
            obj.Size = Settings.TextSize
            obj.Color = Colors.Health
            obj.Font = Settings.TextFont
        
    
    
     info = {
        Name = .(),
        Distance = .()
    }
    
     _, text  (info) 
        text.Visible = 
        text.Center = 
        text.Size = Settings.TextSize
        text.Color = Colors.Enemy
        text.Font = Settings.TextFont
        text.Outline = 
    
    
     snapline = .()
    snapline.Visible = 
    snapline.Color = Colors.Enemy
    snapline.Thickness = 
    
     highlight = .()
    highlight.FillColor = Settings.ChamsFillColor
    highlight.OutlineColor = Settings.ChamsOutlineColor
    highlight.FillTransparency = Settings.ChamsTransparency
    highlight.OutlineTransparency = Settings.ChamsOutlineTransparency
    highlight.DepthMode = .HighlightDepthMode.AlwaysOnTop
    highlight.Enabled = Settings.ChamsEnabled
    
    Highlights[player] = highlight
    
     skeleton = {
        
        Head = .(),
        Neck = .(),
        UpperSpine = .(),
        LowerSpine = .(),
        
        
        LeftShoulder = .(),
        LeftUpperArm = .(),
        LeftLowerArm = .(),
        LeftHand = .(),
        
        
        RightShoulder = .(),
        RightUpperArm = .(),
        RightLowerArm = .(),
        RightHand = .(),
        
        
        LeftHip = .(),
        LeftUpperLeg = .(),
        LeftLowerLeg = .(),
        LeftFoot = .(),
        
        
        RightHip = .(),
        RightUpperLeg = .(),
        RightLowerLeg = .(),
        RightFoot = .()
    }
    
     _, line  (skeleton) 
        line.Visible = 
        line.Color = Settings.SkeletonColor
        line.Thickness = Settings.SkeletonThickness
        line.Transparency = Settings.SkeletonTransparency
    
    
    Drawings.Skeleton[player] = skeleton
    
    Drawings.ESP[player] = {
        Box = box,
        Tracer = tracer,
        HealthBar = healthBar,
        Info = info,
        Snapline = snapline
    }


  (player)
     esp = Drawings.ESP[player]
     esp 
         _, obj  (esp.Box)  obj:() 
        esp.Tracer:()
         _, obj  (esp.HealthBar)  obj:() 
         _, obj  (esp.Info)  obj:() 
        esp.Snapline:()
        Drawings.ESP[player] = 
    
    
     highlight = Highlights[player]
     highlight 
        highlight:()
        Highlights[player] = 
    
    
     skeleton = Drawings.Skeleton[player]
     skeleton 
         _, line  (skeleton) 
            line:()
        
        Drawings.Skeleton[player] = 
    


  (player)
     Settings.RainbowEnabled 
         Settings.RainbowBoxes  Settings.BoxESP   Colors.Rainbow 
         Settings.RainbowTracers  Settings.TracerESP   Colors.Rainbow 
         Settings.RainbowText  (Settings.NameESP  Settings.HealthESP)   Colors.Rainbow 
    
     player.Team == LocalPlayer.Team  Colors.Ally  Colors.Enemy


  (cf, 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/)
    }
    
     i, corner  (corners) 
        corners[i] = cf:(corner)
    
    
     corners


  ()
     origin = Settings.TracerOrigin
     origin ==  
         .(Camera.ViewportSize.X/, Camera.ViewportSize.Y)
     origin ==  
         .(Camera.ViewportSize.X/, )
     origin ==  
         UserInputService:()
    
         .(Camera.ViewportSize.X/, Camera.ViewportSize.Y/)
    


  (player)
      Settings.Enabled   
    
     esp = Drawings.ESP[player]
      esp   
    
     character = player.Character
      character  
        
         _, obj  (esp.Box)  obj.Visible =  
        esp.Tracer.Visible = 
         _, obj  (esp.HealthBar)  obj.Visible =  
         _, obj  (esp.Info)  obj.Visible =  
        esp.Snapline.Visible = 
        
         skeleton = Drawings.Skeleton[player]
         skeleton 
             _, line  (skeleton) 
                line.Visible = 
            
        
         
    
    
     rootPart = character:()
      rootPart  
        
         _, obj  (esp.Box)  obj.Visible =  
        esp.Tracer.Visible = 
         _, obj  (esp.HealthBar)  obj.Visible =  
         _, obj  (esp.Info)  obj.Visible =  
        esp.Snapline.Visible = 
        
         skeleton = Drawings.Skeleton[player]
         skeleton 
             _, line  (skeleton) 
                line.Visible = 
            
        
         
    
    
    
     _, isOnScreen = Camera:(rootPart.Position)
      isOnScreen 
         _, obj  (esp.Box)  obj.Visible =  
        esp.Tracer.Visible = 
         _, obj  (esp.HealthBar)  obj.Visible =  
         _, obj  (esp.Info)  obj.Visible =  
        esp.Snapline.Visible = 
        
         skeleton = Drawings.Skeleton[player]
         skeleton 
             _, line  (skeleton) 
                line.Visible = 
            
        
        
    
    
     humanoid = character:()
      humanoid  humanoid.Health <=  
         _, obj  (esp.Box)  obj.Visible =  
        esp.Tracer.Visible = 
         _, obj  (esp.HealthBar)  obj.Visible =  
         _, obj  (esp.Info)  obj.Visible =  
        esp.Snapline.Visible = 
        
         skeleton = Drawings.Skeleton[player]
         skeleton 
             _, line  (skeleton) 
                line.Visible = 
            
        
        
    
    
     pos, onScreen = Camera:(rootPart.Position)
     distance = (rootPart.Position - Camera.CFrame.Position).Magnitude
    
      onScreen  distance > Settings.MaxDistance 
         _, obj  (esp.Box)  obj.Visible =  
        esp.Tracer.Visible = 
         _, obj  (esp.HealthBar)  obj.Visible =  
         _, obj  (esp.Info)  obj.Visible =  
        esp.Snapline.Visible = 
        
    
    
     Settings.TeamCheck  player.Team == LocalPlayer.Team   Settings.ShowTeam 
         _, obj  (esp.Box)  obj.Visible =  
        esp.Tracer.Visible = 
         _, obj  (esp.HealthBar)  obj.Visible =  
         _, obj  (esp.Info)  obj.Visible =  
        esp.Snapline.Visible = 
        
    
    
     color = (player)
     size = character:()
     cf = rootPart.CFrame
    
     top, top_onscreen = Camera:(cf * .(, size.Y/, ).Position)
     bottom, bottom_onscreen = Camera:(cf * .(, -size.Y/, ).Position)
    
      top_onscreen   bottom_onscreen 
         _, obj  (esp.Box)  obj.Visible =  
        
    
    
     screenSize = bottom.Y - top.Y
     boxWidth = screenSize * 
     boxPosition = .(top.X - boxWidth/, top.Y)
     boxSize = .(boxWidth, screenSize)
    
    
     _, obj  (esp.Box) 
        obj.Visible = 
    
    
     Settings.BoxESP 
         Settings.BoxStyle ==  
             front = {
                TL = Camera:((cf * .(-size.X/, size.Y/, -size.Z/)).Position),
                TR = Camera:((cf * .(size.X/, size.Y/, -size.Z/)).Position),
                BL = Camera:((cf * .(-size.X/, -size.Y/, -size.Z/)).Position),
                BR = Camera:((cf * .(size.X/, -size.Y/, -size.Z/)).Position)
            }
            
             back = {
                TL = Camera:((cf * .(-size.X/, size.Y/, size.Z/)).Position),
                TR = Camera:((cf * .(size.X/, size.Y/, size.Z/)).Position),
                BL = Camera:((cf * .(-size.X/, -size.Y/, size.Z/)).Position),
                BR = Camera:((cf * .(size.X/, -size.Y/, size.Z/)).Position)
            }
            
              (front.TL.Z >   front.TR.Z >   front.BL.Z >   front.BR.Z >  
                   back.TL.Z >   back.TR.Z >   back.BL.Z >   back.BR.Z > ) 
                 _, obj  (esp.Box)  obj.Visible =  
                
            
            
            
              (v3)  .(v3.X, v3.Y) 
            front.TL, front.TR = (front.TL), (front.TR)
            front.BL, front.BR = (front.BL), (front.BR)
            back.TL, back.TR = (back.TL), (back.TR)
            back.BL, back.BR = (back.BL), (back.BR)
            
            
            esp.Box.TopLeft.From = front.TL
            esp.Box.TopLeft.To = front.TR
            esp.Box.TopLeft.Visible = 
            
            esp.Box.TopRight.From = front.TR
            esp.Box.TopRight.To = front.BR
            esp.Box.TopRight.Visible = 
            
            esp.Box.BottomLeft.From = front.BL
            esp.Box.BottomLeft.To = front.BR
            esp.Box.BottomLeft.Visible = 
            
            esp.Box.BottomRight.From = front.TL
            esp.Box.BottomRight.To = front.BL
            esp.Box.BottomRight.Visible = 
            
            
            esp.Box.Left.From = back.TL
            esp.Box.Left.To = back.TR
            esp.Box.Left.Visible = 
            
            esp.Box.Right.From = back.TR
            esp.Box.Right.To = back.BR
            esp.Box.Right.Visible = 
            
            esp.Box.Top.From = back.BL
            esp.Box.Top.To = back.BR
            esp.Box.Top.Visible = 
            
            esp.Box.Bottom.From = back.TL
            esp.Box.Bottom.To = back.BL
            esp.Box.Bottom.Visible = 
            
            
              (from, to, visible)
                 line = .()
                line.Visible = visible
                line.Color = color
                line.Thickness = Settings.BoxThickness
                line.From = from
                line.To = to
                 line
            
            
            
             connectors = {
                (front.TL, back.TL, ),
                (front.TR, back.TR, ),
                (front.BL, back.BL, ),
                (front.BR, back.BR, )
            }
            
            
            .(()
                .()
                 _, line  (connectors) 
                    line:()
                
            )
            
         Settings.BoxStyle ==  
             cornerSize = boxWidth * 
            
            esp.Box.TopLeft.From = boxPosition
            esp.Box.TopLeft.To = boxPosition + .(cornerSize, )
            esp.Box.TopLeft.Visible = 
            
            esp.Box.TopRight.From = boxPosition + .(boxSize.X, )
            esp.Box.TopRight.To = boxPosition + .(boxSize.X - cornerSize, )
            esp.Box.TopRight.Visible = 
            
            esp.Box.BottomLeft.From = boxPosition + .(, boxSize.Y)
            esp.Box.BottomLeft.To = boxPosition + .(cornerSize, boxSize.Y)
            esp.Box.BottomLeft.Visible = 
            
            esp.Box.BottomRight.From = boxPosition + .(boxSize.X, boxSize.Y)
            esp.Box.BottomRight.To = boxPosition + .(boxSize.X - cornerSize, boxSize.Y)
            esp.Box.BottomRight.Visible = 
            
            esp.Box.Left.From = boxPosition
            esp.Box.Left.To = boxPosition + .(, cornerSize)
            esp.Box.Left.Visible = 
            
            esp.Box.Right.From = boxPosition + .(boxSize.X, )
            esp.Box.Right.To = boxPosition + .(boxSize.X, cornerSize)
            esp.Box.Right.Visible = 
            
            esp.Box.Top.From = boxPosition + .(, boxSize.Y)
            esp.Box.Top.To = boxPosition + .(, boxSize.Y - cornerSize)
            esp.Box.Top.Visible = 
            
            esp.Box.Bottom.From = boxPosition + .(boxSize.X, boxSize.Y)
            esp.Box.Bottom.To = boxPosition + .(boxSize.X, boxSize.Y - cornerSize)
            esp.Box.Bottom.Visible = 
            
         
            esp.Box.Left.From = boxPosition
            esp.Box.Left.To = boxPosition + .(, boxSize.Y)
            esp.Box.Left.Visible = 
            
            esp.Box.Right.From = boxPosition + .(boxSize.X, )
            esp.Box.Right.To = boxPosition + .(boxSize.X, boxSize.Y)
            esp.Box.Right.Visible = 
            
            esp.Box.Top.From = boxPosition
            esp.Box.Top.To = boxPosition + .(boxSize.X, )
            esp.Box.Top.Visible = 
            
            esp.Box.Bottom.From = boxPosition + .(, boxSize.Y)
            esp.Box.Bottom.To = boxPosition + .(boxSize.X, boxSize.Y)
            esp.Box.Bottom.Visible = 
            
            esp.Box.TopLeft.Visible = 
            esp.Box.TopRight.Visible = 
            esp.Box.BottomLeft.Visible = 
            esp.Box.BottomRight.Visible = 
        
        
         _, obj  (esp.Box) 
             obj.Visible 
                obj.Color = color
                obj.Thickness = Settings.BoxThickness
            
        
    
    
     Settings.TracerESP 
        esp.Tracer.From = ()
        esp.Tracer.To = .(pos.X, pos.Y)
        esp.Tracer.Color = color
        esp.Tracer.Visible = 
    
        esp.Tracer.Visible = 
    
    
     Settings.HealthESP 
         health = humanoid.Health
         maxHealth = humanoid.MaxHealth
         healthPercent = health/maxHealth
        
         barHeight = screenSize * 
         barWidth = 
         barPos = .(
            boxPosition.X - barWidth - ,
            boxPosition.Y + (screenSize - barHeight)/
        )
        
        esp.HealthBar.Outline.Size = .(barWidth, barHeight)
        esp.HealthBar.Outline.Position = barPos
        esp.HealthBar.Outline.Visible = 
        
        esp.HealthBar.Fill.Size = .(barWidth - , barHeight * healthPercent)
        esp.HealthBar.Fill.Position = .(barPos.X + , barPos.Y + barHeight * (-healthPercent))
        esp.HealthBar.Fill.Color = .( - ( * healthPercent),  * healthPercent, )
        esp.HealthBar.Fill.Visible = 
        
         Settings.HealthStyle ==   Settings.HealthStyle ==  
            esp.HealthBar.Text.Text = .(health) .. Settings.HealthTextSuffix
            esp.HealthBar.Text.Position = .(barPos.X + barWidth + , barPos.Y + barHeight/)
            esp.HealthBar.Text.Visible = 
        
            esp.HealthBar.Text.Visible = 
        
    
         _, obj  (esp.HealthBar) 
            obj.Visible = 
        
    
    
     Settings.NameESP 
        esp.Info.Name.Text = player.DisplayName
        esp.Info.Name.Position = .(
            boxPosition.X + boxWidth/,
            boxPosition.Y - 
        )
        esp.Info.Name.Color = color
        esp.Info.Name.Visible = 
    
        esp.Info.Name.Visible = 
    
    
     Settings.Snaplines 
        esp.Snapline.From = .(Camera.ViewportSize.X/, Camera.ViewportSize.Y)
        esp.Snapline.To = .(pos.X, pos.Y)
        esp.Snapline.Color = color
        esp.Snapline.Visible = 
    
        esp.Snapline.Visible = 
    
    
     highlight = Highlights[player]
     highlight 
         Settings.ChamsEnabled  character 
            highlight.Parent = character
            highlight.FillColor = Settings.ChamsFillColor
            highlight.OutlineColor = Settings.ChamsOutlineColor
            highlight.FillTransparency = Settings.ChamsTransparency
            highlight.OutlineTransparency = Settings.ChamsOutlineTransparency
            highlight.Enabled = 
        
            highlight.Enabled = 
        
    
    
     Settings.SkeletonESP 
          (character)
              character    
            
             bones = {
                Head = character:(),
                UpperTorso = character:()  character:(),
                LowerTorso = character:()  character:(),
                RootPart = character:(),
                
                
                LeftUpperArm = character:()  character:(),
                LeftLowerArm = character:()  character:(),
                LeftHand = character:()  character:(),
                
                
                RightUpperArm = character:()  character:(),
                RightLowerArm = character:()  character:(),
                RightHand = character:()  character:(),
                
                
                LeftUpperLeg = character:()  character:(),
                LeftLowerLeg = character:()  character:(),
                LeftFoot = character:()  character:(),
                
                
                RightUpperLeg = character:()  character:(),
                RightLowerLeg = character:()  character:(),
                RightFoot = character:()  character:()
            }
            
            
              (bones.Head  bones.UpperTorso)    
            
             bones
        
        
          (from, to, line)
              from   to  
                line.Visible = 
                 
            
            
            
             fromPos = (from.CFrame * .(, , )).Position
             toPos = (to.CFrame * .(, , )).Position
            
            
             fromScreen, fromVisible = Camera:(fromPos)
             toScreen, toVisible = Camera:(toPos)
            
            
              (fromVisible  toVisible)  fromScreen.Z <   toScreen.Z <  
                line.Visible = 
                
            
            
            
             screenBounds = Camera.ViewportSize
             fromScreen.X <   fromScreen.X > screenBounds.X 
               fromScreen.Y <   fromScreen.Y > screenBounds.Y 
               toScreen.X <   toScreen.X > screenBounds.X 
               toScreen.Y <   toScreen.Y > screenBounds.Y 
                line.Visible = 
                
            
            
            
            line.From = .(fromScreen.X, fromScreen.Y)
            line.To = .(toScreen.X, toScreen.Y)
            line.Color = Settings.SkeletonColor
            line.Thickness = Settings.SkeletonThickness
            line.Transparency = Settings.SkeletonTransparency
            line.Visible = 
        
        
         bones = (character)
         bones 
             skeleton = Drawings.Skeleton[player]
             skeleton 
                
                (bones.Head, bones.UpperTorso, skeleton.Head)
                (bones.UpperTorso, bones.LowerTorso, skeleton.UpperSpine)
                
                
                (bones.UpperTorso, bones.LeftUpperArm, skeleton.LeftShoulder)
                (bones.LeftUpperArm, bones.LeftLowerArm, skeleton.LeftUpperArm)
                (bones.LeftLowerArm, bones.LeftHand, skeleton.LeftLowerArm)
                
                
                (bones.UpperTorso, bones.RightUpperArm, skeleton.RightShoulder)
                (bones.RightUpperArm, bones.RightLowerArm, skeleton.RightUpperArm)
                (bones.RightLowerArm, bones.RightHand, skeleton.RightLowerArm)
                
                
                (bones.LowerTorso, bones.LeftUpperLeg, skeleton.LeftHip)
                (bones.LeftUpperLeg, bones.LeftLowerLeg, skeleton.LeftUpperLeg)
                (bones.LeftLowerLeg, bones.LeftFoot, skeleton.LeftLowerLeg)
                
                
                (bones.LowerTorso, bones.RightUpperLeg, skeleton.RightHip)
                (bones.RightUpperLeg, bones.RightLowerLeg, skeleton.RightUpperLeg)
                (bones.RightLowerLeg, bones.RightFoot, skeleton.RightLowerLeg)
            
        
    
         skeleton = Drawings.Skeleton[player]
         skeleton 
             _, line  (skeleton) 
                line.Visible = 
            
        
    


  ()
     _, player  (Players:()) 
         esp = Drawings.ESP[player]
         esp 
             _, obj  (esp.Box)  obj.Visible =  
            esp.Tracer.Visible = 
             _, obj  (esp.HealthBar)  obj.Visible =  
             _, obj  (esp.Info)  obj.Visible =  
            esp.Snapline.Visible = 
        
        
        
         skeleton = Drawings.Skeleton[player]
         skeleton 
             _, line  (skeleton) 
                line.Visible = 
            
        
    


  ()
     _, player  (Players:()) 
        (player)
    
    Drawings.ESP = {}
    Drawings.Skeleton = {}
    Highlights = {}


 Window = Fluent:({
    Title = ,
    SubTitle = ,
    TabWidth = ,
    Size = .(, ),
    Acrylic = ,
    Theme = ,
    MinimizeKey = .KeyCode.LeftControl
})

 Tabs = {
    ESP = Window:({ Title = , Icon =  }),
    Settings = Window:({ Title = , Icon =  }),
    Config = Window:({ Title = , Icon =  })
}


     MainSection = Tabs.ESP:()
    
     EnabledToggle = MainSection:(, {
        Title = ,
        Default = 
    })
    EnabledToggle:(()
        Settings.Enabled = EnabledToggle.Value
          Settings.Enabled 
            ()
        
             _, player  (Players:()) 
                 player ~= LocalPlayer 
                    (player)
                
            
        
    )
    
     TeamCheckToggle = MainSection:(, {
        Title = ,
        Default = 
    })
    TeamCheckToggle:(()
        Settings.TeamCheck = TeamCheckToggle.Value
    )
    
     ShowTeamToggle = MainSection:(, {
        Title = ,
        Default = 
    })
    ShowTeamToggle:(()
        Settings.ShowTeam = ShowTeamToggle.Value
    )
    
     BoxSection = Tabs.ESP:()
    
     BoxESPToggle = BoxSection:(, {
        Title = ,
        Default = 
    })
    BoxESPToggle:(()
        Settings.BoxESP = BoxESPToggle.Value
    )
    
     BoxStyleDropdown = BoxSection:(, {
        Title = ,
        Values = {, , },
        Default = 
    })
    BoxStyleDropdown:((Value)
        Settings.BoxStyle = Value
    )
    
     TracerSection = Tabs.ESP:()
    
     TracerESPToggle = TracerSection:(, {
        Title = ,
        Default = 
    })
    TracerESPToggle:(()
        Settings.TracerESP = TracerESPToggle.Value
    )
    
     TracerOriginDropdown = TracerSection:(, {
        Title = ,
        Values = {, , , },
        Default = 
    })
    TracerOriginDropdown:((Value)
        Settings.TracerOrigin = Value
    )
    
     ChamsSection = Tabs.ESP:()
    
     ChamsToggle = ChamsSection:(, {
        Title = ,
        Default = 
    })
    ChamsToggle:(()
        Settings.ChamsEnabled = ChamsToggle.Value
    )
    
     ChamsFillColor = ChamsSection:(, {
        Title = ,
        Description = ,
        Default = Settings.ChamsFillColor
    })
    ChamsFillColor:((Value)
        Settings.ChamsFillColor = Value
    )
    
     ChamsOccludedColor = ChamsSection:(, {
        Title = ,
        Description = ,
        Default = Settings.ChamsOccludedColor
    })
    ChamsOccludedColor:((Value)
        Settings.ChamsOccludedColor = Value
    )
    
     ChamsOutlineColor = ChamsSection:(, {
        Title = ,
        Description = ,
        Default = Settings.ChamsOutlineColor
    })
    ChamsOutlineColor:((Value)
        Settings.ChamsOutlineColor = Value
    )
    
     ChamsTransparency = ChamsSection:(, {
        Title = ,
        Description = ,
        Default = ,
        Min = ,
        Max = ,
        Rounding = 
    })
    ChamsTransparency:((Value)
        Settings.ChamsTransparency = Value
    )
    
     ChamsOutlineTransparency = ChamsSection:(, {
        Title = ,
        Description = ,
        Default = ,
        Min = ,
        Max = ,
        Rounding = 
    })
    ChamsOutlineTransparency:((Value)
        Settings.ChamsOutlineTransparency = Value
    )
    
     ChamsOutlineThickness = ChamsSection:(, {
        Title = ,
        Description = ,
        Default = ,
        Min = ,
        Max = ,
        Rounding = 
    })
    ChamsOutlineThickness:((Value)
        Settings.ChamsOutlineThickness = Value
    )
    
     HealthSection = Tabs.ESP:()
    
     HealthESPToggle = HealthSection:(, {
        Title = ,
        Default = 
    })
    HealthESPToggle:(()
        Settings.HealthESP = HealthESPToggle.Value
    )
    
     HealthStyleDropdown = HealthSection:(, {
        Title = ,
        Values = {, , },
        Default = 
    })
    HealthStyleDropdown:((Value)
        Settings.HealthStyle = Value
    )



     ColorsSection = Tabs.Settings:()
    
     EnemyColor = ColorsSection:(, {
        Title = ,
        Description = ,
        Default = Colors.Enemy
    })
    EnemyColor:((Value)
        Colors.Enemy = Value
    )
    
     AllyColor = ColorsSection:(, {
        Title = ,
        Description = ,
        Default = Colors.Ally
    })
    AllyColor:((Value)
        Colors.Ally = Value
    )
    
     HealthColor = ColorsSection:(, {
        Title = ,
        Description = ,
        Default = Colors.Health
    })
    HealthColor:((Value)
        Colors.Health = Value
    )
    
     BoxSection = Tabs.Settings:()
    
     BoxThickness = BoxSection:(, {
        Title = ,
        Default = ,
        Min = ,
        Max = ,
        Rounding = 
    })
    BoxThickness:((Value)
        Settings.BoxThickness = Value
    )
    
     BoxTransparency = BoxSection:(, {
        Title = ,
        Default = ,
        Min = ,
        Max = ,
        Rounding = 
    })
    BoxTransparency:((Value)
        Settings.BoxFillTransparency = Value
    )
    
     ESPSection = Tabs.Settings:()
    
     MaxDistance = ESPSection:(, {
        Title = ,
        Default = ,
        Min = ,
        Max = ,
        Rounding = 
    })
    MaxDistance:((Value)
        Settings.MaxDistance = Value
    )
    
     TextSize = ESPSection:(, {
        Title = ,
        Default = ,
        Min = ,
        Max = ,
        Rounding = 
    })
    TextSize:((Value)
        Settings.TextSize = Value
    )
    
     HealthTextFormat = ESPSection:(, {
        Title = ,
        Values = {, , },
        Default = 
    })
    HealthTextFormat:((Value)
        Settings.HealthTextFormat = Value
    )
    
     EffectsSection = Tabs.Settings:()
    
     RainbowToggle = EffectsSection:(, {
        Title = ,
        Default = 
    })
    RainbowToggle:(()
        Settings.RainbowEnabled = RainbowToggle.Value
    )
    
     RainbowSpeed = EffectsSection:(, {
        Title = ,
        Default = ,
        Min = ,
        Max = ,
        Rounding = 
    })
    RainbowSpeed:((Value)
        Settings.RainbowSpeed = Value
    )
    
     RainbowOptions = EffectsSection:(, {
        Title = ,
        Values = {, , , },
        Default = ,
        Multi = 
    })
    RainbowOptions:((Value)
         Value ==  
            Settings.RainbowBoxes = 
            Settings.RainbowTracers = 
            Settings.RainbowText = 
         Value ==  
            Settings.RainbowBoxes = 
            Settings.RainbowTracers = 
            Settings.RainbowText = 
         Value ==  
            Settings.RainbowBoxes = 
            Settings.RainbowTracers = 
            Settings.RainbowText = 
         Value ==  
            Settings.RainbowBoxes = 
            Settings.RainbowTracers = 
            Settings.RainbowText = 
        
    )
    
     PerformanceSection = Tabs.Settings:()
    
     RefreshRate = PerformanceSection:(, {
        Title = ,
        Default = ,
        Min = ,
        Max = ,
        Rounding = 
    })
    RefreshRate:((Value)
        Settings.RefreshRate = /Value
    )



    SaveManager:(Fluent)
    InterfaceManager:(Fluent)
    SaveManager:()
    SaveManager:({})
    InterfaceManager:()
    SaveManager:()
    
    InterfaceManager:(Tabs.Config)
    SaveManager:(Tabs.Config)
    
     UnloadSection = Tabs.Config:()
    
     UnloadButton = UnloadSection:({
        Title = ,
        Description = ,
        Callback = ()
            ()
             _, connection  ((RunService.RenderStepped)) 
                connection:()
            
            Window:()
            Drawings = 
            Settings = 
             k, v  (()) 
                ()[k] = 
            
        
    })


.(()
     .() 
        Colors.Rainbow = .(() * Settings.RainbowSpeed % , , )
    
)

 lastUpdate = 
RunService.RenderStepped:(()
      Settings.Enabled  
        ()
         
    
    
     currentTime = ()
     currentTime - lastUpdate >= Settings.RefreshRate 
         _, player  (Players:()) 
             player ~= LocalPlayer 
                  Drawings.ESP[player] 
                    (player)
                
                (player)
            
        
        lastUpdate = currentTime
    
)

Players.PlayerAdded:(CreateESP)
Players.PlayerRemoving:(RemoveESP)

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


Window:()

Fluent:({
    Title = ,
    Content = ,
    Duration = 
})

 SkeletonSection = Tabs.ESP:()

 SkeletonESPToggle = SkeletonSection:(, {
    Title = ,
    Default = 
})
SkeletonESPToggle:(()
    Settings.SkeletonESP = SkeletonESPToggle.Value
)

 SkeletonColor = SkeletonSection:(, {
    Title = ,
    Default = Settings.SkeletonColor
})
SkeletonColor:((Value)
    Settings.SkeletonColor = Value
     _, player  (Players:()) 
         skeleton = Drawings.Skeleton[player]
         skeleton 
             _, line  (skeleton) 
                line.Color = Value
            
        
    
)

 SkeletonThickness = SkeletonSection:(, {
    Title = ,
    Default = ,
    Min = ,
    Max = ,
    Rounding = 
})
SkeletonThickness:((Value)
    Settings.SkeletonThickness = Value
     _, player  (Players:()) 
         skeleton = Drawings.Skeleton[player]
         skeleton 
             _, line  (skeleton) 
                line.Thickness = Value
            
        
    
)

 SkeletonTransparency = SkeletonSection:(, {
    Title = ,
    Default = ,
    Min = ,
    Max = ,
    Rounding = 
})
SkeletonTransparency:((Value)
    Settings.SkeletonTransparency = Value
     _, player  (Players:()) 
         skeleton = Drawings.Skeleton[player]
         skeleton 
             _, line  (skeleton) 
                line.Transparency = Value
            
        
    
)