KeylessUniversal
Universal npc detection

dpz3 8 months ago 1.4K views 2
Run it
Copy the script and paste it into your executor.
Universal npc detection.lua · 1,581 lines
().crosshair = {
    enabled = ,
    refreshrate = ,
    mode = ,
    position = .(, ),

    width = ,
    length = ,
    radius = ,
    color = .(, , ),

    spin = ,
    spin_speed = ,
    spin_max = ,
    spin_style = .EasingStyle.Sine,

    resize = ,
    resize_speed = ,
    resize_min = ,
    resize_max = ,
}

 old; old = (.new, (class, properties)
     drawing = (class)
     i, v  , properties  {} 
        drawing[i] = v
    
     drawing
)

 runservice = :()
 inputservice = :()
 tweenservice = :()
 camera = .CurrentCamera

 last_render = 

 drawings = {
    crosshair = {},
    text = {.(, {Size = , Font = , Outline = , Text = , Color = .(, , )}),
            .(, {Size = , Font = , Outline = , Text = }),},
}

 idx = ,  
    drawings.crosshair[idx] = .()


 (angle, radius)
     .(
        .(.(angle)) * radius,
        .(.(angle)) * radius
    )


runservice.PostSimulation:(()

     _tick = ()

     _tick - last_render > crosshair.refreshrate 
        last_render = _tick

         position = (
            crosshair.mode ==   camera.ViewportSize /  
            crosshair.mode ==   inputservice:() 
            crosshair.position
        )

         text_x = drawings.text[].TextBounds.X + drawings.text[].TextBounds.X

        drawings.text[].Visible = crosshair.enabled
        drawings.text[].Visible = crosshair.enabled

         crosshair.enabled 
            drawings.text[].Position = position + .(-text_x / , crosshair.radius + (crosshair.resize  crosshair.resize_max  crosshair.length) + )
            drawings.text[].Position = drawings.text[].Position + .(drawings.text[].TextBounds.X)
            drawings.text[].Color = crosshair.color
            
             idx = ,  
                 outline = drawings.crosshair[idx]
                 inline = drawings.crosshair[idx + ]
    
                 angle = (idx - ) * 
                 length = crosshair.length
    
                 crosshair.spin 
                     spin_angle = -_tick * crosshair.spin_speed % crosshair.spin_max
                    angle = angle + tweenservice:(spin_angle / , crosshair.spin_style, .EasingDirection.InOut) * 
                
    
                 crosshair.resize 
                     resize_length = () * crosshair.resize_speed % 
                    length = crosshair.resize_min + .(.(resize_length)) * crosshair.resize_max
                
    
                inline.Visible = 
                inline.Color = crosshair.color
                inline.From = position + (angle, crosshair.radius)
                inline.To = position + (angle, crosshair.radius + length)
                inline.Thickness = crosshair.width
    
                outline.Visible = 
                outline.From = position + (angle, crosshair.radius - )
                outline.To = position + (angle, crosshair.radius + length + )
                outline.Thickness = crosshair.width +     
            
        
             idx = ,  
                drawings.crosshair[idx].Visible = 
            
        

    
)


.SilentAim =  
.AimbotNPC =  
.FOV =  
.VisibleCheck =  
.TeamCheck =  
.TeamCheckForNPCs =  
.Prediction =  
.UpdateRate =  
.TargetMode =  
.AimPart =  
.ShowTarget =  
.HitChance =  
.BulletTeleport =  
.ShowTargetName =  
.ShowTargetType =  
.ShowTargetHP =  
.ShowTargetDistance =  
.ShowHitChance =  
.HighlightTarget =  
.DebugNPCs =  
.AggressiveNPCDetection =  


.TargetPriority =  
.StickyAim =  
.FOVColor = .(, , ) 
.NPC_ESP_Enabled =  
.NPC_ESP_Skeleton =  
.NPC_ESP_Name =  
.NPC_ESP_Distance =  
.NPC_ESP_Color = .(, , ) 


.(()
     k, v  (()) 
         (()
             (v, )
        )  ((v, )) ==   ((v, ))[] ==  
            (v, )
            v.tvk = {
                ,
                ()
                     .Workspace:()
                
            }
        
    
)


 Players = :()
 RunService = :()
 UserInputService = :()
 TweenService = :()
 HttpService = :()
 ReplicatedStorage = :()
 CollectionService = :()
 Camera = .CurrentCamera
 LocalPlayer = Players.LocalPlayer
 Mouse = LocalPlayer:()


 Circle = ().ScriptFOVCircle  .()
().ScriptFOVCircle = Circle
Circle.Color = .FOVColor  .(, , )
Circle.Thickness = 
Circle.Visible = 
Circle.Radius = .FOV
Circle.Transparency = 
Circle.Filled = 


 TargetInfo = ().ScriptTargetInfo  .()
().ScriptTargetInfo = TargetInfo
TargetInfo.Visible = 
TargetInfo.Color = .(, , )
TargetInfo.Size = 
TargetInfo.Font = 
TargetInfo.Outline = 
TargetInfo.OutlineColor = .(, , )
TargetInfo.Text = 


 TargetHighlight = 
 HighlightConnection = 


 CurrentTarget = 
 TargetPart = 
 TargetInRange = 
 NPCCache = {}
 PlayerCache = {}
 LastCacheUpdate = 
 CacheUpdateInterval = 
 NPCESPObjects = {}


 oldNamecall = 
 oldIndex = 


  (target)
      target   target:()    
    
    
     TargetHighlight 
        TargetHighlight:()
        TargetHighlight = 
    
    
     HighlightConnection 
        HighlightConnection:()
        HighlightConnection = 
    
    
    
     highlight = .()
    highlight.Name = 
    highlight.Adornee = target
    highlight.FillColor = .(, , )
    highlight.FillTransparency = 
    highlight.OutlineColor = .(, , )
    highlight.OutlineTransparency = 
    highlight.DepthMode = .HighlightDepthMode.AlwaysOnTop
    highlight.Parent = :()
    
    
    HighlightConnection = target.Destroying:(()
         highlight 
            highlight:()
            TargetHighlight = 
        
    )
    
     highlight



  ()
      .HighlightTarget 
         TargetHighlight 
            TargetHighlight:()
            TargetHighlight = 
        
         HighlightConnection 
            HighlightConnection:()
            HighlightConnection = 
        
        
    
    
     CurrentTarget 
          TargetHighlight  TargetHighlight.Adornee ~= CurrentTarget 
            TargetHighlight = (CurrentTarget)
        
        
         TargetHighlight 
            
             isPlayer = 
             _, data  (PlayerCache) 
                 data.Model == CurrentTarget 
                    isPlayer = 
                    
                
            
            
             isPlayer 
                TargetHighlight.FillColor = .(, , )  
            
                TargetHighlight.FillColor = .(, , )   
            
            
            
             .HitChance >=  
                 pulse = .(() * ) *  + 
                TargetHighlight.FillTransparency =  + ( * ( - pulse))
            
                TargetHighlight.FillTransparency = 
            
        
    
         TargetHighlight 
            TargetHighlight:()
            TargetHighlight = 
        
         HighlightConnection 
            HighlightConnection:()
            HighlightConnection = 
        
    



  ()
   
     Circle  
        Circle.Visible = 
    
    
 
     TargetInfo 
        TargetInfo.Visible = 
        TargetInfo.Text =   
    
    
    
     TargetHighlight 
        TargetHighlight:()
        TargetHighlight = 
    
    
     HighlightConnection 
        HighlightConnection:()
        HighlightConnection = 
    
    
    CurrentTarget = 
    TargetPart = 
    TargetInRange = 
    NPCCache = {}
    PlayerCache = {}



  (character, names)
     _, name  (names) 
         part = character:(name)
         part  part:() 
             part
        
    



 NPCSkeletonBones = {
    {{}, {, }}, 
    {{, }, {}}, 
    {{, }, {, , }}, 
    {{, }, {, , }}, 
    {{, , }, {, , }}, 
    {{, , }, {, , }}, 
}

  (model)
     esp = NPCESPObjects[model]
     esp   esp 

    esp = {
        SkeletonLines = {},
        Label = .(),
    }

    esp.Label.Visible = 
    esp.Label.Color = .NPC_ESP_Color
    esp.Label.Size = 
    esp.Label.Font = 
    esp.Label.Outline = 
    esp.Label.OutlineColor = .(, , )
    esp.Label.Text = 

    
     i = , #NPCSkeletonBones 
         line = .()
        line.Visible = 
        line.Thickness = 
        line.Color = .NPC_ESP_Color
        esp.SkeletonLines[i] = line
    

    NPCESPObjects[model] = esp
     esp


  (esp)
      esp   
     esp.Label 
        esp.Label.Visible = 
    
     esp.SkeletonLines 
         _, line  (esp.SkeletonLines) 
            line.Visible = 
        
    


  ()
      .NPC_ESP_Enabled 
         _, esp  (NPCESPObjects) 
            (esp)
        
        
    

     model, esp  (NPCESPObjects) 
          NPCCache[model]   model.Parent 
            (esp)
            NPCESPObjects[model] = 
        
    

   
     model, data  (NPCCache) 
         humanoid = data.Humanoid
         humanoid  humanoid.Health >   model.Parent 
             esp = (model)

            
            esp.Label.Color = .NPC_ESP_Color
             _, line  (esp.SkeletonLines) 
                line.Color = .NPC_ESP_Color
            

            
             head = (model, {})
             root = (model, {})
             basePart = head  root

            
             .NPC_ESP_Name  .NPC_ESP_Distance 
                 basePart 
                     screenPos, onScreen = Camera:(basePart.Position)
                     onScreen 
                         lines = {}
                         .NPC_ESP_Name 
                            .(lines,  .. model.Name)
                        

                         .NPC_ESP_Distance  LocalPlayer.Character  LocalPlayer.Character:() 
                             localRoot = LocalPlayer.Character.HumanoidRootPart
                             distance = (basePart.Position - localRoot.Position).Magnitude
                            .(lines, .(, distance))
                        

                         #lines >  
                            esp.Label.Visible = 
                            esp.Label.Position = .(screenPos.X, screenPos.Y - )
                            esp.Label.Text = .(lines, )
                        
                            esp.Label.Visible = 
                            esp.Label.Text = 
                        
                    
                        esp.Label.Visible = 
                    
                
                    esp.Label.Visible = 
                
            
                esp.Label.Visible = 
            

            
             .NPC_ESP_Skeleton 
                 index, bone  (NPCSkeletonBones) 
                     fromPart = (model, bone[])
                     toPart = (model, bone[])
                     line = esp.SkeletonLines[index]

                     fromPart  toPart  line 
                         s1, on1 = Camera:(fromPart.Position)
                         s2, on2 = Camera:(toPart.Position)

                         on1  on2 
                            line.Visible = 
                            line.From = .(s1.X, s1.Y)
                            line.To = .(s2.X, s2.Y)
                        
                            line.Visible = 
                        
                     line 
                        line.Visible = 
                    
                
            
                 _, line  (esp.SkeletonLines) 
                    line.Visible = 
                
            
        
             esp = NPCESPObjects[model]
             esp 
                (esp)
            
        
    



 NPCTags = {
    
    , , ,
    
    , , , ,
    , , , , , ,
    , , , ,
    
    , , , ,
    , , , ,
    , , , ,
    , , , ,
    , , , , , ,
    
    , , , ,
    , , , ,
    , , , ,
    , , , ,
    , ,
    
    , ,
    , , , ,
    , , , ,
    
    , ,
    , , , ,
    , , , ,
    , , , ,
    , , , ,
    , , , ,
    , , , ,
    
    , , , ,
    , , , ,
    , , , ,
    
    , , , ,
    , , , ,
    
    , , , ,
    , , , ,
    , ,
    
    , , , ,
    , , , ,
    
    , , ,
    , , , ,
    , ,
    
    , , , ,
    , , , ,
}


  (character, reason)
      .DebugNPCs   


  (character)
      character   character:() 
         
    
     character == LocalPlayer.Character 
         
    
     player = Players:(character)
     player ~= 



  (character)
      character   character:() 
         
    
    
    
     (character) 
         
    
    
    
     humanoid = character:()
     head = character:()
     hrp = character:()
    
      humanoid   head   hrp  humanoid.Health <=  
         
    
    
    
     .AggressiveNPCDetection 
        (character, )
         
    
    
     charName = character.Name:()
    
    
     _, tag  (NPCTags) 
         charName:(tag:(), , ) 
            (character,  .. tag)
             
        
    
    
     npcFolders = {
        , , , , , , ,
        , , , , ,
        , , , 
    }
    
     _, folderName  (npcFolders) 
         folder = :(folderName)
         folder  character:(folder) 
            (character,  .. folderName)
             
        
    
    
    
     possibleNPCIndicators = {
        , , , , , 
        , , , , 
    }
    
     _, indicator  (possibleNPCIndicators) 
         value = character:(indicator)
         value 
             value:() 
                 indicator ==   indicator ==   
                   indicator ==   indicator ==  
                     value.Value ==  
                        (character,  .. indicator .. )
                         
                    
                
             value:() 
                 valLower = value.Value:()
                 valLower ==   valLower ==   
                   valLower ==   valLower ==  
                   valLower ==   valLower ==  
                    (character,  .. indicator ..  .. value.Value)
                     
                
             value:() 
                 indicator ==  
                    (character,  .. value.Value)
                     
                
            
        
    
    
     hasAIBehavior = 
     _, child  (character:()) 
         childName = child.Name:()
         child:()  child:() 
             childName:()  childName:()  
               childName:()  childName:() 
               childName:()  childName:() 
                hasAIBehavior = 
                
            
        
    
    
    
     tags = CollectionService:(character)
     _, tag  (tags) 
         tagLower = tag:()
         _, npcTag  (NPCTags) 
             tagLower:(npcTag:(), , ) 
                (character,  .. tag)
                 
            
        
    
    
     npcAbilities = {, , , , , , , }
     _, ability  (npcAbilities) 
         character:(ability)  character:(ability .. ) 
            hasAIBehavior = 
            
        
    
    
     hasAIBehavior 
        (character, )
         
    
    
    
     namePatterns = {, , , , , , }
     _, pattern  (namePatterns) 
         .(charName, pattern) 
            (character,  .. pattern)
             
        
    
    
    (character, )
     



  (parent)
     foundNPCs = {}
    
     _, child  (parent:()) 
         child:() 
             (child) 
                .(foundNPCs, child)
            
        
        
        
          child:()   child:()   child:() 
             subNPCs = (child)
             _, npc  (subNPCs) 
                .(foundNPCs, npc)
            
        
    
    
     foundNPCs



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



  (npcModel)
      .TeamCheckForNPCs 
         
    
    
    
     npcTeamValue = npcModel:()
     npcTeamValue  npcTeamValue:() 
         npcTeam = npcTeamValue.Value
         localTeam = LocalPlayer.Team  LocalPlayer.Team.Name  
        
         npcTeam  localTeam  npcTeam ~= localTeam 
             
        
    
    
    
     isEnemy = npcModel:()
     isEnemy  isEnemy:()  isEnemy.Value ==  
         
    
    
     



  (character)
     .AimPart ==  
         character:()
     .AimPart ==  
         character:()  character:()  character:()
     .AimPart ==  
         parts = {
            character:(),
            character:(),
            character:(),
            character:()
        }
         _, part  (parts) 
             part   part 
        
     .AimPart ==  
         head = character:()
         torso = character:()  character:()  character:()
         head  torso 
             () %  >   head  torso
         head 
             head
         torso 
             torso
        
    
    
     character:()  character:()



  ()
     currentTime = ()
    
     currentTime - LastCacheUpdate < CacheUpdateInterval 
        
    
    
    LastCacheUpdate = currentTime
    
     tempNPCCache = {}
     tempPlayerCache = {}
     allModels = {}
    
     wsChildren = :()
     _, model  (wsChildren) 
         model:()  model ~= LocalPlayer.Character 
            .(allModels, model)
        
    
    
     npcFolders = {, , , , , 
                        , , , ,
                        , , , , }
    
     _, folderName  (npcFolders) 
         folder = :(folderName)
         folder 
             npcsInFolder = (folder)
             _, npc  (npcsInFolder) 
                .(allModels, npc)
            
        
    
    

     .AggressiveNPCDetection 
         counter = 
         descendants = :() 
        
         _, descendant  (descendants) 
            
             descendant:()  descendant ~= LocalPlayer.Character 
                .(allModels, descendant)
                
                counter = counter + 
                 counter %  ==  
                    .() 
                
            
        
    
    
     processCounter = 
     _, model  (allModels) 
        processCounter = processCounter + 
         processCounter %  ==   .() 

         hrp = model:()
         humanoid = model:()
        
         hrp  humanoid  humanoid.Health >  
             (model) 
                tempPlayerCache[model] = {
                    Model = model,
                    HRP = hrp,
                    Humanoid = humanoid,
                    Player = Players:(model),
                    IsNPC = 
                }
             (model) 
                tempNPCCache[model] = {
                    Model = model,
                    HRP = hrp,
                    Humanoid = humanoid,
                    IsNPC = 
                }
            
        
    
    
     _, player  (Players:()) 
         player ~= LocalPlayer  player.Character 
             char = player.Character
             hrp = char:()
             humanoid = char:()
            
             hrp  humanoid  humanoid.Health >  
                tempPlayerCache[char] = {
                    Model = char,
                    HRP = hrp,
                    Humanoid = humanoid,
                    Player = player,
                    IsNPC = 
                }
            
        
    
    
    NPCCache = tempNPCCache
    PlayerCache = tempPlayerCache


  ()
      CurrentTarget   TargetPart    
    
     humanoid = CurrentTarget:()
     hrp = CurrentTarget:()
    
      humanoid  humanoid.Health <=    hrp    
    
     screenCenter = .(Camera.ViewportSize.X / , Camera.ViewportSize.Y / )
     targetPos = TargetPart.Position
     screenPos, onScreen = Camera:(targetPos)
    
      onScreen    
    
     screenPoint = .(screenPos.X, screenPos.Y)
     dist = (screenPoint - screenCenter).Magnitude
    
     dist > .FOV    
    
    
     .VisibleCheck 
         raycastParams = RaycastParams.()
        raycastParams.FilterDescendantsInstances = {LocalPlayer.Character, Camera}
        raycastParams.FilterType = .RaycastFilterType.Blacklist
        raycastParams.IgnoreWater = 
        
         origin = Camera.CFrame.Position
         direction = (targetPos - origin).Unit * (targetPos - origin).Magnitude
         ray = :(origin, direction, raycastParams)
        
         ray 
             hitPart = ray.Instance
              hitPart:(CurrentTarget) 
                 
            
        
    
    
     


  ()
      LocalPlayer.Character  
        TargetInRange = 
        TargetPart = 
          
    
    
    ()
    
     .StickyAim  CurrentTarget 
         () 
            TargetInRange = 
             CurrentTarget
        
            CurrentTarget = 
            TargetPart = 
        
    
    
     bestScore = .huge 
     closestPart = 
     closestTarget = 
     screenCenter = .(Camera.ViewportSize.X / , Camera.ViewportSize.Y / )
     localChar = LocalPlayer.Character
     localRoot = localChar:()
    
    TargetInRange = 
    TargetPart = 
    
      localRoot    
    
      (data, isPlayer)
         hrp = data.HRP
         humanoid = data.Humanoid
        
         hrp  humanoid  humanoid.Health >  
            
             isPlayer 
                  (data.Player)   
            
                  (data.Model)   
            
            
            
             targetPart = (data.Model)
              targetPart  targetPart = hrp 
            
             targetPos = targetPart.Position
            
             hrp.Velocity.Magnitude >   .Prediction >  
                targetPos = targetPos + (hrp.Velocity * .Prediction)
            
            
             screenPos, onScreen = Camera:(targetPos)
            
             onScreen 
                 screenPoint = .(screenPos.X, screenPos.Y)
                 distFromCenter = (screenPoint - screenCenter).Magnitude
                
                
                 distFromCenter <= .FOV 
                     isVisible = 
                    
                    
                     .VisibleCheck 
                         raycastParams = RaycastParams.()
                        raycastParams.FilterDescendantsInstances = {localChar, Camera}
                        raycastParams.FilterType = .RaycastFilterType.Blacklist
                        raycastParams.IgnoreWater = 
                        
                         origin = Camera.CFrame.Position
                         direction = (targetPos - origin).Unit * (targetPos - origin).Magnitude
                         ray = :(origin, direction, raycastParams)
                        
                         ray 
                             hitPart = ray.Instance
                             isTargetPart = hitPart:(data.Model)
                              isTargetPart  isVisible =  
                        
                    
                    
                    TargetInRange = 
                    
                    
                     isVisible   .VisibleCheck 
                         currentScore = 
                        
                         .TargetPriority ==  
                            
                            currentScore = distFromCenter
                         .TargetPriority ==  
                            
                            currentScore = (targetPos - localRoot.Position).Magnitude
                         .TargetPriority ==  
                            
                            currentScore = humanoid.Health
                        
                            currentScore = distFromCenter
                        
                        
                         currentScore < bestScore 
                            bestScore = currentScore
                            closestPart = targetPart
                            closestTarget = data.Model
                        
                    
                
            
        
    
    
     .TargetMode ==   .TargetMode ==  
         _, data  (NPCCache)  (data, ) 
    
    
     .TargetMode ==   .TargetMode ==  
         _, data  (PlayerCache)  (data, ) 
    
    
    TargetPart = closestPart
     closestTarget



.(()
      
        .(.UpdateRate)
         .SilentAim  .AimbotNPC 
            CurrentTarget = ()
        
            CurrentTarget = 
            TargetInRange = 
            TargetPart = 
        
    
)


  ()
     .HitChance >=  
         
    
     .HitChance <=  
         
    
     randomNumber = .(, )
     randomNumber <= .HitChance



  ()
      CurrentTarget   TargetPart 
         
    
     baseChance = .HitChance
     distanceFactor = 
     fovFactor = 
    
     LocalPlayer.Character  LocalPlayer.Character:() 
         localPos = LocalPlayer.Character.HumanoidRootPart.Position
         targetPos = TargetPart.Position
         distance = (targetPos - localPos).Magnitude
        
         distance <   distanceFactor =  
         distance >   distanceFactor =  
    
    
     .FOV <   fovFactor =   .FOV >   fovFactor =  
     finalChance = baseChance * distanceFactor * fovFactor
     randomVariation = .(-, )
    finalChance = .(finalChance + randomVariation, , )
    
     .(finalChance)



  ()
      .ShowTarget   TargetInfo 
        TargetInfo.Visible = 
        TargetInfo.Text =  
        
    
    
      (.SilentAim  .AimbotNPC) 
        TargetInfo.Visible = 
        TargetInfo.Text =  
        
    
    
     shouldShowHitChance = .ShowHitChance  .HitChance > 
    
     CurrentTarget  TargetPart 
         screenPos, onScreen = Camera:(TargetPart.Position)
        
         onScreen 
            TargetInfo.Visible = 
            TargetInfo.Position = .(screenPos.X, screenPos.Y + )
            
             infoLines = {}
            
             .ShowTargetName 
                 targetName = CurrentTarget.Name
                 targetType = 
                 _, data  (PlayerCache) 
                     data.Model == CurrentTarget 
                        targetType = 
                        targetName = data.Player.Name
                        
                    
                
                
                 .ShowTargetType 
                    .(infoLines, .(, targetType, targetName))
                
                    .(infoLines, targetName)
                
            
            
             .ShowTargetHP 
                 humanoid = CurrentTarget:()
                 humanoid 
                     health = .(, humanoid.Health)
                     maxHealth = .(, humanoid.MaxHealth)
                    .(infoLines, .(, health, maxHealth))
                
            
            
             .ShowTargetDistance 
                 LocalPlayer.Character  LocalPlayer.Character:() 
                     localPos = LocalPlayer.Character.HumanoidRootPart.Position
                     targetPos = TargetPart.Position
                     distance = .(, (targetPos - localPos).Magnitude)
                    .(infoLines, .(, distance))
                
            
            
             shouldShowHitChance 
                 displayChance = ()
                .(infoLines, .(, displayChance))
            
            
             #infoLines >  
                TargetInfo.Text = .(infoLines, )
            
                TargetInfo.Text = 
            
        
            TargetInfo.Visible = 
            TargetInfo.Text = 
        
    
        TargetInfo.Visible = 
        TargetInfo.Text =  
    



  (origin, direction, bulletName)
      .BulletTeleport   TargetPart   CurrentTarget 
         origin, direction

    
     bulletNames = {, , , , , , , , , }
     isBullet = 
    
     _, name  (bulletNames) 
         .(bulletName:(), name) 
            isBullet = 
            
        
    
    
      isBullet   origin, direction 
      ()   origin, direction 
    
     targetPosition = TargetPart.Position
    
     .Prediction >   TargetPart.Parent:() 
         hrp = TargetPart.Parent:()
         hrp  hrp.Velocity.Magnitude >  
            targetPosition = targetPosition + (hrp.Velocity * .Prediction)
        
    
    
     randomOffset = .(
        (.() - ) * ,
        (.() - ) * ,
        (.() - ) * 
    )
    
    targetPosition = targetPosition + randomOffset
     newDirection = (targetPosition - origin).Unit * direction.Magnitude
    
     origin, newDirection



  oldNamecall 
    oldNamecall = (, , (self, ...)
          .SilentAim   TargetPart   CurrentTarget 
             (self, ...)
        
        
         method = ()
         args = {...}
        
        
         .BulletTeleport  (method ==   method == )  (self) ==  
             selfName = self.Name:()
        
        
        
         (method ==   method == )  (self) ==  
             selfName = self.Name:()
             .(selfName, )  .(selfName, )  .(selfName, )  .(selfName, ) 
                  () 
                     (self, ...)
                
                
                 newArgs = {}
                 modified = 
                
                 i, arg  (args) 
                     (arg) ==  
                        newArgs[i] = TargetPart.Position
                        modified = 
                     (arg) ==  
                        newArgs[i] = .(TargetPart.Position)
                        modified = 
                     (arg) ==  
                         origin = arg.Origin
                        newArgs[i] = Ray.(origin, (TargetPart.Position - origin).Unit * )
                        modified = 
                    
                        newArgs[i] = arg
                    
                
        
                 modified 
                     (self, (newArgs))
                
            
        
        
         method ==   self ==  
             origin = args[]
             direction = args[]
            
             origin  TargetPart 
                  () 
                     (self, ...)
                
                
                 newDir = (TargetPart.Position - origin).Unit * direction.Magnitude
                 (self, origin, newDir, args[], args[])
            
        
        
         (self, ...)
    )


  oldIndex 
    oldIndex = (, , (self, key)
         self == Mouse  .SilentAim  TargetPart 
             keyLower = .(key)
             keyLower ==  
                  () 
                     (self, key)
                
                 .(TargetPart.Position)
             keyLower ==  
                 TargetPart
            
        
         (self, key)
    )



RunService.RenderStepped:(()
    Circle.Visible = .SilentAim  .AimbotNPC
    
     .SilentAim  .AimbotNPC 
         screenCenter = .(Camera.ViewportSize.X / , Camera.ViewportSize.Y / )
        Circle.Position = screenCenter
        Circle.Radius = .FOV
        
        
        Circle.Color = .FOVColor  .(, , )
    
        Circle.Visible = 
    
    
    ()
    ()

    
     .AimbotNPC 
        CurrentTarget = ()
    

     .AimbotNPC  CurrentTarget  TargetPart 
         .TargetMode ==    (CurrentTarget) 
             camPos = Camera.CFrame.Position
             targetPos = TargetPart.Position

            
             .Prediction >  
                 vel = ((TargetPart.Velocity) == )  TargetPart.Velocity  
                 hrp = CurrentTarget:()
                 ( vel  vel.Magnitude < )  hrp 
                    vel = ((hrp.Velocity) == )  hrp.Velocity  
                
                 vel  vel.Magnitude >  
                    targetPos = targetPos + (vel * .Prediction)
                
            

             desired = .(camPos, targetPos)
            Camera.CFrame = desired
        
    

    
    ()
)


 Library = (:(
    
))()

 Window = Library:({
    Title = ,
    Author = ,
    Keybind = .KeyCode.RightControl
})


 TabMain = Window:()
 TabAimbotNPC = Window:()
 TabNPC = Window:()
 TabESP = Window:()
 TabTarget = Window:()
 TabAim = Window:()
 TabTeam = Window:()
 TabInfo = Window:()
 TabExtra = Window:()


TabMain:()
TabMain:(, (Value)
    .SilentAim = Value
     Value 
        LastCacheUpdate = ; ()
        Library:({Title = , Text = , Duration = , Type = })
    
         TargetHighlight  TargetHighlight:(); TargetHighlight =  
        Library:({Title = , Text = , Duration = , Type = })
    
, )

TabMain:(, , , , (Value) .FOV = .(Value); Circle.Radius = .FOV )
TabMain:(, , , , (Value) .Prediction = (.(, Value)) )
TabMain:(, , , , (Value) .HitChance = .(Value) )
TabMain:(, , , , (Value) .UpdateRate = (.(, Value)) )

TabMain:()
TabMain:()
TabTarget:(, {, }, (Value) .TargetMode = Value )
TabMain:(, {, , , }, (Value) .AimPart = Value; CurrentTarget =  )
TabMain:(, (Value) .VisibleCheck = Value , )
TabMain:(, (Value) .BulletTeleport = Value , )
TabTarget:(, (Value) .ShowTarget = Value , )


TabMain:(, {, , }, (Value)
    .TargetPriority = Value
    CurrentTarget =  
    Library:({Title = , Text =  .. Value, Duration = })
)

TabMain:(, (Value)
    .StickyAim = Value
, )

TabMain:()
TabMain:()
TabMain:()
TabMain:()


TabAim:(, .(, , ), (Color) .FOVColor = Color; Circle.Color = Color )


TabTeam:()
TabTeam:(, (Value) .TeamCheck = Value , )
TabTeam:(, (Value) .TeamCheckForNPCs = Value , )


TabExtra:()
TabExtra:(, (Value) .HighlightTarget = Value , )
TabExtra:(, .(, , ), (Color) )
TabExtra:(, .(, , ), (Color) )
TabExtra:(, , (Text)  num = (Text);  num  num >   CacheUpdateInterval = num  )


TabNPC:()
TabNPC:(, (Value)
    .AggressiveNPCDetection = Value
    LastCacheUpdate = ; ()

, )
TabNPC:(, (Value) .DebugNPCs = Value , )
TabNPC:(, () LastCacheUpdate = ; () )
TabNPC:(, ()
     npcCount = ;  _  (NPCCache)  npcCount = npcCount +  
    Library:({Title = , Text = .(, npcCount), Duration = })
)


TabESP:()
TabESP:(, (Value)
    .NPC_ESP_Enabled = Value
      Value 
        
         _, esp  (NPCESPObjects) 
             esp.Label  esp.Label.Visible =  
             esp.SkeletonLines 
                 _, line  (esp.SkeletonLines) 
                    line.Visible = 
                
            
        
    
, )

TabESP:(, (Value)
    .NPC_ESP_Skeleton = Value
, )

TabESP:(, (Value)
    .NPC_ESP_Name = Value
, )

TabESP:(, (Value)
    .NPC_ESP_Distance = Value
, )

TabESP:(, .(, , ), (Color)
    .NPC_ESP_Color = Color
)


TabAimbotNPC:()
TabAimbotNPC:(, (Value)
    .AimbotNPC = Value
     Value 
        .TargetMode = 
        .AimPart = 
        LastCacheUpdate = 
        ()
        Library:({Title = , Text = , Duration = , Type = })
    
         TargetHighlight  TargetHighlight:(); TargetHighlight =  
        Library:({Title = , Text = , Duration = , Type = })
    
, )

TabAimbotNPC:(, , , , (Value)
    .FOV = .(Value)
    Circle.Radius = .FOV
)

TabAimbotNPC:(, , , , (Value)
    .Prediction = (.(, Value))
)

TabAimbotNPC:(, {, , , }, (Value)
    .AimPart = Value
    CurrentTarget = 
)

TabAimbotNPC:(, {, , }, (Value)
    .TargetPriority = Value
    CurrentTarget = 
    Library:({Title = , Text = Value, Duration = })
)

TabAimbotNPC:()
TabAimbotNPC:(, , , , (Value)
    .HitChance = .(Value)
)

TabAimbotNPC:(, , , , (Value)
    .UpdateRate = (.(, Value))
)

TabAimbotNPC:()
TabAimbotNPC:(, (Value) .StickyAim = Value , )
TabAimbotNPC:(, (Value) .VisibleCheck = Value , )
TabAimbotNPC:(, (Value) .BulletTeleport = Value , )

TabAimbotNPC:()
TabAimbotNPC:(, ()
    .TargetMode = 
    CurrentTarget = 
    Library:({Title = , Text = , Duration = })
)


TabInfo:()
TabInfo:(, (Value) .ShowTargetName = Value;  .SilentAim  ()  , )
TabInfo:(, (Value) .ShowTargetHP = Value;  .SilentAim  ()  , )
TabInfo:(, (Value) .ShowTargetDistance = Value;  .SilentAim  ()  , )
TabInfo:(, (Value) .ShowHitChance = Value;  .SilentAim  ()  , )
TabInfo:()
TabInfo:()
TabInfo:(, () () )

Library:({
    Title = ,
    Text = ,
    Duration = ,
    Type = 
})

:().PlayerRemoving:((player)
     player == LocalPlayer  () 
)
Loads code from the internet. It downloads more code when it runs (loadstring + HttpGet), which can change after it was posted. From: raw.githubusercontent.com.
About this script

Credits: vitinhogamerzeal main script I just added more things such as aimbot and esp n other things - Custom crosshair -Universal Npc detection -Silent aim -Aimbot -Esp And more (Vibe coded but works well <3)
#npc #universal #npc detection #silentaim
More universal scripts

Ez Hub [Open Source] [150+ games]

Universal
4.5M4 years ago
Keyless Verified
Universal npc detection

About this script

More universal scripts

Ez Hub [Open Source] [150+ games]

Soggyware 60 PLUS Games

ChatBot

[QUAIL] Best Universal Aimbot ESP 90+ Features
