esp by ai OPEN SOURCE

 Players = :()
 RunService = :()
 UserInputService = :()
 HttpService = :()
 MarketplaceService = :()

 LocalPlayer = Players.LocalPlayer
 Camera = .CurrentCamera
 Mouse = LocalPlayer:()





 Config = {
    
    Enabled = ,
    TeamCheck = ,
    MaxDistance = ,
    
    
    Box = ,
    DynamicBox = ,
    BoxPadding = ,
    BoxGlow = ,
    BoxGlowIntensity = ,
    BoxFill = ,
    BoxFillOpacity = ,
    BoxGradient = ,
    BoxCornerLength = ,
    BoxAnimated = ,
    BoxAccentLines = ,
    BoxCornerDots = ,
    
    
    Name = ,
    NameGlow = ,
    NameBackground = ,
    NameSize = ,
    
    
    Health = ,
    HealthSegments = ,
    HealthGlow = ,
    HealthText = ,
    
    
    Distance = ,
    
    
    Weapon = ,
    WeaponBackground = ,
    
    
    Tracer = ,
    TracerOrigin = ,
    TracerGlow = ,
    TracerSegments = ,
    
    
    Skeleton = ,
    SkeletonGlow = ,
    SkeletonThickness = ,
    
    
    HeadDot = ,
    HeadDotSize = ,
    
    
    LookDirection = ,
    LookLength = ,
    
    
    OffScreenArrows = ,
    ArrowSize = ,
    ArrowDistance = ,
    
    
    Chams = ,
    ChamsOpacity = ,
    
    
    Crosshair = ,
    Watermark = ,
    TargetInfo = ,
    FPSCounter = ,
    GlowPulse = ,
    SmoothMovement = ,
    AnimationSpeed = ,
    
    
    EnemyColor = .(, , ),
    EnemyColorLight = .(, , ),
    TeamColor = .(, , ),
    TeamColorLight = .(, , )
}





 floor, ceil, clamp, sin, cos, tan, atan2, rad, deg, abs, min, max, sqrt, pi, huge =
    .floor, .ceil, .clamp, .sin, .cos, .tan, .atan2,
    .rad, .deg, .abs, .min, .max, .sqrt, .pi, .huge

  (a, b, t)
     a + (b - a) * t


  (c1, c2, t)
     .((c1.R, c2.R, t), (c1.G, c2.G, t), (c1.B, c2.B, t))


  (v1, v2, t)
     .((v1.X, v2.X, t), (v1.Y, v2.Y, t))


  (t)
     t * t * ( -  * t)


  (speed, minVal, maxVal)
     t = ((() * speed * pi) + ) / 
     (minVal  , maxVal  , t)


  (speed, minVal, maxVal)
     t = ((() * speed) + ) / 
    t = (t)
     (minVal  , maxVal  , t)


  (percent)
    percent = (percent, , )
     percent >  
         (.(, , ), .(, , ), (percent - ) / )
     percent >  
         (.(, , ), .(, , ), (percent - ) / )
    
         (.(, , ), .(, , ), percent / )
    


  (pos)
     screenPos, onScreen = Camera:(pos)
     .(screenPos.X, screenPos.Y), onScreen, screenPos.Z


  (player)
     char = player.Character
      char    
     hum = char:()
     root = char:()
     hum  root  hum.Health > 


  (player)
      Config.TeamCheck    
     player.Team  LocalPlayer.Team  player.Team == LocalPlayer.Team


  (p1, p2)
     (p1 - p2).Magnitude






  (character)
     minX, minY = huge, huge
     maxX, maxY = -huge, -huge
     onScreenCount = 
     totalDepth = 
    
     parts = {
        , , , , ,
        , , ,
        , , ,
        , , ,
        , , ,
        , , , 
    }
    
     _, partName  (parts) 
         part = character:(partName)
         part  part:() 
             cf = part.CFrame
             size = part.Size
            
             corners = {
                cf * .( size.X/,  size.Y/,  size.Z/),
                cf * .( size.X/,  size.Y/, -size.Z/),
                cf * .( size.X/, -size.Y/,  size.Z/),
                cf * .( size.X/, -size.Y/, -size.Z/),
                cf * .(-size.X/,  size.Y/,  size.Z/),
                cf * .(-size.X/,  size.Y/, -size.Z/),
                cf * .(-size.X/, -size.Y/,  size.Z/),
                cf * .(-size.X/, -size.Y/, -size.Z/)
            }
            
             _, corner  (corners) 
                 screenPos, onScreen, depth = (corner.Position)
                 onScreen  depth >  
                    minX = (minX, screenPos.X)
                    minY = (minY, screenPos.Y)
                    maxX = (maxX, screenPos.X)
                    maxY = (maxY, screenPos.Y)
                    onScreenCount = onScreenCount + 
                    totalDepth = totalDepth + depth
                
            
        
    
    
     onScreenCount <     
    
     padding = Config.BoxPadding
    minX, minY = minX - padding, minY - padding
    maxX, maxY = maxX + padding, maxY + padding
    
     {
        Position = .((minX + maxX) / , (minY + maxY) / ),
        Size = .(maxX - minX, maxY - minY),
        Min = .(minX, minY),
        Max = .(maxX, maxY),
        Depth = totalDepth / onScreenCount
    }


  (character)
     root = character:()
      root    
    
     pos, onScreen, depth = (root.Position)
      onScreen  depth <     
    
     scale =  / (depth * ((Camera.FieldOfView / )) * ) * 
     height = scale * 
     width = height * 
    
     {
        Position = pos,
        Size = .(width, height),
        Min = .(pos.X - width/, pos.Y - height/),
        Max = .(pos.X + width/, pos.Y + height/),
        Depth = depth
    }


  (character)
     Config.DynamicBox 
         dynamic = (character)
         dynamic   dynamic 
    
     (character)






  (drawingType, props)
     d = .(drawingType)
     k, v  (props  {}) 
        (() d[k] = v )
    
     d






 ESPObjects = {}
 SmoothData = {}

  (player)
     esp = {
        
        BoxFill = (, { Filled =  }),
        BoxFillGradient = (, { Filled =  }),
        BoxGlowOuter = {},
        BoxGlowInner = {},
        BoxOutlines = {},
        BoxCorners = {},
        BoxAccentLines = {},
        BoxCornerDots = {},
        BoxCornerDotsGlow = {},
        
        
        NameBackground = (, { Filled =  }),
        NameGlow = (, { Center = , Font = .Fonts.Plex }),
        NameShadow = (, { Center = , Font = .Fonts.Plex, Color = .(,,) }),
        Name = (, { Center = , Font = .Fonts.Plex }),
        
        
        DistanceShadow = (, { Center = , Font = .Fonts.Plex, Color = .(,,) }),
        Distance = (, { Center = , Font = .Fonts.Plex }),
        
        
        WeaponBackground = (, { Filled =  }),
        WeaponShadow = (, { Center = , Font = .Fonts.Plex, Color = .(,,) }),
        Weapon = (, { Center = , Font = .Fonts.Plex }),
        
        
        HealthOutline = (, { Filled = , Color = .(,,) }),
        HealthBackground = (, { Filled =  }),
        HealthGlow = (, { Filled =  }),
        HealthSegments = {},
        HealthText = (, { Center = , Font = .Fonts.Plex, Outline =  }),
        
        
        TracerGlows = {},
        TracerLines = {},
        
        
        SkeletonGlows = {},
        SkeletonBones = {},
        SkeletonJoints = {},
        
        
        HeadGlowOuter = (, { Filled = , NumSides =  }),
        HeadGlowInner = (, { Filled = , NumSides =  }),
        HeadOutline = (, { Filled = , NumSides = , Color = .(,,) }),
        HeadDot = (, { Filled = , NumSides =  }),
        
        
        LookGlow = (, {}),
        LookLine = (, {}),
        LookArrow = (, { Filled =  }),
        
        
        ArrowGlowOuter = (, { Filled =  }),
        ArrowGlowInner = (, { Filled =  }),
        ArrowOutline = (, { Filled = , Color = .(,,) }),
        Arrow = (, { Filled =  }),
        ArrowDistance = (, { Center = , Font = .Fonts.Plex, Outline =  }),
        ArrowName = (, { Center = , Font = .Fonts.Plex, Outline =  }),
        
        
        Highlight = .()
    }
    
    
     i = ,  
        esp.BoxGlowOuter[i] = (, { Thickness =  })
        esp.BoxGlowInner[i] = (, { Thickness =  })
        esp.BoxOutlines[i] = (, { Thickness = , Color = .(,,) })
        esp.BoxCorners[i] = (, { Thickness =  })
    
    
     i = ,  
        esp.BoxAccentLines[i] = (, { Thickness =  })
        esp.BoxCornerDots[i] = (, { Filled = , NumSides = , Radius =  })
        esp.BoxCornerDotsGlow[i] = (, { Filled = , NumSides =  })
    
    
     i = , Config.HealthSegments 
        esp.HealthSegments[i] = (, { Filled =  })
    
    
     i = , Config.TracerSegments 
        esp.TracerGlows[i] = (, { Thickness =  })
        esp.TracerLines[i] = (, { Thickness =  })
    
    
     i = ,  
        esp.SkeletonGlows[i] = (, { Thickness =  })
        esp.SkeletonBones[i] = (, { Thickness =  })
    
    
     i = ,  
        esp.SkeletonJoints[i] = (, { Filled = , NumSides = , Radius =  })
    
    
    esp.Highlight.FillTransparency = Config.ChamsOpacity / 
    esp.Highlight.OutlineTransparency = 
    esp.Highlight.DepthMode = .HighlightDepthMode.AlwaysOnTop
    
     esp


  (player)
     esp = ESPObjects[player]
      esp   
    
      (d)
         d  (d) ==   d.Remove 
            (() d:() )
        
    
    
     k, v  (esp) 
         (v) ==   v[] 
             _, d  (v)  (d) 
         (v) ==  
            (() v:() )
        
            (v)
        
    
    
    ESPObjects[player] = 
    SmoothData[player] = 






  (player, esp)
     character = player.Character
     humanoid = character  character:()
     root = character  character:()
     head = character  character:()
    
      SmoothData[player] 
        SmoothData[player] = { boxMin = , boxMax = , health = , lastUpdate = () }
    
     smooth = SmoothData[player]
     deltaTime = () - smooth.lastUpdate
    smooth.lastUpdate = ()
    
    
      ()
        esp.BoxFill.Visible = 
        esp.BoxFillGradient.Visible = 
         i = ,  
            esp.BoxGlowOuter[i].Visible = 
            esp.BoxGlowInner[i].Visible = 
            esp.BoxOutlines[i].Visible = 
            esp.BoxCorners[i].Visible = 
        
         i = ,  
            esp.BoxAccentLines[i].Visible = 
            esp.BoxCornerDots[i].Visible = 
            esp.BoxCornerDotsGlow[i].Visible = 
        
        esp.NameBackground.Visible = 
        esp.NameGlow.Visible = 
        esp.NameShadow.Visible = 
        esp.Name.Visible = 
        esp.DistanceShadow.Visible = 
        esp.Distance.Visible = 
        esp.WeaponBackground.Visible = 
        esp.WeaponShadow.Visible = 
        esp.Weapon.Visible = 
        esp.HealthOutline.Visible = 
        esp.HealthBackground.Visible = 
        esp.HealthGlow.Visible = 
        esp.HealthText.Visible = 
         i = , #esp.HealthSegments  esp.HealthSegments[i].Visible =  
         i = , #esp.TracerGlows 
            esp.TracerGlows[i].Visible = 
            esp.TracerLines[i].Visible = 
        
         i = , #esp.SkeletonGlows 
            esp.SkeletonGlows[i].Visible = 
            esp.SkeletonBones[i].Visible = 
        
         i = , #esp.SkeletonJoints  esp.SkeletonJoints[i].Visible =  
        esp.HeadGlowOuter.Visible = 
        esp.HeadGlowInner.Visible = 
        esp.HeadOutline.Visible = 
        esp.HeadDot.Visible = 
        esp.LookGlow.Visible = 
        esp.LookLine.Visible = 
        esp.LookArrow.Visible = 
        esp.ArrowGlowOuter.Visible = 
        esp.ArrowGlowInner.Visible = 
        esp.ArrowOutline.Visible = 
        esp.Arrow.Visible = 
        esp.ArrowDistance.Visible = 
        esp.ArrowName.Visible = 
         esp.Highlight.Parent  esp.Highlight.Parent =  
    
    
      Config.Enabled   (player) 
        ()
        
    
    
     localRoot = LocalPlayer.Character  LocalPlayer.Character:()
      localRoot  ()  
    
     distance = (root.Position, localRoot.Position)
     distance > Config.MaxDistance  ()  
    
     isTeammate = (player)
     mainColor = isTeammate  Config.TeamColor  Config.EnemyColor
     lightColor = isTeammate  Config.TeamColorLight  Config.EnemyColorLight
    
     time = ()
     pulse = Config.GlowPulse  ( * (Config.AnimationSpeed / ), , )  (Config.BoxGlowIntensity / )
     breathe = ( * (Config.AnimationSpeed / ), , )
    
     bbox = (character)
    
    
      bbox  Config.OffScreenArrows 
         pos, onScreen = (root.Position)
          onScreen 
             center = Camera.ViewportSize / 
             dir = (pos - center).Unit
             arrowPos = center + dir * Config.ArrowDistance
            
             angle = (dir.Y, dir.X)
             size = Config.ArrowSize * breathe
            
             p1 = arrowPos + .((angle) * size, (angle) * size)
             p2 = arrowPos + .((angle + ) * size * , (angle + ) * size * )
             p3 = arrowPos + .((angle - ) * size * , (angle - ) * size * )
            
             Config.BoxGlow 
                esp.ArrowGlowOuter.PointA, esp.ArrowGlowOuter.PointB, esp.ArrowGlowOuter.PointC = p1, p2, p3
                esp.ArrowGlowOuter.Color = mainColor
                esp.ArrowGlowOuter.Transparency = pulse + 
                esp.ArrowGlowOuter.Visible = 
                
                esp.ArrowGlowInner.PointA, esp.ArrowGlowInner.PointB, esp.ArrowGlowInner.PointC = p1, p2, p3
                esp.ArrowGlowInner.Color = lightColor
                esp.ArrowGlowInner.Transparency = pulse
                esp.ArrowGlowInner.Visible = 
            
                esp.ArrowGlowOuter.Visible = 
                esp.ArrowGlowInner.Visible = 
            
            
             outDir = dir * 
            esp.ArrowOutline.PointA = p1 + outDir
            esp.ArrowOutline.PointB = p2 + outDir
            esp.ArrowOutline.PointC = p3 + outDir
            esp.ArrowOutline.Visible = 
            
            esp.Arrow.PointA, esp.Arrow.PointB, esp.Arrow.PointC = p1, p2, p3
            esp.Arrow.Color = mainColor
            esp.Arrow.Visible = 
            
            esp.ArrowDistance.Text = (distance) .. 
            esp.ArrowDistance.Position = arrowPos - dir * 
            esp.ArrowDistance.Color = .(, , )
            esp.ArrowDistance.Visible = 
            
            esp.ArrowName.Text = player.DisplayName
            esp.ArrowName.Position = arrowPos - dir * 
            esp.ArrowName.Color = mainColor
            esp.ArrowName.Visible = 
        
            esp.ArrowGlowOuter.Visible = 
            esp.ArrowGlowInner.Visible = 
            esp.ArrowOutline.Visible = 
            esp.Arrow.Visible = 
            esp.ArrowDistance.Visible = 
            esp.ArrowName.Visible = 
        
    
        esp.ArrowGlowOuter.Visible = 
        esp.ArrowGlowInner.Visible = 
        esp.ArrowOutline.Visible = 
        esp.Arrow.Visible = 
        esp.ArrowDistance.Visible = 
        esp.ArrowName.Visible = 
    
    
      bbox  ()  
    
    
     left, top, right, bottom
     Config.SmoothMovement  smooth.boxMin 
         smoothFactor = (deltaTime * , , )
        smooth.boxMin = (smooth.boxMin, bbox.Min, smoothFactor)
        smooth.boxMax = (smooth.boxMax, bbox.Max, smoothFactor)
        left, top = smooth.boxMin.X, smooth.boxMin.Y
        right, bottom = smooth.boxMax.X, smooth.boxMax.Y
    
        smooth.boxMin = bbox.Min
        smooth.boxMax = bbox.Max
        left, top = bbox.Min.X, bbox.Min.Y
        right, bottom = bbox.Max.X, bbox.Max.Y
    
    
     width = right - left
     height = bottom - top
     centerX = (left + right) / 
     centerY = (top + bottom) / 
     cornerLen = (width, height) * (Config.BoxCornerLength / )
    
    
     Config.Box 
         Config.BoxFill 
            esp.BoxFill.Position = .(left, top)
            esp.BoxFill.Size = .(width, height)
            esp.BoxFill.Color = mainColor
            esp.BoxFill.Transparency = Config.BoxFillOpacity / 
            esp.BoxFill.Visible = 
            
             Config.BoxGradient 
                esp.BoxFillGradient.Position = .(left, top)
                esp.BoxFillGradient.Size = .(width, height * )
                esp.BoxFillGradient.Color = lightColor
                esp.BoxFillGradient.Transparency = (Config.BoxFillOpacity / ) + 
                esp.BoxFillGradient.Visible = 
            
                esp.BoxFillGradient.Visible = 
            
        
            esp.BoxFill.Visible = 
            esp.BoxFillGradient.Visible = 
        
        
         corners = {
            {.(left, top), .(left + cornerLen, top)},
            {.(left, top), .(left, top + cornerLen)},
            {.(right, top), .(right - cornerLen, top)},
            {.(right, top), .(right, top + cornerLen)},
            {.(left, bottom), .(left + cornerLen, bottom)},
            {.(left, bottom), .(left, bottom - cornerLen)},
            {.(right, bottom), .(right - cornerLen, bottom)},
            {.(right, bottom), .(right, bottom - cornerLen)}
        }
        
         i, corner  (corners) 
             from, to = corner[], corner[]
             isTop = (i <= )
             cornerColor = isTop  (mainColor, lightColor, )  mainColor
            
             Config.BoxGlow 
                esp.BoxGlowOuter[i].From = from
                esp.BoxGlowOuter[i].To = to
                esp.BoxGlowOuter[i].Color = mainColor
                esp.BoxGlowOuter[i].Transparency = pulse + 
                esp.BoxGlowOuter[i].Visible = 
                
                esp.BoxGlowInner[i].From = from
                esp.BoxGlowInner[i].To = to
                esp.BoxGlowInner[i].Color = lightColor
                esp.BoxGlowInner[i].Transparency = pulse
                esp.BoxGlowInner[i].Visible = 
            
                esp.BoxGlowOuter[i].Visible = 
                esp.BoxGlowInner[i].Visible = 
            
            
            esp.BoxOutlines[i].From = from
            esp.BoxOutlines[i].To = to
            esp.BoxOutlines[i].Visible = 
            
            esp.BoxCorners[i].From = from
            esp.BoxCorners[i].To = to
            esp.BoxCorners[i].Color = cornerColor
            esp.BoxCorners[i].Visible = 
        
        
         Config.BoxAccentLines 
             accents = {
                {.(left + cornerLen + , top), .(right - cornerLen - , top)},
                {.(left + cornerLen + , bottom), .(right - cornerLen - , bottom)},
                {.(left, top + cornerLen + ), .(left, bottom - cornerLen - )},
                {.(right, top + cornerLen + ), .(right, bottom - cornerLen - )}
            }
             i, acc  (accents) 
                esp.BoxAccentLines[i].From = acc[]
                esp.BoxAccentLines[i].To = acc[]
                esp.BoxAccentLines[i].Color = mainColor
                esp.BoxAccentLines[i].Transparency = 
                esp.BoxAccentLines[i].Visible = 
            
        
             i = ,   esp.BoxAccentLines[i].Visible =  
        
        
         Config.BoxCornerDots 
             dots = {.(left, top), .(right, top), .(left, bottom), .(right, bottom)}
             dotPulse = (, , )
             i, pos  (dots) 
                 Config.BoxGlow 
                    esp.BoxCornerDotsGlow[i].Position = pos
                    esp.BoxCornerDotsGlow[i].Radius = dotPulse + 
                    esp.BoxCornerDotsGlow[i].Color = mainColor
                    esp.BoxCornerDotsGlow[i].Transparency = pulse
                    esp.BoxCornerDotsGlow[i].Visible = 
                
                    esp.BoxCornerDotsGlow[i].Visible = 
                
                esp.BoxCornerDots[i].Position = pos
                esp.BoxCornerDots[i].Color = lightColor
                esp.BoxCornerDots[i].Visible = 
            
        
             i = ,  
                esp.BoxCornerDots[i].Visible = 
                esp.BoxCornerDotsGlow[i].Visible = 
            
        
    
        esp.BoxFill.Visible = 
        esp.BoxFillGradient.Visible = 
         i = ,  
            esp.BoxGlowOuter[i].Visible = 
            esp.BoxGlowInner[i].Visible = 
            esp.BoxOutlines[i].Visible = 
            esp.BoxCorners[i].Visible = 
        
         i = ,  
            esp.BoxAccentLines[i].Visible = 
            esp.BoxCornerDots[i].Visible = 
            esp.BoxCornerDotsGlow[i].Visible = 
        
    
    
    
     Config.Name 
         namePos = .(centerX, top - )
         displayName = player.DisplayName
         textWidth = #displayName * (Config.NameSize * )
        
         Config.NameBackground 
            esp.NameBackground.Position = .(centerX - textWidth/ - , top - )
            esp.NameBackground.Size = .(textWidth + , )
            esp.NameBackground.Color = .(, , )
            esp.NameBackground.Transparency = 
            esp.NameBackground.Visible = 
        
            esp.NameBackground.Visible = 
        
        
         Config.NameGlow  Config.BoxGlow 
            esp.NameGlow.Text = displayName
            esp.NameGlow.Position = namePos
            esp.NameGlow.Size = Config.NameSize
            esp.NameGlow.Color = mainColor
            esp.NameGlow.Transparency = pulse
            esp.NameGlow.Visible = 
        
            esp.NameGlow.Visible = 
        
        
        esp.NameShadow.Text = displayName
        esp.NameShadow.Position = namePos + .(, )
        esp.NameShadow.Size = Config.NameSize
        esp.NameShadow.Visible = 
        
        esp.Name.Text = displayName
        esp.Name.Position = namePos
        esp.Name.Size = Config.NameSize
        esp.Name.Color = mainColor
        esp.Name.Visible = 
    
        esp.NameBackground.Visible = 
        esp.NameGlow.Visible = 
        esp.NameShadow.Visible = 
        esp.Name.Visible = 
    
    
    
     Config.Distance 
         distPos = .(centerX, bottom + )
         distText =  .. (distance) .. 
        
        esp.DistanceShadow.Text = distText
        esp.DistanceShadow.Position = distPos + .(, )
        esp.DistanceShadow.Size = 
        esp.DistanceShadow.Visible = 
        
        esp.Distance.Text = distText
        esp.Distance.Position = distPos
        esp.Distance.Size = 
        esp.Distance.Color = .(, , )
        esp.Distance.Visible = 
    
        esp.DistanceShadow.Visible = 
        esp.Distance.Visible = 
    
    
    
     Config.Weapon 
         tool = character:()
         tool 
             weapPos = .(centerX, bottom + )
             weapText = tool.Name
             textWidth = #weapText * 
            
             Config.WeaponBackground 
                esp.WeaponBackground.Position = .(centerX - textWidth/ - , bottom + )
                esp.WeaponBackground.Size = .(textWidth + , )
                esp.WeaponBackground.Color = .(, , )
                esp.WeaponBackground.Transparency = 
                esp.WeaponBackground.Visible = 
            
                esp.WeaponBackground.Visible = 
            
            
            esp.WeaponShadow.Text = weapText
            esp.WeaponShadow.Position = weapPos + .(, )
            esp.WeaponShadow.Size = 
            esp.WeaponShadow.Visible = 
            
            esp.Weapon.Text = weapText
            esp.Weapon.Position = weapPos
            esp.Weapon.Size = 
            esp.Weapon.Color = .(, , )
            esp.Weapon.Visible = 
        
            esp.WeaponBackground.Visible = 
            esp.WeaponShadow.Visible = 
            esp.Weapon.Visible = 
        
    
        esp.WeaponBackground.Visible = 
        esp.WeaponShadow.Visible = 
        esp.Weapon.Visible = 
    
    
    
     Config.Health 
         healthPercent = (humanoid.Health / humanoid.MaxHealth, , )
        smooth.health = (smooth.health, healthPercent, (deltaTime * , , ))
         smoothHealth = smooth.health
         healthColor = (smoothHealth)
        
         barWidth = 
         barHeight = height
         barX = left - barWidth - 
         barY = top
        
         segCount = Config.HealthSegments
         segGap = 
         segHeight = (barHeight - (segCount - ) * segGap) / segCount
        
        esp.HealthOutline.Position = .(barX - , barY - )
        esp.HealthOutline.Size = .(barWidth + , barHeight + )
        esp.HealthOutline.Visible = 
        
        esp.HealthBackground.Position = .(barX - , barY - )
        esp.HealthBackground.Size = .(barWidth + , barHeight + )
        esp.HealthBackground.Color = .(, , )
        esp.HealthBackground.Visible = 
        
         Config.HealthGlow  Config.BoxGlow 
             glowH = barHeight * smoothHealth
            esp.HealthGlow.Position = .(barX - , top + (barHeight - glowH) - )
            esp.HealthGlow.Size = .(barWidth + , glowH + )
            esp.HealthGlow.Color = healthColor
            esp.HealthGlow.Transparency = pulse + 
            esp.HealthGlow.Visible = 
        
            esp.HealthGlow.Visible = 
        
        
         filledSegs = (smoothHealth * segCount + )
         i = , segCount 
             esp.HealthSegments[i] 
                 segY = barY + (segCount - i) * (segHeight + segGap)
                 segColor = (i / segCount)
                esp.HealthSegments[i].Position = .(barX, segY)
                esp.HealthSegments[i].Size = .(barWidth, segHeight)
                esp.HealthSegments[i].Color = i <= filledSegs  segColor  .(, , )
                esp.HealthSegments[i].Transparency = i <= filledSegs    
                esp.HealthSegments[i].Visible = 
            
        
        
         Config.HealthText  smoothHealth <  
            esp.HealthText.Text = (humanoid.Health)
            esp.HealthText.Position = .(barX + barWidth/, barY - )
            esp.HealthText.Color = healthColor
            esp.HealthText.Size = 
            esp.HealthText.Visible = 
        
            esp.HealthText.Visible = 
        
    
        esp.HealthOutline.Visible = 
        esp.HealthBackground.Visible = 
        esp.HealthGlow.Visible = 
        esp.HealthText.Visible = 
         i = , #esp.HealthSegments  esp.HealthSegments[i].Visible =  
    
    
    
     Config.Tracer 
         screenSize = Camera.ViewportSize
         startPos
         Config.TracerOrigin ==  
            startPos = .(screenSize.X / , screenSize.Y)
         Config.TracerOrigin ==  
            startPos = .(screenSize.X / , )
         Config.TracerOrigin ==  
            startPos = screenSize / 
        
            startPos = UserInputService:()
        
        
         endPos = .(centerX, bottom)
         segments = Config.TracerSegments
        
         i = , segments 
             esp.TracerGlows[i]  esp.TracerLines[i] 
                 t1 = (i - ) / segments
                 t2 = i / segments
                 tMid = (t1 + t2) / 
                
                 from = (startPos, endPos, t1)
                 to = (startPos, endPos, t2)
                 segColor = (.(, , ), mainColor, (tMid))
                
                 Config.TracerGlow  Config.BoxGlow 
                    esp.TracerGlows[i].From = from
                    esp.TracerGlows[i].To = to
                    esp.TracerGlows[i].Color = segColor
                    esp.TracerGlows[i].Transparency = (, pulse, (tMid))
                    esp.TracerGlows[i].Visible = 
                
                    esp.TracerGlows[i].Visible = 
                
                
                esp.TracerLines[i].From = from
                esp.TracerLines[i].To = to
                esp.TracerLines[i].Color = segColor
                esp.TracerLines[i].Transparency = (, , (tMid))
                esp.TracerLines[i].Visible = 
            
        
    
         i = , #esp.TracerGlows 
             esp.TracerGlows[i]  esp.TracerGlows[i].Visible =  
             esp.TracerLines[i]  esp.TracerLines[i].Visible =  
        
    
    
    
     Config.Skeleton 
         bones = {
            {, },
            {, }, {, }, {, },
            {, }, {, }, {, },
            {, },
            {, }, {, }, {, },
            {, }, {, }, {, }
        }
        
         r6 = {
            {, },
            {, }, {, }, {, },
            {, }, {, }, {, },
            {, },
            {, }, {, }, {, },
            {, }, {, }, {, }
        }
        
         boneList = character:()  bones  r6
         jointPositions = {}
        
         i, pair  (boneList) 
             p1 = character:(pair[])
             p2 = character:(pair[])
            
             p1  p2  p1 ~= p2  esp.SkeletonGlows[i]  esp.SkeletonBones[i] 
                 pos1, on1 = (p1.Position)
                 pos2, on2 = (p2.Position)
                
                 on1  on2 
                     Config.SkeletonGlow  Config.BoxGlow 
                        esp.SkeletonGlows[i].From = pos1
                        esp.SkeletonGlows[i].To = pos2
                        esp.SkeletonGlows[i].Color = mainColor
                        esp.SkeletonGlows[i].Transparency = pulse + 
                        esp.SkeletonGlows[i].Visible = 
                    
                        esp.SkeletonGlows[i].Visible = 
                    
                    
                    esp.SkeletonBones[i].From = pos1
                    esp.SkeletonBones[i].To = pos2
                    esp.SkeletonBones[i].Color = mainColor
                    esp.SkeletonBones[i].Thickness = Config.SkeletonThickness / 
                    esp.SkeletonBones[i].Visible = 
                    
                    jointPositions[(pos1)] = {pos = pos1, color = lightColor}
                    jointPositions[(pos2)] = {pos = pos2, color = lightColor}
                
                    esp.SkeletonGlows[i].Visible = 
                    esp.SkeletonBones[i].Visible = 
                
             esp.SkeletonGlows[i]  esp.SkeletonBones[i] 
                esp.SkeletonGlows[i].Visible = 
                esp.SkeletonBones[i].Visible = 
            
        
        
         jointIndex = 
         _, data  (jointPositions) 
             esp.SkeletonJoints[jointIndex] 
                esp.SkeletonJoints[jointIndex].Position = data.pos
                esp.SkeletonJoints[jointIndex].Color = data.color
                esp.SkeletonJoints[jointIndex].Visible = 
                jointIndex = jointIndex + 
            
        
         i = jointIndex, #esp.SkeletonJoints 
             esp.SkeletonJoints[i]  esp.SkeletonJoints[i].Visible =  
        
    
         i = , #esp.SkeletonGlows 
             esp.SkeletonGlows[i]  esp.SkeletonGlows[i].Visible =  
             esp.SkeletonBones[i]  esp.SkeletonBones[i].Visible =  
        
         i = , #esp.SkeletonJoints 
             esp.SkeletonJoints[i]  esp.SkeletonJoints[i].Visible =  
        
    
    
    
     Config.HeadDot  head 
         headPos, headOn = (head.Position)
         headOn 
             dotSize = (Config.HeadDotSize - bbox.Depth / , , Config.HeadDotSize + )
            dotSize = dotSize * breathe
            
             Config.BoxGlow 
                esp.HeadGlowOuter.Position = headPos
                esp.HeadGlowOuter.Radius = dotSize + 
                esp.HeadGlowOuter.Color = mainColor
                esp.HeadGlowOuter.Transparency = pulse + 
                esp.HeadGlowOuter.Visible = 
                
                esp.HeadGlowInner.Position = headPos
                esp.HeadGlowInner.Radius = dotSize + 
                esp.HeadGlowInner.Color = lightColor
                esp.HeadGlowInner.Transparency = pulse
                esp.HeadGlowInner.Visible = 
            
                esp.HeadGlowOuter.Visible = 
                esp.HeadGlowInner.Visible = 
            
            
            esp.HeadOutline.Position = headPos
            esp.HeadOutline.Radius = dotSize + 
            esp.HeadOutline.Visible = 
            
            esp.HeadDot.Position = headPos
            esp.HeadDot.Radius = dotSize
            esp.HeadDot.Color = lightColor
            esp.HeadDot.Visible = 
        
            esp.HeadGlowOuter.Visible = 
            esp.HeadGlowInner.Visible = 
            esp.HeadOutline.Visible = 
            esp.HeadDot.Visible = 
        
    
        esp.HeadGlowOuter.Visible = 
        esp.HeadGlowInner.Visible = 
        esp.HeadOutline.Visible = 
        esp.HeadDot.Visible = 
    
    
    
     Config.LookDirection  head 
         headPos, headOn = (head.Position)
         lookVector = head.CFrame.LookVector
         lookEndWorld = head.Position + lookVector * (Config.LookLength / )
         lookEndPos, lookEndOn = (lookEndWorld)
        
         headOn  lookEndOn 
             lookColor = .(, , )
            
             Config.BoxGlow 
                esp.LookGlow.From = headPos
                esp.LookGlow.To = lookEndPos
                esp.LookGlow.Color = lookColor
                esp.LookGlow.Thickness = 
                esp.LookGlow.Transparency = pulse + 
                esp.LookGlow.Visible = 
            
                esp.LookGlow.Visible = 
            
            
            esp.LookLine.From = headPos
            esp.LookLine.To = lookEndPos
            esp.LookLine.Color = lookColor
            esp.LookLine.Thickness = 
            esp.LookLine.Visible = 
            
             dir = (lookEndPos - headPos).Unit
             arrowSize = 
             angle = (dir.Y, dir.X)
            
             ap1 = lookEndPos
             ap2 = lookEndPos - .((angle - ) * arrowSize, (angle - ) * arrowSize)
             ap3 = lookEndPos - .((angle + ) * arrowSize, (angle + ) * arrowSize)
            
            esp.LookArrow.PointA = ap1
            esp.LookArrow.PointB = ap2
            esp.LookArrow.PointC = ap3
            esp.LookArrow.Color = lookColor
            esp.LookArrow.Visible = 
        
            esp.LookGlow.Visible = 
            esp.LookLine.Visible = 
            esp.LookArrow.Visible = 
        
    
        esp.LookGlow.Visible = 
        esp.LookLine.Visible = 
        esp.LookArrow.Visible = 
    
    
    
     Config.Chams 
         chamsPulse = (, , )
        esp.Highlight.FillColor = mainColor
        esp.Highlight.OutlineColor = lightColor
        esp.Highlight.FillTransparency = chamsPulse
        esp.Highlight.Adornee = character
        esp.Highlight.Parent = character
    
        esp.Highlight.Parent = 
    






 Crosshair = {
    TopGlow = (, { Thickness =  }),
    Top = (, { Thickness =  }),
    BottomGlow = (, { Thickness =  }),
    Bottom = (, { Thickness =  }),
    LeftGlow = (, { Thickness =  }),
    Left = (, { Thickness =  }),
    RightGlow = (, { Thickness =  }),
    Right = (, { Thickness =  }),
    DotGlow = (, { Filled = , NumSides =  }),
    Dot = (, { Filled = , NumSides =  }),
    Ring = (, { Filled = , NumSides = , Thickness =  })
}

  ()
      Config.Crosshair 
         _, v  (Crosshair)  v.Visible =  
        
    
    
     center = Camera.ViewportSize / 
     gap = 
     size = 
     color = .(, , )
     pulse = (, , )
     breathe = (, , )
    
    Crosshair.TopGlow.From = .(center.X, center.Y - gap)
    Crosshair.TopGlow.To = .(center.X, center.Y - gap - size)
    Crosshair.TopGlow.Color = color
    Crosshair.TopGlow.Transparency = pulse
    Crosshair.TopGlow.Visible = 
    
    Crosshair.Top.From = Crosshair.TopGlow.From
    Crosshair.Top.To = Crosshair.TopGlow.To
    Crosshair.Top.Color = color
    Crosshair.Top.Visible = 
    
    Crosshair.BottomGlow.From = .(center.X, center.Y + gap)
    Crosshair.BottomGlow.To = .(center.X, center.Y + gap + size)
    Crosshair.BottomGlow.Color = color
    Crosshair.BottomGlow.Transparency = pulse
    Crosshair.BottomGlow.Visible = 
    
    Crosshair.Bottom.From = Crosshair.BottomGlow.From
    Crosshair.Bottom.To = Crosshair.BottomGlow.To
    Crosshair.Bottom.Color = color
    Crosshair.Bottom.Visible = 
    
    Crosshair.LeftGlow.From = .(center.X - gap, center.Y)
    Crosshair.LeftGlow.To = .(center.X - gap - size, center.Y)
    Crosshair.LeftGlow.Color = color
    Crosshair.LeftGlow.Transparency = pulse
    Crosshair.LeftGlow.Visible = 
    
    Crosshair.Left.From = Crosshair.LeftGlow.From
    Crosshair.Left.To = Crosshair.LeftGlow.To
    Crosshair.Left.Color = color
    Crosshair.Left.Visible = 
    
    Crosshair.RightGlow.From = .(center.X + gap, center.Y)
    Crosshair.RightGlow.To = .(center.X + gap + size, center.Y)
    Crosshair.RightGlow.Color = color
    Crosshair.RightGlow.Transparency = pulse
    Crosshair.RightGlow.Visible = 
    
    Crosshair.Right.From = Crosshair.RightGlow.From
    Crosshair.Right.To = Crosshair.RightGlow.To
    Crosshair.Right.Color = color
    Crosshair.Right.Visible = 
    
    Crosshair.DotGlow.Position = center
    Crosshair.DotGlow.Radius = 
    Crosshair.DotGlow.Color = color
    Crosshair.DotGlow.Transparency = pulse
    Crosshair.DotGlow.Visible = 
    
    Crosshair.Dot.Position = center
    Crosshair.Dot.Radius = 
    Crosshair.Dot.Color = .(, , )
    Crosshair.Dot.Visible = 
    
     ringRadius =  * breathe
    Crosshair.Ring.Position = center
    Crosshair.Ring.Radius = ringRadius
    Crosshair.Ring.Color = color
    Crosshair.Ring.Transparency = 
    Crosshair.Ring.Visible = 






 Watermark = {
    Background = (, { Filled =  }),
    Border = (, {}),
    Logo = (, { Font = .Fonts.Plex }),
    Divider = (, {}),
    FPS = (, { Font = .Fonts.Plex }),
    Ping = (, { Font = .Fonts.Plex })
}

 fpsCounter = 
 lastFPSTick = ()
 currentFPS = 

  ()
      Config.Watermark 
         _, v  (Watermark)  v.Visible =  
        
    
    
    fpsCounter = fpsCounter + 
     () - lastFPSTick >=  
        currentFPS = fpsCounter
        fpsCounter = 
        lastFPSTick = ()
    
    
     ping = 
    (()
        ping = :().Network.ServerStatsItem[]:()
    )
    
     x = Camera.ViewportSize.X - 
     y = 
     width = 
     height = 
    
    Watermark.Background.Position = .(x, y)
    Watermark.Background.Size = .(width, height)
    Watermark.Background.Color = .(, , )
    Watermark.Background.Transparency = 
    Watermark.Background.Visible = 
    
    Watermark.Border.From = .(x, y)
    Watermark.Border.To = .(x + width, y)
    Watermark.Border.Color = .(, , )
    Watermark.Border.Thickness = 
    Watermark.Border.Visible = 
    
    Watermark.Logo.Text = 
    Watermark.Logo.Position = .(x + , y + )
    Watermark.Logo.Size = 
    Watermark.Logo.Color = .(, , )
    Watermark.Logo.Visible = 
    
    Watermark.Divider.From = .(x + , y + )
    Watermark.Divider.To = .(x + , y + height - )
    Watermark.Divider.Color = .(, , )
    Watermark.Divider.Thickness = 
    Watermark.Divider.Visible = 
    
     fpsColor = currentFPS >=   .(, , ) 
                     currentFPS >=   .(, , )  .(, , )
    
    Watermark.FPS.Text = currentFPS .. 
    Watermark.FPS.Position = .(x + , y + )
    Watermark.FPS.Size = 
    Watermark.FPS.Color = fpsColor
    Watermark.FPS.Visible = Config.FPSCounter
    
     pingColor = ping <=   .(, , ) 
                      ping <=   .(, , )  .(, , )
    
    Watermark.Ping.Text = (ping) .. 
    Watermark.Ping.Position = .(x + , y + )
    Watermark.Ping.Size = 
    Watermark.Ping.Color = pingColor
    Watermark.Ping.Visible = 






 _, player  (Players:()) 
     player ~= LocalPlayer 
        ESPObjects[player] = (player)
    


Players.PlayerAdded:((player)
    player.CharacterAdded:(()
        .()
          ESPObjects[player] 
            ESPObjects[player] = (player)
        
    )
)

Players.PlayerRemoving:((player)
    (player)
)





RunService.RenderStepped:(()
    Camera = .CurrentCamera
    
     player, esp  (ESPObjects) 
         player  player.Parent 
            (player, esp)
        
            (player)
        
    
    
    ()
    ()
)





 gui_config = {
    Color = .(, , ),
    Keybind = .KeyCode.RightShift
}

 library = (:())()
 window = library:(gui_config, ())

(()
    library:( .. MarketplaceService:(.PlaceId).Name)
)

library.flags = library.flags  {}


 tabs = {
    main = window:(),
    box = window:(),
    info = window:(),
    lines = window:(),
    extras = window:(),
    colors = window:(),
    settings = window:()
}


 general_section = tabs.main:(, )
 performance_section = tabs.main:(, )

general_section:(, Config.Enabled, (v) Config.Enabled = v )
general_section:(, Config.TeamCheck, (v) Config.TeamCheck = v )
general_section:(, , , Config.MaxDistance, , (v) Config.MaxDistance = v )

performance_section:(, Config.DynamicBox, (v) Config.DynamicBox = v )
performance_section:(, Config.SmoothMovement, (v) Config.SmoothMovement = v )
performance_section:(, , , Config.AnimationSpeed, , (v) Config.AnimationSpeed = v )


 box_section = tabs.box:(, )
 box_effects = tabs.box:(, )

box_section:(, Config.Box, (v) Config.Box = v )
box_section:(, , , Config.BoxPadding, , (v) Config.BoxPadding = v )
box_section:(, , , Config.BoxCornerLength, , (v) Config.BoxCornerLength = v )

box_effects:(, Config.BoxGlow, (v) Config.BoxGlow = v )
box_effects:(, , , Config.BoxGlowIntensity, , (v) Config.BoxGlowIntensity = v )
box_effects:(, Config.BoxFill, (v) Config.BoxFill = v )
box_effects:(, , , Config.BoxFillOpacity, , (v) Config.BoxFillOpacity = v )
box_effects:(, Config.BoxGradient, (v) Config.BoxGradient = v )
box_effects:(, Config.BoxAccentLines, (v) Config.BoxAccentLines = v )
box_effects:(, Config.BoxCornerDots, (v) Config.BoxCornerDots = v )


 name_section = tabs.info:(, )
 info_section = tabs.info:(, )

name_section:(, Config.Name, (v) Config.Name = v )
name_section:(, Config.NameGlow, (v) Config.NameGlow = v )
name_section:(, Config.NameBackground, (v) Config.NameBackground = v )
name_section:(, , , Config.NameSize, , (v) Config.NameSize = v )

info_section:(, Config.Distance, (v) Config.Distance = v )
info_section:(, Config.Weapon, (v) Config.Weapon = v )
info_section:(, Config.WeaponBackground, (v) Config.WeaponBackground = v )


 health_section = tabs.lines:(, )
 tracer_section = tabs.lines:(, )
 skeleton_section = tabs.lines:(, )

health_section:(, Config.Health, (v) Config.Health = v )
health_section:(, , , Config.HealthSegments, , (v) Config.HealthSegments = v )
health_section:(, Config.HealthGlow, (v) Config.HealthGlow = v )
health_section:(, Config.HealthText, (v) Config.HealthText = v )

tracer_section:(, Config.Tracer, (v) Config.Tracer = v )
tracer_section:(, Config.TracerGlow, (v) Config.TracerGlow = v )
tracer_section:(, , , Config.TracerSegments, , (v) Config.TracerSegments = v )
tracer_section:(, {, , , }, (v) Config.TracerOrigin = v , , )

skeleton_section:(, Config.Skeleton, (v) Config.Skeleton = v )
skeleton_section:(, Config.SkeletonGlow, (v) Config.SkeletonGlow = v )
skeleton_section:(, , , Config.SkeletonThickness, , (v) Config.SkeletonThickness = v )


 head_section = tabs.extras:(, )
 look_section = tabs.extras:(, )
 arrow_section = tabs.extras:(, )
 chams_section = tabs.extras:(, )

head_section:(, Config.HeadDot, (v) Config.HeadDot = v )
head_section:(, , , Config.HeadDotSize, , (v) Config.HeadDotSize = v )

look_section:(, Config.LookDirection, (v) Config.LookDirection = v )
look_section:(, , , Config.LookLength, , (v) Config.LookLength = v )

arrow_section:(, Config.OffScreenArrows, (v) Config.OffScreenArrows = v )
arrow_section:(, , , Config.ArrowSize, , (v) Config.ArrowSize = v )
arrow_section:(, , , Config.ArrowDistance, , (v) Config.ArrowDistance = v )

chams_section:(, Config.Chams, (v) Config.Chams = v )
chams_section:(, , , Config.ChamsOpacity, , (v) Config.ChamsOpacity = v )


 enemy_color_section = tabs.colors:(, )
 team_color_section = tabs.colors:(, )
 theme_section = tabs.colors:(, )

enemy_color_section:(, (color)
    Config.EnemyColor = color
, , , )

enemy_color_section:(, (color)
    Config.EnemyColorLight = color
, , , )

team_color_section:(, (color)
    Config.TeamColor = color
, , , )

team_color_section:(, (color)
    Config.TeamColorLight = color
, , , )

theme_section:(, Config.GlowPulse, (v)
    Config.GlowPulse = v
)

theme_section:(, , , Config.BoxGlowIntensity, , (v)
    Config.BoxGlowIntensity = v
)

theme_section:(, , , Config.AnimationSpeed, , (v)
    Config.AnimationSpeed = v
end)

-- ═══ SETTINGS TAB ═══
local ui_elements_section = tabs.settings:CreateSection("UI Elements", "left")
local config_section = tabs.settings:CreateSection("Configuration", "right")
local credits_section = tabs.settings:CreateSection("Credits", "right")

ui_elements_section:CreateToggle("Crosshair", Config.Crosshair, function(v)
    Config.Crosshair = v
end)

ui_elements_section:CreateToggle("Watermark", Config.Watermark, function(v)
    Config.Watermark = v
end)

ui_elements_section:CreateToggle("FPS Counter", Config.FPSCounter, function(v)
    Config.FPSCounter = v
end)

ui_elements_section:CreateToggle("Target Info", Config.TargetInfo, function(v)
    Config.TargetInfo = v
end)

config_section:CreateButton("Save Config", function()
    local success = pcall(function()
        if writefile then
            local configData = HttpService:JSONEncode(Config)
            writefile("JCHEATS_ESP_Config.json", configData)
        end
    end)
    if success then
        library:Notification("Config", "Saved successfully!", 3)
    else
        library:Notification("Error", "Failed to save", 3)
    end
end)

config_section:CreateButton("Load Config", function()
    local success = pcall(function()
        if readfile and isfile and isfile("JCHEATS_ESP_Config.json") then
            local data = readfile("JCHEATS_ESP_Config.json")
            local loaded = HttpService:JSONDecode(data)
            for k, v in pairs(loaded) do
                if Config[k] ~= nil then
                    Config[k] = v
                end
            end
        end
    end)
    if success then
        library:Notification("Config", "Loaded!", 3)
    else
        library:Notification("Error", "Failed to load", 3)
    end
end)

config_section:CreateButton("Reset Default", function()
    Config.Enabled = true
    Config.TeamCheck = false
    Config.MaxDistance = 2500
    Config.Box = true
    Config.DynamicBox = true
    Config.BoxGlow = true
    Config.BoxFill = true
    Config.Name = true
    Config.Health = true
    Config.Distance = true
    Config.Tracer = true
    Config.Skeleton = true
    Config.HeadDot = true
    Config.Chams = true
    Config.Crosshair = true
    Config.Watermark = true
    library:Notification("Config", "Reset to defaults!", 3)
end)

credits_section:CreateButton("Discord (Copy)", function()
    if setclipboard then
        setclipboard("discord.gg/jcheats")
        library:Notification("Copied", "Discord link copied!", 2)
    end
end)

-- ════════════════════════════════════════════════════════════════════════════════
-- KEYBIND HANDLER
-- ════════════════════════════════════════════════════════════════════════════════

UserInputService.InputBegan:Connect(function(input, processed)
    if processed then return end
    
    if input.KeyCode == gui_config.Keybind then
        library:ToggleUI()
    end
    
    if input.KeyCode == Enum.KeyCode.F1 then
        Config.Enabled = not Config.Enabled
        library:Notification("ESP", Config.Enabled and "Enabled" or "Disabled", 2)
    end
    
    if input.KeyCode == Enum.KeyCode.F2 then
        Config.Box = not Config.Box
        library:Notification("Box", Config.Box and "Enabled" or "Disabled", 2)
    end
    
    if input.KeyCode == Enum.KeyCode.F3 then
        Config.Skeleton = not Config.Skeleton
        library:Notification("Skeleton", Config.Skeleton and "Enabled" or "Disabled", 2)
    end
    
    if input.KeyCode == Enum.KeyCode.F4 then
        Config.Chams = not Config.Chams
        library:Notification("Chams", Config.Chams and "Enabled" or "Disabled", 2)
    end
end)

-- ════════════════════════════════════════════════════════════════════════════════
-- STARTUP
-- ════════════════════════════════════════════════════════════════════════════════

task.spawn(function()
    task.wait(1)
    library:Notification("JCHEATS", "Masterpiece ESP loaded!", 5)
    library:Notification("Menu", "Press RightShift to toggle", 3)
end)

print([[
╔══════════════════════════════════════════════════════════════╗
║              JCHEATS Masterpiece ESP Loaded!                 ║
║                                                              ║
║  RightShift - Menu | F1 - ESP | F2 - Box                    ║
║  F3 - Skeleton | F4 - Chams                                  ║
║                                                              ║
║                    Made by Bin for Jack ♡                    ║
╚══════════════════════════════════════════════════════════════╝
]])