Silent Aim

().AimTarget =  
().AimWallbang = 


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


  (cameraPos, targetPos, ignoreList)
     direction = (targetPos - cameraPos)
     distance = direction.Magnitude
     distance <=  
         
    
    direction = direction.Unit

     params = RaycastParams.()
    params.FilterType = .RaycastFilterType.Blacklist
    params.FilterDescendantsInstances = ignoreList
    params.IgnoreWater = 

     rayResult = Workspace:(cameraPos, direction * (distance + ), params)
     rayResult ==  
         
    

     hitInstance = rayResult.Instance
     .(rayResult.Distance - distance) <  
         
    

     current = hitInstance
     current 
         current:()  current:() 
             
        
        current = current.Parent
    

     


  ()
     character = LocalPlayer.Character
      character 
         {}
    
     primaryPart = character.PrimaryPart
      primaryPart 
         {}
    

     cameraPos = Camera.CFrame.Position
     screenCenter = .(Camera.ViewportSize.X / , Camera.ViewportSize.Y / )

     ignoreList = {character}
     _, child  (character:()) 
         child:() 
            .(ignoreList, child)
        
    

     allTargets = {}

      (charModel, hrp, isVisible)
        .(allTargets, {
            character = charModel,
            hrp = hrp,
            isVisible = isVisible
        })
    

     ().AimTarget ==   ().AimTarget ==  
         missionsFolder = Workspace:()
         missionsFolder 
             _, mission  (missionsFolder:()) 
                 aiSpawners = mission:()
                 aiSpawners 
                     _, spawner  (aiSpawners:()) 
                         botModel = spawner:()
                         botModel 
                             humanoid = botModel:()
                             hrp = botModel:()
                             humanoid  hrp  humanoid.Health >  
                                 visible = (cameraPos, hrp.Position, ignoreList)
                                 visible 
                                    (botModel, hrp, )
                                 ().AimWallbang 
                                    (botModel, hrp, )
                                
                            
                        
                    
                
            
        
    

     ().AimTarget ==   ().AimTarget ==  
         _, player  (Players:()) 
             player ~= LocalPlayer 
                 targetChar = player.Character
                 targetChar 
                     humanoid = targetChar:()
                     hrp = targetChar:()
                     humanoid  hrp  humanoid.Health >  
                        .(ignoreList, targetChar)
                         visible = (cameraPos, hrp.Position, ignoreList)
                         visible 
                            (targetChar, hrp, )
                         ().AimWallbang 
                            (targetChar, hrp, )
                        
                    
                
            
        
    

     targetsWithDist = {}
     _, target  (allTargets) 
         screenPos, onScreen = Camera:(target.hrp.Position)
         onScreen 
            target.screenDist = (.(screenPos.X, screenPos.Y) - screenCenter).Magnitude
            .(targetsWithDist, target)
        
    

    .(targetsWithDist, (a, b)
         a.isVisible ~= b.isVisible 
             a.isVisible
        
         a.screenDist < b.screenDist
    )

     result = {}
     _, target  (targetsWithDist) 
        .(result, target.character)
    

     result


 RaycastModule = (:().Modules.Tool.Gun.Raycast)
 GetMouseHitModule = (:().Modules.Tool.Raw.GetMouseHit)
(restorefunction, RaycastModule.FireRay)
(restorefunction, GetMouseHitModule)
 FireRay; FireRay = (RaycastModule.FireRay, (p1, p2, p3, p4, p5, p6, p7, p8)
     bestTargets = ()
     #bestTargets >  
         v1, v2, v3, v4
         target = bestTargets
        v1 = {target[].HumanoidRootPart.Position}
        v2 = {}
        v3 = {}
         _,v  (target) 
            .(v2, {
                v,
                target[].HumanoidRootPart.Position,
                (target[].HumanoidRootPart.Position-:().LocalPlayer.Character.PrimaryPart.Position).Unit,
                
            })
            .(v3, v.Humanoid)
        
        v4 = {}
         v1, v2, v3, v4
    
         (p1, p2, p3, p4, p5, p6, p7, p8)
    
)
 GetMouseHit; GetMouseHit = (GetMouseHitModule, (p1)
     bestTargets = ()
     #bestTargets >  
         bestTargets[].HumanoidRootPart.Position
    
         (p1)
    
)