Salz Hub

 .KD_ESP_UNLOAD  (.KD_ESP_UNLOAD) 

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

 Settings = {
    
    ESPEnabled = ,
    BoxESP = ,
    SkeletonESP = ,
    TracerESP = ,
    MaxDistance = ,
    BoxColor = .(, , ),
    SkeletonColor = .(, , ),
    TracerColor = .(, , ),
    TextColor = .(, , ),
    TextSize = ,
    TracerFrom = ,

    
    AimEnabled = ,
    AimKey = .KeyCode.E,
    AimFOV = ,
    AimSmooth = ,
    AimPart = ,
    TeamCheck = ,
    ShowFOV = ,
    FOVColor = .(, , ),
    Prediction = ,
}

 espObjects = {}
 connections = {}


 announceGui = .()
announceGui.Name = 
announceGui.ResetOnSpawn = 
announceGui.IgnoreGuiInset = 
announceGui.Parent = PlayerGui

 announce = .()
announce.Size = .(, , , )
announce.Position = .(, , , )
announce.BackgroundColor3 = .(, , )
announce.BackgroundTransparency = 
announce.BorderSizePixel = 
announce.Text = 
announce.TextColor3 = .(, , )
announce.TextSize = 
announce.Font = .Font.GothamBold
announce.Parent = announceGui

 ac = .()
ac.CornerRadius = .(, )
ac.Parent = announce

 stroke = .()
stroke.Color = .(, , )
stroke.Thickness = 
stroke.Transparency = 
stroke.Parent = announce


.(()
    .()
     i = , ,  
        announce.TextTransparency = i
        announce.BackgroundTransparency =  + (i * )
        stroke.Transparency =  + (i * )
        .()
    
    announce.Visible = 
)

 fovCircle = .()
fovCircle.Thickness = 
fovCircle.NumSides = 
fovCircle.Filled = 
fovCircle.Color = Settings.FOVColor
fovCircle.Visible = 
fovCircle.ZIndex = 
fovCircle.Radius = Settings.AimFOV

  (class, props)
     d = .(class)
     k, v  (props)  d[k] = v 
     d


 skeletonOffsets = {
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
}

 skeletonOffsetsR6 = {
    {, },
    {, },
    {, },
    {, },
    {, },
}

  (player)
     player == LocalPlayer  espObjects[player]   

     lines = {}
     i = ,  
        lines[i] = (, {
            Thickness = ,
            Color = Settings.SkeletonColor,
            Visible = ,
            ZIndex = ,
        })
    

    espObjects[player] = {
        box = (, {
            Thickness = , Filled = , Color = Settings.BoxColor,
            Visible = , ZIndex = ,
        }),
        name = (, {
            Size = Settings.TextSize, Center = , Outline = ,
            Color = Settings.TextColor, Visible = , ZIndex = ,
        }),
        tracer = (, {
            Thickness = , Color = Settings.TracerColor,
            Visible = , ZIndex = ,
        }),
        skeleton = lines,
    }


  (player)
     o = espObjects[player]
      o   
    (() o.box:() )
    (() o.name:() )
    (() o.tracer:() )
     _, l  (o.skeleton)  (() l:() ) 
    espObjects[player] = 


  (o)
    o.box.Visible = 
    o.name.Visible = 
    o.tracer.Visible = 
     _, l  (o.skeleton)  l.Visible =  


  ()
     closest = 
     shortest = Settings.AimFOV
     myChar = LocalPlayer.Character
     myRoot = myChar  myChar:()
      myRoot    

     _, player  (Players:()) 
         player ~= LocalPlayer  player.Character 
             Settings.TeamCheck  player.Team  LocalPlayer.Team  player.Team == LocalPlayer.Team 
                
            
             char = player.Character
             part = char:(Settings.AimPart)
             hum = char:()
             part  hum  hum.Health >  
                 pos, onScreen = Camera:(part.Position)
                 onScreen  pos.Z >  
                     dist2d = (.(mouse.X, mouse.Y) - .(pos.X, pos.Y)).Magnitude
                     dist3d = (myRoot.Position - part.Position).Magnitude
                     dist2d < shortest  dist3d <= Settings.MaxDistance 
                        shortest = dist2d
                        closest = part
                    
                
            
        
    
     closest


  (char, lines)
     isR15 = char:()
     offsets = isR15  skeletonOffsets  skeletonOffsetsR6
     i, pair  (offsets) 
         a = char:(pair[])
         b = char:(pair[])
         line = lines[i]
         a  b  line 
             p1, on1 = Camera:(a.Position)
             p2, on2 = Camera:(b.Position)
             on1  on2 
                line.From = .(p1.X, p1.Y)
                line.To = .(p2.X, p2.Y)
                line.Color = Settings.SkeletonColor
                line.Visible = 
            
                line.Visible = 
            
         line 
            line.Visible = 
        
    
     i = #offsets + , #lines 
        lines[i].Visible = 
    


 aiming = 

  ()
     myChar = LocalPlayer.Character
     myRoot = myChar  myChar:()

    fovCircle.Position = .(mouse.X, mouse.Y + )
    fovCircle.Radius = Settings.AimFOV
    fovCircle.Visible = Settings.ShowFOV  Settings.AimEnabled

     Settings.AimEnabled  aiming 
         target = ()
         target 
             velocity = target.AssemblyLinearVelocity  .zero
             predicted = target.Position + (velocity * Settings.Prediction)
             current = Camera.CFrame
             goal = .(current.Position, predicted)
            Camera.CFrame = current:(goal, Settings.AimSmooth)
        
    

     player, o  (espObjects) 
         char = player.Character
         head = char  char:()
         root = char  char:()
         hum = char  char:()

         Settings.ESPEnabled  head  root  hum  hum.Health >   myRoot 
             dist = (myRoot.Position - root.Position).Magnitude
             dist <= Settings.MaxDistance 
                 headPos, onScreen = Camera:(head.Position + .(, , ))
                 footPos = Camera:(root.Position - .(, , ))
                 rootPos = Camera:(root.Position)

                 onScreen 
                     Settings.BoxESP 
                         height = .(footPos.Y - headPos.Y)
                         width = height * 
                        o.box.Position = .(headPos.X - width/, headPos.Y)
                        o.box.Size = .(width, height)
                        o.box.Visible = 
                    
                        o.box.Visible = 
                    

                    o.name.Text = .(, player.DisplayName, .(dist))
                    o.name.Position = .(headPos.X, headPos.Y - )
                    o.name.Visible = 

                     Settings.TracerESP 
                         from
                         Settings.TracerFrom ==  
                            from = .(Camera.ViewportSize.X/, Camera.ViewportSize.Y/)
                         Settings.TracerFrom ==  
                            from = .(mouse.X, mouse.Y + )
                        
                            from = .(Camera.ViewportSize.X/, Camera.ViewportSize.Y)
                        
                        o.tracer.From = from
                        o.tracer.To = .(rootPos.X, rootPos.Y)
                        o.tracer.Color = Settings.TracerColor
                        o.tracer.Visible = 
                    
                        o.tracer.Visible = 
                    

                     Settings.SkeletonESP 
                        (char, o.skeleton)
                    
                         _, l  (o.skeleton)  l.Visible =  
                    
                
                    (o)
                
            
                (o)
            
        
            (o)
        
    


.(connections, UserInputService.InputBegan:((input, gpe)
     gpe   
     input.KeyCode == Settings.AimKey 
        aiming = 
    
))

.(connections, UserInputService.InputEnded:((input)
     input.KeyCode == Settings.AimKey 
        aiming = 
    
))

 _, p  (Players:())  (p) 
.(connections, Players.PlayerAdded:(createObjects))
.(connections, Players.PlayerRemoving:(removeObjects))
.(connections, RunService.RenderStepped:(update))

.KD_ESP_UNLOAD = ()
     _, c  (connections)  c:() 
     player  (espObjects)  (player) 
    (() fovCircle:() )
    (() announceGui:() )
    .KD_ESP_UNLOAD = 


()