OPEN SOURCE linhmc universal aimbot

 Rayfield = (:())()
 Players = :()
 RunService = :()
 UserInputService = :()
 Camera = .CurrentCamera
 LocalPlayer = Players.LocalPlayer
 math_sin = .sin
 math_huge = .huge
  = 
 Vector2_new = .new
 Vector3_new = .new
 Color3_fromRGB = .fromRGB
 hitboxSize = 
 hitboxEnabled = 
 teamCheck = 
 ogSIZES = {}
 hbCON = {}
 infoToggleEnabled = 
 ignoreThroughParts = 
 FOV_RGB_Enabled = 
 FOV_RGB_Speed = 

 pressedKeys = {}
UserInputService.InputBegan:((input, gp)
      gp  input.UserInputType == .UserInputType.Keyboard 
        pressedKeys[input.KeyCode.Name] = 
    
)
UserInputService.InputEnded:((input, gp)
      gp  input.UserInputType == .UserInputType.Keyboard 
        pressedKeys[input.KeyCode.Name] = 
    
)

 ESP_Name_Enabled = 

 AimAssistSettings = {
    Enabled = ,
    AimPart = ,
    FOV = ,
    Sensitivity = ,
    WallCheck = ,
    TeamCheck = ,
    OutfitCheck = ,
    ESP_Enabled = ,
    ESP_LineMode = ,
    ESP_Skeleton = ,
    ESP_RGB_NoTeam = , 
    BulletPrediction = ,
    SkipDeadPlayers = ,
    SmoothAiming = ,
    ESP_Box = ,
    ESP_AimPart = ,
    ESP_SkipTeam = 
}

 Circle = .()
Circle.Color = (, , )
Circle.Thickness = 
Circle.Filled = 
Circle.Radius = AimAssistSettings.FOV
Circle.Position = (Camera.ViewportSize.X / , Camera.ViewportSize.Y / )
Circle.Visible = 

 InfoText = .()
InfoText.Visible = 
InfoText.Color = (,,)
InfoText.Size = 
InfoText.Outline = 
InfoText.Center = 
InfoText.Font = 

 ESP_Lines = {}
 ESP_Skeletons = {}
 ESP_Pool = {lines = {}, skeletons = {}, names = {}}
 ESP_Boxes = {}
 ESP_PartMarkers = {}
 ESP_BoxPool = {}
 ESP_PartMarkerPool = {}
 ESP_NameTexts = {}
 ESP_NamePool = {}
 screenCenter = (, )
 lastScreenUpdate = 
 SCREEN_UPDATE_INTERVAL = /
 lastRGBTime = 
 cachedRGBColor = (, , )
 RGB_UPDATE_INTERVAL = /

 FOV_RGB_Tick = 

  (speed)
     currentTime = ()
     time = currentTime * (speed  )
     r = (time) *  + 
     g = (time + ) *  + 
     b = (time + ) *  + 
     (r, g, b)


 outfitCache = {}
 outfitCacheTime = {}
 OUTFIT_CACHE_DURATION = 
  (player)
      player   player.Character 
         
    
     currentTime = ()
     playerId = player.UserId
     outfitCache[playerId]  outfitCacheTime[playerId]  
       (currentTime - outfitCacheTime[playerId]) < OUTFIT_CACHE_DURATION 
         outfitCache[playerId]
    
     outfitData = {}
     shirt = player.Character:()
     pants = player.Character:()
    outfitData.shirt = shirt  shirt.ShirtTemplate  
    outfitData.pants = pants  pants.PantsTemplate  
    outfitCache[playerId] = outfitData
    outfitCacheTime[playerId] = currentTime
     outfitData

  (outfit1, outfit2)
      outfit1   outfit2 
         
    
     outfit1.shirt ~=   outfit1.pants ~=   
           outfit1.shirt == outfit2.shirt  outfit1.pants == outfit2.pants


 hasTeamSystem = 
 lastTeamCheck = 
 TEAM_CHECK_INTERVAL = 
  ()
     currentTime = ()
     hasTeamSystem ==   (currentTime - lastTeamCheck) >= TEAM_CHECK_INTERVAL 
        lastTeamCheck = currentTime
        hasTeamSystem = 
         _, player  (Players:()) 
             player.Team ~=  
                hasTeamSystem = 
                
            
        
    
     hasTeamSystem

  (player)
      AimAssistSettings.OutfitCheck 
         
    
     localOutfit = (LocalPlayer)
     targetOutfit = (player)
     (localOutfit, targetOutfit)

  (player)
      player   player.Character 
         
    
     humanoid = player.Character:()
     humanoid  humanoid.Health > 

 (part, origin)
     direction = (part.Position - origin)
     distance = direction.Magnitude
     distance <     
     rayParams = RaycastParams.()
    rayParams.FilterType = .RaycastFilterType.Blacklist
     filterList = {LocalPlayer.Character, Camera}
    rayParams.FilterDescendantsInstances = filterList
    rayParams.IgnoreWater = 
     rayDirection = direction.Unit * (distance - )
     result = :(origin, rayDirection, rayParams)
      result 
         
    
     hitPart = result.Instance
     hitPart  hitPart.Parent 
         _, plr  (Players:()) 
             plr.Team  LocalPlayer.Team  plr.Team == LocalPlayer.Team  plr.Character  hitPart:(plr.Character) 
                 
            
        
         ignoreThroughParts  (
            hitPart.CanCollide ==  
            hitPart.Transparency >  
            (hitPart.Name ==   hitPart.Name ==   hitPart.Name ==   hitPart.Name == )
        ) 
             newOrigin = result.Position + direction.Unit * 
             newDirection = (part.Position - newOrigin)
             newDirection.Magnitude >  
                 (part, newOrigin)
            
        
         hitPart:(part.Parent)  hitPart.Parent == part.Parent
    
     

  (part)
     (part, Camera.CFrame.Position)

  (character)
     parts = {, , , , }
     nearestPart, nearestDistance = , math_huge
     _, partName  (parts) 
         part = character:(partName)
         part 
             screenPoint, onScreen = Camera:(part.Position)
             onScreen  screenPoint.Z >  
                 dist = ((screenPoint.X, screenPoint.Y) - screenCenter).Magnitude
                 dist < nearestDistance 
                    nearestDistance = dist
                    nearestPart = part
                
            
        
    
     nearestPart

  ()
     closestPlayer, closestDistance = , math_huge
     hasTeam = ()
     _, player  (Players:()) 
         player ~= LocalPlayer  player.Character  player.Character:() 
             AimAssistSettings.SkipDeadPlayers   (player) 
                
            
             AimAssistSettings.TeamCheck  hasTeam  player.Team == LocalPlayer.Team 
                
            
             (player) 
                
            
             dist = (player.Character.HumanoidRootPart.Position - Camera.CFrame.Position).Magnitude
             dist < closestDistance 
                closestDistance = dist
                closestPlayer = player
            
        
    
     closestPlayer

  ()
     closestPlayer, closestDistance = , math_huge
     hasTeam = ()
     _, player  (Players:()) 
         player ~= LocalPlayer  player.Character 
             AimAssistSettings.SkipDeadPlayers   (player) 
                
            
             AimAssistSettings.TeamCheck  hasTeam  player.Team == LocalPlayer.Team  
                 
            
             (player) 
                
            
             targetPart
             AimAssistSettings.AimPart ==  
                targetPart = (player.Character)
            
                targetPart = player.Character:(AimAssistSettings.AimPart)
                  targetPart 
                     fallbackMap = {
                        [] = {, , },
                        [] = {, },
                        [] = {, },
                        [] = {},
                        [] = {}
                    }
                     fallbacks = fallbackMap[AimAssistSettings.AimPart]  {AimAssistSettings.AimPart}
                     _, fallback  (fallbacks) 
                        targetPart = player.Character:(fallback)
                         targetPart   
                    
                      targetPart 
                         lastResort = {, , , }
                         _, fallback  (lastResort) 
                            targetPart = player.Character:(fallback)
                             targetPart   
                        
                    
                
            
             targetPart 
                 AimAssistSettings.WallCheck   (targetPart)  
                     
                
                 screenPoint, onScreen = Camera:(targetPart.Position)
                 onScreen  screenPoint.Z >  
                     dist = ((screenPoint.X, screenPoint.Y) - screenCenter).Magnitude
                     dist < AimAssistSettings.FOV  dist < closestDistance 
                        closestDistance = dist
                        closestPlayer = player
                    
                
            
        
    
     closestPlayer

  (player)
      player   player.Character    
     AimAssistSettings.AimPart ==  
         (player.Character)
    
         part = player.Character:(AimAssistSettings.AimPart)
         part 
             part
        
         fallbackMap = {
            [] = {, , },
            [] = {, },
            [] = {, },
            [] = {},
            [] = {}
        }
         fallbacks = fallbackMap[AimAssistSettings.AimPart]  {AimAssistSettings.AimPart}
         _, fallback  (fallbacks) 
            part = player.Character:(fallback)
             part 
                 part
            
        
         lastResort = {, , , }
         _, fallback  (lastResort) 
            part = player.Character:(fallback)
             part 
                 part
            
        
    
     

  (plr)
     plr == LocalPlayer   hitboxEnabled   
     teamCheck  plr.Team ~=   LocalPlayer.Team ~=   plr.Team == LocalPlayer.Team   
      ()
         char = plr.Character
         humanoid = char  char:()
         root = char  char:()
         humanoid  humanoid.Health >   root 
              ogSIZES[plr] 
                ogSIZES[plr] = root.Size
            
            root.Size = (hitboxSize, hitboxSize, hitboxSize)
            root.Transparency = 
            root.BrickColor = BrickColor.()
            root.Material = .Material.Neon
            root.CanCollide = 
        
    
    ()
     hbCON[plr]  hbCON[plr]:() 
    hbCON[plr] = RunService.Heartbeat:(()
         char = plr.Character
         humanoid = char  char:()
         root = char  char:()
         humanoid  humanoid.Health >   root 
            root.Size = (hitboxSize, hitboxSize, hitboxSize)
            root.Transparency = 
            root.BrickColor = BrickColor.()
            root.Material = .Material.Neon
            root.CanCollide = 
        
    )

  (plr)
     hbCON[plr] 
        hbCON[plr]:()
        hbCON[plr] = 
    
     char = plr.Character
     root = char  char:()
     root  ogSIZES[plr] 
        root.Size = ogSIZES[plr]
        root.Transparency = 
        root.BrickColor = BrickColor.()
        root.Material = .Material.Neon
        root.CanCollide = 
    
    ogSIZES[plr] = 

  (player)
     AimAssistSettings.ESP_RGB_NoTeam  ( player.Team  player.Team == ) 
         ()
    
     player.Team  player.TeamColor 
         player.TeamColor.Color
    
         (, , )
    

  ()
     line = .(ESP_Pool.lines)
     line 
        line.Visible = 
         line
    
         newLine = .()
        newLine.Visible = 
         newLine
    

  (line)
     line 
        line.Visible = 
        .(ESP_Pool.lines, line)
    

  (skeleton)
     skeleton 
         _, line  (skeleton) 
            (line)
        
    

  ()
     box = .(ESP_BoxPool)
     box 
        box.Visible = 
         box
    
         newBox = .()
        newBox.Visible = 
        newBox.Thickness = 
        newBox.Transparency = 
         newBox
    

  (box)
     box 
        box.Visible = 
        .(ESP_BoxPool, box)
    

  ()
     circle = .(ESP_PartMarkerPool)
     circle 
        circle.Visible = 
         circle
    
         newCircle = .()
        newCircle.Visible = 
        newCircle.Radius = 
        newCircle.Thickness = 
        newCircle.Filled = 
         newCircle
    

  (circle)
     circle 
        circle.Visible = 
        .(ESP_PartMarkerPool, circle)
    


  ()
     t = .(ESP_NamePool)
     t 
        t.Visible = 
         t
    
         text = .()
        text.Visible = 
        text.Size = 
        text.Outline = 
        text.Center = 
        text.Font = 
        text.Color = (,,)
         text
    

  (t)
     t 
        t.Visible = 
        .(ESP_NamePool, t)
    


 lastFrameTime = 
 FRAME_LIMIT = /
 lastESPUpdate = 
 ESP_UPDATE_INTERVAL = /
  ()
     currentTime = ()
     currentTime - lastESPUpdate < ESP_UPDATE_INTERVAL   
    lastESPUpdate = currentTime
     _, line  (ESP_Lines)  (line) 
    ESP_Lines = {}
     _, skeleton  (ESP_Skeletons)  (skeleton) 
    ESP_Skeletons = {}
     _, box  (ESP_Boxes)  (box) 
    ESP_Boxes = {}
     _, circ  (ESP_PartMarkers)  (circ) 
    ESP_PartMarkers = {}
     _, t  (ESP_NameTexts)  (t) 
    ESP_NameTexts = {}
     hasTeam = ()
     _, player  (Players:()) 
         player ~= LocalPlayer  player.Character  player.Character:() 
             AimAssistSettings.SkipDeadPlayers   (player)   
             AimAssistSettings.ESP_SkipTeam  hasTeam  player.Team == LocalPlayer.Team   
             humanoidRootPart = player.Character.HumanoidRootPart
             pos, onScreen = Camera:(humanoidRootPart.Position)
             onScreen  pos.Z >  
                 color = (player)
                 AimAssistSettings.ESP_Enabled 
                     line = ()
                     fromY = AimAssistSettings.ESP_LineMode ==     Camera.ViewportSize.Y
                    line.From = (Camera.ViewportSize.X / , fromY)
                    line.To = (pos.X, pos.Y)
                    line.Thickness = 
                    line.Transparency = 
                    line.Color = color
                    .(ESP_Lines, line)
                
                 AimAssistSettings.ESP_Skeleton 
                     skeleton = {}
                     character = player.Character
                     skeletonColor = color
                      (partA, partB)
                         p1, v1 = character:(partA), character:(partB)
                         p1  v1 
                             pos1, os1 = Camera:(p1.Position)
                             pos2, os2 = Camera:(v1.Position)
                             os1  os2  pos1.Z >   pos2.Z >  
                                 line = ()
                                line.From = (pos1.X, pos1.Y)
                                line.To = (pos2.X, pos2.Y)
                                line.Color = skeletonColor
                                line.Thickness = 
                                line.Transparency = 
                                .(skeleton, line)
                            
                        
                    
                     character:() 
                        (, )
                        (, )
                        (, )
                        (, )
                        (, )
                        (, )
                        (, )
                        (, )
                        (, )
                        (, )
                        (, )
                        (, )
                        (, )
                        (, )
                    
                        (, )
                        (, )
                        (, )
                        (, )
                        (, )
                    
                    .(ESP_Skeletons, skeleton)
                
                 AimAssistSettings.ESP_Box 
                     min, max = .(.huge, .huge, .huge), .(-.huge, -.huge, -.huge)
                     _, part  (player.Character:()) 
                         part:() 
                            min = .(
                                .(min.X, part.Position.X - part.Size.X/),
                                .(min.Y, part.Position.Y - part.Size.Y/),
                                .(min.Z, part.Position.Z - part.Size.Z/)
                            )
                            max = .(
                                .(max.X, part.Position.X + part.Size.X/),
                                .(max.Y, part.Position.Y + part.Size.Y/),
                                .(max.Z, part.Position.Z + part.Size.Z/)
                            )
                        
                    
                     corners = {
                        .(min.X, min.Y, min.Z),
                        .(max.X, min.Y, min.Z),
                        .(max.X, max.Y, min.Z),
                        .(min.X, max.Y, min.Z),
                        .(min.X, min.Y, max.Z),
                        .(max.X, min.Y, max.Z),
                        .(max.X, max.Y, max.Z),
                        .(min.X, max.Y, max.Z),
                    }
                     screenPoints = {}
                     anyVisible = 
                     _, v  (corners) 
                         p, vis = Camera:(v)
                         vis  p.Z >  
                            anyVisible = 
                        
                        .(screenPoints, (p.X, p.Y))
                    
                     anyVisible 
                         minX, minY, maxX, maxY = .huge, .huge, -.huge, -.huge
                         _, v  (screenPoints) 
                            minX = .(minX, v.X)
                            minY = .(minY, v.Y)
                            maxX = .(maxX, v.X)
                            maxY = .(maxY, v.Y)
                        
                         box = ()
                        box.Color = color
                        box.PointA = (minX, minY)
                        box.PointB = (maxX, minY)
                        box.PointC = (maxX, maxY)
                        box.PointD = (minX, maxY)
                        .(ESP_Boxes, box)
                    
                
                 ESP_Name_Enabled 
                     nameText = ()
                    nameText.Text = player.DisplayName  player.Name
                    nameText.Color = color
                    nameText.Size = 
                     head = player.Character:()
                     head 
                         headPos, headOnScreen = Camera:(head.Position + (, , ))
                         headOnScreen  headPos.Z >  
                            nameText.Position = (headPos.X, headPos.Y - )
                        
                            nameText.Visible = 
                        
                    
                        nameText.Position = (pos.X, pos.Y - )
                    
                    nameText.Visible = 
                    .(ESP_NameTexts, nameText)
                
            
        
    
     AimAssistSettings.ESP_AimPart  AimAssistSettings.Enabled 
         target = ()
         target 
             part = (target)
             part 
                 p, vis = Camera:(part.Position)
                 vis  p.Z >  
                     circ = ()
                    circ.Position = (p.X, p.Y)
                    circ.Color = (, , )
                    circ.Visible = 
                    .(ESP_PartMarkers, circ)
                
            
        
    

 lastTarget = 
 targetLockTime = 
 LOCK_DURATION = 
RunService.RenderStepped:(()
     currentTime = ()
     currentTime - lastFrameTime < FRAME_LIMIT   
    lastFrameTime = currentTime
     currentTime - lastScreenUpdate >= SCREEN_UPDATE_INTERVAL 
        screenCenter = (Camera.ViewportSize.X / , Camera.ViewportSize.Y / )
        lastScreenUpdate = currentTime
    

     FOV_RGB_Enabled 
        Circle.Color = (FOV_RGB_Speed)
    

    Circle.Radius = AimAssistSettings.FOV
    Circle.Position = screenCenter
    Circle.Visible = AimAssistSettings.Enabled

     currentTarget = 
     AimAssistSettings.Enabled 
         target = ()
         target  target == lastTarget 
            targetLockTime = currentTime
         target   lastTarget 
            lastTarget = target
            targetLockTime = currentTime
          target  lastTarget  (currentTime - targetLockTime) < LOCK_DURATION 
            target = lastTarget
        
            lastTarget = target
            targetLockTime = currentTime
        
         target 
             targetPart = (target)
             targetPart 
                 isValid = 
                 AimAssistSettings.SkipDeadPlayers   (target) 
                    isValid = 
                
                 AimAssistSettings.TeamCheck  ()  target.Team == LocalPlayer.Team 
                    isValid = 
                
                 (target) 
                    isValid = 
                
                 AimAssistSettings.WallCheck   (targetPart) 
                    isValid = 
                
                 screenPoint, onScreen = Camera:(targetPart.Position)
                 onScreen  screenPoint.Z >  
                     dist = ((screenPoint.X, screenPoint.Y) - screenCenter).Magnitude
                     dist > AimAssistSettings.FOV 
                        isValid = 
                    
                
                    isValid = 
                
                 isValid 
                     aimPos = targetPart.Position
                     AimAssistSettings.BulletPrediction  target.Character  target.Character:() 
                         targetVelocity = target.Character.HumanoidRootPart.Velocity
                         distance = (aimPos - Camera.CFrame.Position).Magnitude
                         timeToTarget = distance / 
                        aimPos = aimPos + (targetVelocity * timeToTarget * )
                    
                     dir = (aimPos - Camera.CFrame.Position).Unit
                     goal = .(Camera.CFrame.Position, Camera.CFrame.Position + dir)
                     smoothness = AimAssistSettings.Sensitivity
                     LocalPlayer.Character  LocalPlayer.Character:() 
                         moveVector = LocalPlayer.Character.Humanoid.MoveDirection
                         moveVector.Magnitude >  
                            smoothness = smoothness * 
                        
                    
                     AimAssistSettings.SmoothAiming 
                        Camera.CFrame = Camera.CFrame:(goal, smoothness)
                    
                        Camera.CFrame = goal
                    
                    currentTarget = target
                
                    lastTarget = 
                
            
        
            lastTarget = 
        
    
        lastTarget = 
    
     infoToggleEnabled 
        InfoText.Visible = 
         str = 
         closest = ()
         closestName = 
         closest 
             dn = closest.DisplayName  closest.Name
             un = closest.Name
            closestName = dn ..  .. un .. 
        
         isStunned = 
         closest  closest.Character 
             stunVal = closest.Character:()
             stunVal  stunVal:() 
                isStunned = stunVal.Value
             closest.Character:()  closest.Character.Humanoid:() 
                 stunH = closest.Character.Humanoid.Stunned
                 (stunH) ==  
                    isStunned = stunH
                 (stunH) ==  
                    isStunned = stunH > 
                 (stunH) ==   stunH:() 
                    isStunned = stunH.Value
                
            
        
         stunText = isStunned    
         myTeam = (LocalPlayer.Team  LocalPlayer.Team.Name)  
         aimTargetName = lastTarget  (lastTarget.DisplayName  lastTarget.Name)  
         aimAssistState = AimAssistSettings.Enabled    
         aimingPart = lastTarget  (lastTarget)  (lastTarget).Name  
        str = str .. ():(
            aimAssistState, myTeam, closestName, stunText, aimTargetName, aimingPart
        )
         keysText = 
         k  (pressedKeys) 
            keysText = keysText .. k .. 
        
         keysText ==   keysText =  
        str = str .. ():(keysText)
        InfoText.Text = str
        InfoText.Position = (, )
    
        InfoText.Visible = 
    
)
RunService.RenderStepped:(UpdateESP)
 Window = Rayfield:({
    Name = ,
    LoadingTitle = ,
    LoadingSubtitle = ,
    ConfigurationSaving = {Enabled = }
})
 AimAssistTab = Window:(, )
 HitboxTab = Window:(, )
 VisualTab = Window:(, )
 SettingsTab = Window:(, )
AimAssistTab:({
    Name = ,
    CurrentValue = ,
    Callback = (state)
        infoToggleEnabled = state
    
})
HitboxTab:({
    Name = ,
    Range = {, },
    Increment = ,
    Suffix = ,
    CurrentValue = ,
    Callback = (value)
        hitboxSize = value
    
})
HitboxTab:({
    Name = ,
    CurrentValue = ,
    Callback = (state)
        hitboxEnabled = state
         _, plr  (Players:()) 
             state 
                (plr)
            
                (plr)
            
        
    
})
HitboxTab:({
    Name = ,
    CurrentValue = ,
    Callback = (state)
        teamCheck = state
         hitboxEnabled 
             _, plr  (Players:()) 
                (plr)
                (plr)
            
        
    
})
AimAssistTab:({
    Name = , 
    CurrentValue = , 
    Callback = (value) 
        AimAssistSettings.Enabled = value 
    
})
AimAssistTab:({
    Name = , 
    Options = {, , , , , }, 
    CurrentOption = ,
    Callback = (value) 
         (value) ==  
            value = value[]
        
         value ==   value =  
         value ==   value =  
        AimAssistSettings.AimPart = value 
    
})
AimAssistTab:({
    Name = , 
    Range = {, }, 
    Increment = , 
    CurrentValue = ,
    Callback = (value) 
        AimAssistSettings.FOV = value 
    
})
AimAssistTab:({
    Name = , 
    Range = {, }, 
    Increment = , 
    CurrentValue = ,
    Callback = (value) 
        AimAssistSettings.Sensitivity = value 
    
})
AimAssistTab:({
    Name = , 
    CurrentValue = ,
    Callback = (value) 
        AimAssistSettings.BulletPrediction = value 
    
})
AimAssistTab:({
    Name = , 
    CurrentValue = ,
    Callback = (value) 
        AimAssistSettings.SmoothAiming = value 
    
})
AimAssistTab:({
    Name = , 
    Color = (,,),
    Callback = (color) 
          FOV_RGB_Enabled 
            Circle.Color = color 
        
    
})
AimAssistTab:({
    Name = ,
    CurrentValue = ,
    Callback = (state)
        FOV_RGB_Enabled = state
    
})
AimAssistTab:({
    Name = ,
    Range = {, },
    Increment = ,
    CurrentValue = ,
    Callback = (val)
        FOV_RGB_Speed = val
    
})
 Paragraph = VisualTab:({
   Title = ,
   Content = 
})

VisualTab:({
    Name = , 
    CurrentValue = , 
    Callback = (value) 
        AimAssistSettings.ESP_Enabled = value 
    
})
VisualTab:({
    Name = , 
    CurrentValue = ,
    Callback = (value) 
        AimAssistSettings.ESP_Skeleton = value 
    
})
VisualTab:({
    Name = , 
    CurrentValue = , 
    Callback = (value) 
        AimAssistSettings.ESP_RGB_NoTeam = value 
    
})
VisualTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        AimAssistSettings.ESP_Box = value
    
})
VisualTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        AimAssistSettings.ESP_AimPart = value
    
})
VisualTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        ESP_Name_Enabled = value
    
})
VisualTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        AimAssistSettings.ESP_SkipTeam = value
    
})
SettingsTab:({
    Name = , 
    CurrentValue = ,
    Callback = (value) 
        AimAssistSettings.WallCheck = value 
    
})
SettingsTab:({
    Name = , 
    CurrentValue = , 
    Callback = (value) 
        AimAssistSettings.TeamCheck = value 
    
})
SettingsTab:({
    Name = , 
    CurrentValue = , 
    Callback = (value) 
        AimAssistSettings.OutfitCheck = value 
    
})
SettingsTab:({
    Name = , 
    CurrentValue = , 
    Callback = (value) 
        AimAssistSettings.SkipDeadPlayers = value 
    
})
SettingsTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        ignoreThroughParts = value
    
})
Players.PlayerAdded:((plr)
    plr.CharacterAdded:(()
        .()
         hitboxEnabled 
            (plr)
        
    )
)
 _, plr  (Players:()) 
     plr ~= LocalPlayer 
        plr.CharacterAdded:(()
            .()
             hitboxEnabled 
                (plr)
            
        )
    

Rayfield:({
    Title = ,
    Content = ,
    Duration = ,
    Image = 
})