Eh Script Vault open source

 Rayfield = (:())()


 Players = :()
 LocalPlayer = Players.LocalPlayer
 Camera = .CurrentCamera
 RunService = :()
 UserInputService = :()
 UIS = UserInputService
 ReplicatedStorage = :()
 Players = :()
 LocalPlayer = Players.LocalPlayer
 camCFrame = Camera.CFrame

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


 discordInvite = 
(discordInvite)
Rayfield:({
    Title = ,
    Content = ,
    Duration = ,
    Image = ,
    Actions = { Ignore = { Name = , Callback = () ()  } }
})

 Window = Rayfield:({
    Name = ,
    LoadingTitle = ,
    LoadingSubtitle = ,
    ShowText = ,
    Theme = ,
    ToggleUIKeybind = ,
    KeySystem = ,
    KeySettings = {
        Title = ,
        Subtitle = ,
        Note = ,
        FileName = ,
        SaveKey = ,
        GrabKeyFromSite = ,
        Key = {}
    },
    ConfiglurationSaving = {
        Enabled = ,
        FileName = 
    },
    Discord = { Enabled = , Invite = , RememberJoins =  }
})





 AimTab = Window:()
 SilentTab = Window:()
 GunTab = Window:()
 ESPTab = Window:()
 ColorTab = Window:()
 Tab = Window:()


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


 AimBotEnabled = 
 AimKeyHeld = 
 AimKey = .KeyCode.Q
 MaxDistance = 
 AimFOV = 
 AimSmoothness = 
 ShowFOV = 
 VisibleCheckEnabled = 
 AimPart = 
 PredictionEnabled = 
 PredictionAmount = 
 FOVColor = .(,,)


  (size, color)
     gui = LocalPlayer:():()  .()
    gui.Name = 
    gui.ResetOnSpawn = 
    gui.Parent = LocalPlayer:()

     frame = .()
    frame.Name = 
    frame.Parent = gui
    frame.AnchorPoint = .(,)
    frame.Position = .(,,,)
    frame.Size = .(,size*,,size*)
    frame.BackgroundTransparency = 
    frame.BorderSizePixel = 
    frame.Visible = ShowFOV

     stroke = .()
    stroke.Parent = frame
    stroke.Color = color
    stroke.Thickness = 

     corner = .()
    corner.Parent = frame
    corner.CornerRadius = .(,)

     frame, stroke


 AimbotFOVCircle, AimbotFOVStroke = (AimFOV, FOVColor)


UserInputService.InputBegan:((input, gameProcessed)
      gameProcessed  input.KeyCode == AimKey 
        AimKeyHeld = 
    
)
UserInputService.InputEnded:((input)
     input.KeyCode == AimKey 
        AimKeyHeld = 
    
)


  (worldPos)
     mousePos = UserInputService:()
     screenPos, onScreen = Camera:(worldPos)
      onScreen    
     dist = (.(screenPos.X, screenPos.Y) - .(mousePos.X, mousePos.Y)).Magnitude
     dist <= AimFOV


  (part)
     origin = Camera.CFrame.Position
     direction = (part.Position - origin)
     rayParams = RaycastParams.()
    rayParams.FilterDescendantsInstances = {LocalPlayer.Character}
    rayParams.FilterType = .RaycastFilterType.Blacklist
     result = :(origin, direction, rayParams)
     result 
         result.Instance:(part.Parent)
    
     


  (part)
     PredictionEnabled  part.Parent:() 
         velocity = part.Parent.HumanoidRootPart.Velocity
         part.Position + velocity * PredictionAmount
    
     part.Position


  ()
     best, bestDist = , .huge
     _, pl  (Players:()) 
         pl ~= LocalPlayer  pl.Character  pl.Character:(AimPart) 
             part = pl.Character[AimPart]
             dist = (part.Position - Camera.CFrame.Position).Magnitude
             visible = 
             VisibleCheckEnabled 
                visible = (part)
            
             dist <= MaxDistance  dist < bestDist  (part.Position)  visible 
                best = part
                bestDist = dist
            
        
    
     best



AimTab:({Name=, CurrentValue=AimBotEnabled, Callback=(val) AimBotEnabled=val })
AimTab:({Name=, CurrentKeybind=AimKey.Name, HoldToInteract=, Callback=(isHeld) AimKeyHeld=isHeld })
AimTab:({Name=, Range={,}, Increment=, CurrentValue=AimFOV, Callback=(val) AimFOV=val;  AimbotFOVCircle  AimbotFOVCircle.Size=.(,val*,,val*)  })
AimTab:({Name=, Range={,}, Increment=, CurrentValue=MaxDistance, Callback=(val) MaxDistance=val })
AimTab:({Name=, Range={,}, Increment=, CurrentValue=AimSmoothness, Callback=(val) AimSmoothness=val })
AimTab:({Name=, Range={,}, Increment=, CurrentValue=PredictionAmount, Callback=(val) PredictionAmount=val })
AimTab:({Name=, CurrentValue=ShowFOV, Callback=(val) ShowFOV=val;  AimbotFOVCircle  AimbotFOVCircle.Visible=val  })
AimTab:({Name=, CurrentValue=VisibleCheckEnabled, Callback=(val) VisibleCheckEnabled=val })
AimTab:({Name=, CurrentValue=PredictionEnabled, Callback=(val) PredictionEnabled=val })
AimTab:({Name=, Options={,,,}, CurrentOption={AimPart}, Callback=(opt) AimPart=opt[] })

RunService.RenderStepped:(()
     AimbotFOVCircle 
        AimbotFOVCircle.Position = .(,,,)
    
     AimBotEnabled  AimKeyHeld 
         target = ()
         target 
             targetPos = (target)
             currentCFrame = Camera.CFrame
             targetCFrame = .(currentCFrame.Position, targetPos)
            Camera.CFrame = currentCFrame:(targetCFrame, AimSmoothness)
        
    
)


  (part, basePrediction)
     predictedPos = part.Position
     part.Parent:() 
         velocity = part.Parent.HumanoidRootPart.Velocity
        predictedPos = predictedPos + velocity * (basePrediction  )
    
     randomOffset = .(
        .(-,)/,
        .(-,)/,
        .(-,)/
    )
    predictedPos = predictedPos + randomOffset
     predictedPos



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

 SilentSettings = {
    Enable = ,
    FOV = ,
    HitChance = ,
    Delay = ,
    LifeCheck = ,
    VisibleCheck = ,
    ShootThroughWalls = ,
    ShowFOV = ,
    PredictionEnabled = ,
    PredictionAmount = 
}
 lastShot = 

 SilentFOVGui = .()
SilentFOVGui.Name = 
SilentFOVGui.ResetOnSpawn = 
SilentFOVGui.DisplayOrder = 
SilentFOVGui.Parent = LocalPlayer:()

 SilentFOVCircle = .()
SilentFOVCircle.AnchorPoint = .(,)
SilentFOVCircle.Position = .(,,,)
SilentFOVCircle.Size = .(, SilentSettings.FOV*, , SilentSettings.FOV*)
SilentFOVCircle.BackgroundTransparency = 
SilentFOVCircle.BorderSizePixel = 
SilentFOVCircle.Visible = SilentSettings.ShowFOV
SilentFOVCircle.Parent = SilentFOVGui

 stroke = .()
stroke.Parent = SilentFOVCircle
stroke.Color = .(,,)
stroke.Thickness = 

 corner = .()
corner.Parent = SilentFOVCircle
corner.CornerRadius = .(,)


  (worldPos)
     mousePos = UserInputService:()
     screenPos, onScreen = Camera:(worldPos)
      onScreen    
     dist = (.(screenPos.X, screenPos.Y) - .(mousePos.X, mousePos.Y)).Magnitude
     dist <= SilentSettings.FOV


  (part)
     origin = Camera.CFrame.Position
     direction = (part.Position - origin)
     rayParams = RaycastParams.()
    rayParams.FilterDescendantsInstances = {LocalPlayer.Character}
    rayParams.FilterType = .RaycastFilterType.Blacklist
     result = :(origin, direction, rayParams)
      result  result.Instance:(part.Parent)


  (part)
     SilentSettings.PredictionEnabled  part.Parent:() 
         part.Position + part.Parent.HumanoidRootPart.Velocity * SilentSettings.PredictionAmount
    
     part.Position



RunService.RenderStepped:((dt)
      SilentSettings.Enable 
        stroke.Color = .(,,)
        
    

    lastShot = lastShot + dt
     closest = 
     closestDist = SilentSettings.FOV
     screenCenter = .(Camera.ViewportSize.X/, Camera.ViewportSize.Y/)

     _, p  (Players:()) 
         p ~= LocalPlayer  p.Character  p.Character:() 
             hrp = p.Character.HumanoidRootPart
             humanoid = p.Character:()

            
             humanoid  ( SilentSettings.LifeCheck  humanoid.Health > ) 
                 screenPos, onScreen = Camera:(hrp.Position)
                 onScreen 
                     delta = (.(screenPos.X,screenPos.Y)-screenCenter).Magnitude
                     delta <= closestDist  (hrp.Position) 
                         SilentSettings.ShootThroughWalls  ( SilentSettings.ShootThroughWalls  ( SilentSettings.VisibleCheck  (hrp))) 
                            closest = p
                            closestDist = delta
                        
                    
                
            
        
    

     closest 
        stroke.Color = .(,,)
    
        stroke.Color = .(,,)
    


     closest  lastShot >= SilentSettings.Delay  .() <= SilentSettings.HitChance 
         weapon = LocalPlayer.Character  LocalPlayer.Character:()
         event = ReplicatedStorage:():()
         weapon  event 
             hrp = closest.Character.HumanoidRootPart
            event:(weapon, (hrp), ((hrp)-weapon.Handle.Position).Unit)
            lastShot = 
        
    
)


SilentTab:({ Name=, CurrentValue=SilentSettings.Enable, Callback=(v) SilentSettings.Enable=v  })
SilentTab:({ Name=, CurrentValue=SilentSettings.LifeCheck, Callback=(v) SilentSettings.LifeCheck=v  })
SilentTab:({ Name=, CurrentValue=SilentSettings.VisibleCheck, Callback=(v) SilentSettings.VisibleCheck=v  })
SilentTab:({ Name=, CurrentValue=SilentSettings.ShootThroughWalls, Callback=(v) SilentSettings.ShootThroughWalls=v  })
SilentTab:({ Name=, CurrentValue=SilentSettings.ShowFOV, Callback=(v) SilentSettings.ShowFOV=v; SilentFOVCircle.Visible=v  })
SilentTab:({ Name=, Range={,}, Increment=, CurrentValue=SilentSettings.FOV, Callback=(v) 
    SilentSettings.FOV=v
    SilentFOVCircle.Size = .(,v*,,v*) 
 })
SilentTab:({ Name=, Range={,}, Increment=, CurrentValue=SilentSettings.HitChance, Callback=(v) SilentSettings.HitChance=v  })
SilentTab:({ Name=, Range={,}, Increment=, CurrentValue=SilentSettings.Delay, Callback=(v) SilentSettings.Delay=v  })
SilentTab:({ Name=, CurrentValue=SilentSettings.PredictionEnabled, Callback=(v) SilentSettings.PredictionEnabled=v  })
SilentTab:({ Name=, Range={,}, Increment=, CurrentValue=SilentSettings.PredictionAmount, Callback=(v) SilentSettings.PredictionAmount=v  })



 rapidEnabled, rapidValue, noReloadEnabled, noRecoilEnabled, CrosshairSizeEnabled, AimDelayEnabled = ,,,,,
GunTab:({ Name=, CurrentValue=, Callback=(v) rapidEnabled=v  })
GunTab:({ Name=, Range={,}, Increment=, CurrentValue=, Callback=(v) rapidValue=v  })
GunTab:({ Name=, CurrentValue=, Callback=(v) noReloadEnabled=v  })
GunTab:({ Name=, CurrentValue=, Callback=(v) noRecoilEnabled=v  })
GunTab:({ Name=, CurrentValue=, Callback=(v) CrosshairSizeEnabled=v  })
GunTab:({ Name=, CurrentValue=, Callback=(v) AimDelayEnabled=v  })

.(()
     .() 
         char = LocalPlayer.Character
         char 
             tool = char:()
             tool 
                 rapidEnabled  tool:()  tool:(, rapidValue) 
                 noReloadEnabled  tool:()  tool:(,) 
                 noRecoilEnabled  tool:()  tool:(,) 
                 CrosshairSizeEnabled  tool:()  tool:(,) 
                 AimDelayEnabled  tool:()  tool:(,) 
            
        
    
)

 Button = Tab:({
   Name = ,
   Callback = ()
       Module  = LocalPlayer.PlayerScripts.Code.controllers.character.characterStaminaController
       ClassModule = (Module).CharacterStaminaController

      (ClassModule.useStamina, ()
          
      )
   ,
})

 InfinityJumpToggle = Tab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        .InfinityJumpEnabled = Value
    ,
})


UIS.InputBegan:((input, gameProcessed)
      gameProcessed  .InfinityJumpEnabled  input.KeyCode == .KeyCode.Space 
         character = LocalPlayer.Character
         character  character:() 
            character:():(.HumanoidStateType.Jumping)
        
    
)


 GhostToggle = Tab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        .GhostEnabled = Value
         character = LocalPlayer.Character
         character 
             _, part  (character:()) 
                 part:()  part.Name ~=  
                     Value 
                        part.Transparency = 
                         highlight = .()
                        highlight.Name = 
                        highlight.FillTransparency = 
                        highlight.OutlineTransparency = 
                        highlight.OutlineColor = .GhostColor  .(,,)
                        highlight.Parent = part

                         p = .()
                        p.Name = 
                        p.Texture = 
                        p.Rate = 
                        p.Lifetime = NumberRange.(,)
                        p.Size = NumberSequence.()
                        p.Transparency = NumberSequence.({NumberSequenceKeypoint.(,), NumberSequenceKeypoint.(,)})
                        p.Color = ColorSequence.(.GhostColor  .(,,))
                        p.Parent = part
                    
                        part.Transparency = 
                         part:()  part.GhostHighlight:() 
                         part:()  part.GhostParticles:() 
                    
                
            
        
    ,
})


 GhostColorPicker = Tab:({
    Name = ,
    Color = .(,,),
    Callback = (value)
        .GhostColor = value
         char = LocalPlayer.Character
         char 
             _, part  (char:()) 
                 part:() 
                     part:() 
                        part.GhostHighlight.OutlineColor = value
                    
                     part:() 
                        part.GhostParticles.Color = ColorSequence.(value)
                    
                
            
        
    ,
})



 TrailToggle = Tab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        .TrailEnabled = Value
         character = LocalPlayer.Character
         character 
             hrp = character:()
             hrp 
                 Value 
                    
                     attachment0 = .()
                    attachment0.Name = 
                    attachment0.Position = .(, , )
                    attachment0.Parent = hrp

                     attachment1 = .()
                    attachment1.Name = 
                    attachment1.Position = .(, -, )
                    attachment1.Parent = hrp

                    
                     trail = .()
                    trail.Name = 
                    trail.Attachment0 = attachment0
                    trail.Attachment1 = attachment1
                    trail.Color = ColorSequence.(.TrailColor  .(,,))
                    trail.Lifetime = .TrailLifetime  
                    trail.Transparency = NumberSequence.(.TrailTransparency  )
                    trail.MinLength = 
                    trail.LightEmission = 
                    trail.Enabled = 
                    trail.Parent = hrp
                
                    
                     _, obj  (hrp:()) 
                         obj.Name ==   obj.Name ==   obj.Name ==  
                            obj:()
                        
                    
                
            
        
    ,
})

 TrailLifetimeSlider = Tab:({
    Name = ,
    Range = {, },
    Increment = ,
    Suffix = ,
    CurrentValue = .TrailLifetime  ,
    Flag = ,
    Callback = (Value)
        .TrailLifetime = Value
         hrp = LocalPlayer.Character  LocalPlayer.Character:()
         hrp 
             trail = hrp:()
             trail 
                trail.Lifetime = Value
            
        
    ,
})

 TrailTransparencySlider = Tab:({
    Name = ,
    Range = {, },
    Increment = ,
    CurrentValue = .TrailTransparency  ,
    Flag = ,
    Callback = (Value)
        .TrailTransparency = Value
         hrp = LocalPlayer.Character  LocalPlayer.Character:()
         hrp 
             trail = hrp:()
             trail 
                
                trail.Transparency = NumberSequence.(Value)
            
        
    ,
})

 TrailColorPicker = Tab:({
    Name = ,
    Color = .(,,),
    Callback = (value)
        .TrailColor = value
         char = LocalPlayer.Character
         char 
             hrp = char:()
             hrp  hrp:() 
                hrp.GhostTrail.Color = ColorSequence.(value)
            
        
    ,
})


 SpeedSlider = Tab:({
    Name = ,
    Range = {, },
    Increment = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        .Speed = Value
    ,
})

 SpeedToggle = Tab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        .SpeedEnabled = Value
    ,
})



 speedMoveInput = {W=, A=, S=, D=}

UIS.InputBegan:((input)
     input.KeyCode == .KeyCode.W  speedMoveInput.W =  
     input.KeyCode == .KeyCode.A  speedMoveInput.A =  
     input.KeyCode == .KeyCode.S  speedMoveInput.S =  
     input.KeyCode == .KeyCode.D  speedMoveInput.D =  
)

UIS.InputEnded:((input)
     input.KeyCode == .KeyCode.W  speedMoveInput.W =  
     input.KeyCode == .KeyCode.A  speedMoveInput.A =  
     input.KeyCode == .KeyCode.S  speedMoveInput.S =  
     input.KeyCode == .KeyCode.D  speedMoveInput.D =  
)

(()
      
         .SpeedEnabled  LocalPlayer.Character  LocalPlayer.Character:() 
             hrp = LocalPlayer.Character.HumanoidRootPart
             camCFrame = Camera.CFrame
             lookVector = .(camCFrame.LookVector.X, , camCFrame.LookVector.Z).Unit
             rightVector = .(camCFrame.RightVector.X, , camCFrame.RightVector.Z).Unit

             dir = .(,,)
             speedMoveInput.W  dir = dir + lookVector 
             speedMoveInput.S  dir = dir - lookVector 
             speedMoveInput.A  dir = dir - rightVector 
             speedMoveInput.D  dir = dir + rightVector 

             dir.Magnitude >  
                dir = dir.Unit * .Speed * 
                hrp.CFrame = .(hrp.Position + .(dir.X, , dir.Z))
            
        
        .()
    
)




 FlyToggle = Tab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        .FlyEnabled = Value
         character  character:() 
            character.Humanoid.PlatformStand = Value
        
    ,
})

 FlySlider = Tab:({
    Name = ,
    Range = {, },
    Increment = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        .FlySpeed = Value
    ,
})



 flyMoveInput = {W=, A=, S=, D=, Up=, Down=}
UIS.InputBegan:((input)
     input.KeyCode == .KeyCode.W  flyMoveInput.W =  
     input.KeyCode == .KeyCode.A  flyMoveInput.A =  
     input.KeyCode == .KeyCode.S  flyMoveInput.S =  
     input.KeyCode == .KeyCode.D  flyMoveInput.D =  
     input.KeyCode == .KeyCode.Space  flyMoveInput.Up =  
     input.KeyCode == .KeyCode.LeftShift  flyMoveInput.Down =  
)
UIS.InputEnded:((input)
     input.KeyCode == .KeyCode.W  flyMoveInput.W =  
     input.KeyCode == .KeyCode.A  flyMoveInput.A =  
     input.KeyCode == .KeyCode.S  flyMoveInput.S =  
     input.KeyCode == .KeyCode.D  flyMoveInput.D =  
     input.KeyCode == .KeyCode.Space  flyMoveInput.Up =  
     input.KeyCode == .KeyCode.LeftShift  flyMoveInput.Down =  
)

(()
      
         .FlyEnabled  LocalPlayer.Character  LocalPlayer.Character:() 
             hrp = LocalPlayer.Character.HumanoidRootPart
             camCFrame = Camera.CFrame
             dir = .(,,)
             flyMoveInput.W  dir = dir + camCFrame.LookVector 
             flyMoveInput.S  dir = dir - camCFrame.LookVector 
             flyMoveInput.A  dir = dir - camCFrame.RightVector 
             flyMoveInput.D  dir = dir + camCFrame.RightVector 
             flyMoveInput.Up  dir = dir + .(,,) 
             flyMoveInput.Down  dir = dir - .(,,) 

             dir.Magnitude >  
                hrp.CFrame = .(hrp.Position + dir.Unit * (.FlySpeed * ), hrp.Position + camCFrame.LookVector)
            
                hrp.CFrame = .(hrp.Position, hrp.Position + camCFrame.LookVector)
            

            hrp.AssemblyLinearVelocity = .zero
            hrp.AssemblyAngularVelocity = .zero
        
        .()
    
)


.GhostEnabled = 
.GhostColor = .(,,)
.TrailEnabled = 
.TrailLifetime = 
.TrailTransparency = 
.TrailColor = .(,,)
.SpeedEnabled = 
.Speed = 
.FlyEnabled = 
.FlySpeed = 




 Settings = {
    MaxDistance = ,
    NameESP = ,
    DistanceESP = ,
    ItemESP = ,
    LineESP = ,
    HealthbarESP = ,
    SkeletonESP = ,
    TeamESP = ,
    ESPEnabled = 
}

 Colors = {
    Name = .(,,),
    Distance = .(,,),
    Item = .(,,),
    Line = .(,,),
    Healthbar = .(,,),
    Skeleton = .(,,),
    Wanted = .(,,)
}

 TEAM_COLORS = {
    ADAC = .(, , ),
    BusCompany = .(, , ),
    Citizen = .(, , ),
    FireDepartment = .(, , ),
    Police = .(, , ),
    Prisoner = .(, , ),
    TruckCompany = .(, , ),
}


 DrawCache = {}

  ()
     t = .()
    t.Size = 
    t.Center = 
    t.Outline = 
    t.Font = 
    t.Visible = 
     t


  ()
     l = .()
    l.Thickness = 
    l.Visible = 
     l


  (player)
     DrawCache[player]   DrawCache[player] 
     t = {
        NameText = (),
        DistanceText = (),
        ItemText = (),
        Line = (),
        HealthBG = (),
        Health = (),
        Skeleton = {}
    }
    DrawCache[player] = t
     t


  (player)
     t = DrawCache[player]
      t   
     _, v  (t) 
         (v)== 
             _, l  (v)   l  l.Remove  l:()  
         v.Remove 
            v:()
        
    
    DrawCache[player] = 


Players.PlayerRemoving:(cleanupDrawings)

  (player)
     team = player  player.Team
     Settings.TeamESP  team  TEAM_COLORS[team.Name] 
         team.Name, TEAM_COLORS[team.Name]
    
     , Colors.Name


  (p)
    p = .(p,,)
     .(-p,p,)


  (char)
     hum = char:()
      hum   {} 
     hum.RigType == .HumanoidRigType.R15 
         {{,},{,},
                {,},{,},{,},
                {,},{,},{,},
                {,},{,},{,},
                {,},{,},{,}}
    
         {{,},{,},{,},{,},{,}}
    


  (name, flag)
    ESPTab:({
        Name = name,
        CurrentValue = Settings[name:(,)],
        Flag = flag,
        Callback = (v)
            Settings[name:(,)] = v
             name ==    v 
                 _, player  (Players:()) 
                    (player)
                
            
        
    })


 _, name  ({,,,,,,,}) 
    (name, name..)



ESPTab:({
    Name = ,
    Range = {,},
    Increment = ,
    Suffix = ,
    CurrentValue = Settings.MaxDistance,
    Flag = ,
    Callback = (v) Settings.MaxDistance = v 
})


 k,v  (Colors) 
    ColorTab:({
        Name = k..,
        Color = v,
        Flag = ..k,
        Callback = (c) Colors[k] = c 
    })



RunService.RenderStepped:(()
      Settings.ESPEnabled   
     camPos = Camera.CFrame.Position
     _, player  (Players:()) 
         player == LocalPlayer   
         char = player.Character
         hrp = char  char:()
         hum = char  char:()
          hrp   hum  (player)  

         dist = (hrp.Position - camPos).Magnitude
         sPos, onScreen = Camera:(hrp.Position)
         dist > Settings.MaxDistance   onScreen 
            (player)
            
        

         drawings = (player)
         teamLabel, teamColor = (player)


         baseY = sPos.Y - 
         texts = {}
         Settings.NameESP 
             displayName = player.Name
             color = Colors.Name
             teamLabel  displayName = .(, player.Name, teamLabel) color = teamColor 
            .(texts, {drawings.NameText, displayName, color})
        
         Settings.DistanceESP  .(texts, {drawings.DistanceText, ..math.(dist).., Colors.Distance}) 
         Settings.ItemESP 
             tool = char:()
             tool  .(texts, {drawings.ItemText, tool.Name, Colors.Item}) 
        
        drawings.NameText.Visible = 
        drawings.DistanceText.Visible = 
        drawings.ItemText.Visible = 
         i, t  (texts) 
             obj, txt, col = t[], t[], t[]
            obj.Position = .(sPos.X, baseY + (i-)*)
            obj.Text = txt
            obj.Color = col
            obj.Visible = 
        


        drawings.Line.Visible = Settings.LineESP
         Settings.LineESP 
            drawings.Line.From = .(Camera.ViewportSize.X/, Camera.ViewportSize.Y/)
            drawings.Line.To = .(sPos.X, sPos.Y)
            drawings.Line.Color = teamColor  Colors.Line
        

        drawings.Health.Visible = Settings.HealthbarESP
        drawings.HealthBG.Visible = Settings.HealthbarESP
         Settings.HealthbarESP 
             offsetX = 
             topV = .(sPos.X + offsetX, sPos.Y - )
             bottomV = .(sPos.X + offsetX, sPos.Y + )
            drawings.HealthBG.From = topV
            drawings.HealthBG.To = bottomV
            drawings.HealthBG.Color = .(,,)
            drawings.HealthBG.Thickness = 

             hpPct = hum.Health / hum.MaxHealth
            drawings.Health.From = bottomV
            drawings.Health.To = .(bottomV.X, bottomV.Y - ( * hpPct))
            drawings.Health.Color = teamColor  (hpPct)
            drawings.Health.Thickness = 
        


         Settings.SkeletonESP 
             conns = (char)
             #drawings.Skeleton < #conns 
                 i=#drawings.Skeleton+,#conns  .(drawings.Skeleton,()) 
            
             i,pair  (conns) 
                 partA = char:(pair[])
                 partB = char:(pair[])
                 ln = drawings.Skeleton[i]
                 partA  partB 
                     aScr,_ = Camera:(partA.Position)
                     bScr,_ = Camera:(partB.Position)
                    ln.From = .(aScr.X,aScr.Y)
                    ln.To = .(bScr.X,bScr.Y)
                    ln.Color = teamColor  Colors.Skeleton
                    ln.Visible = 
                 ln.Visible= 
            
        
             _, ln  (drawings.Skeleton)   ln  ln.Visible=  
        
    
)