idiot aura vrx

 Players = :()
 RunService = :()
 ReplicatedStorage = :()
 LocalPlayer = Players.LocalPlayer

 LagServer = {
    loopThread = ,
    running = 
}

 LagServer:()
     ok, res = (()
         LocalPlayer.Data.Character.Value
    )
     ok  res   res 
     char = LocalPlayer.Character
     hum = char  char:()
     hum  hum:()  


 LagServer:(characterName)
     ok, res = (()
         chars = ReplicatedStorage:()
         folder = chars:(characterName)
         ab = folder  folder:()
         ab  ab:() ~= 
    )
     ok  res


 LagServer:()
     char = LocalPlayer.Character
     hrp = char  char:()
      hrp    

     nearest, dist = , .huge
     _,p  (Players:()) 
         p ~= LocalPlayer  p.Character 
             tr = p.Character:()
             th = p.Character:()
             tr  th 
                 hp = th:()
                 hp  hp >  
                     d = (hrp.Position - tr.Position).Magnitude
                     d < dist 
                        dist = d
                        nearest = p
                    
                
            
        
    
     nearest


 LagServer:()
     charName = self:()
      self:(charName)   

     target = self:()
      target   

     targetChar = target.Character
     targetCF = targetChar  targetChar:()  targetChar.HumanoidRootPart.CFrame  .()

    (()
         ability = ReplicatedStorage.Characters[charName].Abilities[]
        ReplicatedStorage.Remotes.Abilities.Ability:(ability, )

         actions = {,,,,,,}
         i=, 
             args = {
                ability,
                charName..,
                i,
                ,
                {
                    HitboxCFrames = {targetCF,targetCF},
                    BestHitCharacter = targetChar,
                    HitCharacters = {targetChar},
                    Ignore = i>  {ActionNumber1={targetChar}}  {},
                    DeathInfo = {},
                    BlockedCharacters = {},
                    HitInfo = {
                        IsFacing =  (i==  i==),
                        IsInFront = i<=,
                        Blocked = i>    
                    },
                    ServerTime = (),
                    Actions = i>  {ActionNumber1={}}  {},
                    FromCFrame = targetCF
                },
                ..actions[i],
                i==    
            }

             i== 
                args[].RockCFrame = targetCF
                args[].Actions = {
                    ActionNumber1 = {
                        [target.Name] = {
                            StartCFrameStr = (targetCF.X)....(targetCF.Y)....(targetCF.Z)..,
                            ImpulseVelocity = .(,-,),
                            AbilityName = ,
                            RotVelocityStr = ,
                            VelocityStr = ,
                            Duration = ,
                            RotImpulseVelocity = .(,-,-),
                            Seed = .(,),
                            LookVectorStr = 
                        }
                    }
                }
            

            ReplicatedStorage.Remotes.Combat.Action:((args))
        
    )


 LagServer:()
     self.loopThread   
    self.running = 
    
    self.loopThread = .(()
         self.running 
             target = self:()
             target 
                self:()
                (()
                     c = self:()
                    ReplicatedStorage.Remotes.Abilities.AbilityCanceled:(
                        ReplicatedStorage.Characters[c].Abilities[]
                    )
                )
                .()
            
                .()
            
        
        self.loopThread = 
    )


 LagServer:()
    self.running = 
     self.loopThread 
        .(self.loopThread)
        self.loopThread = 
    


 MobRemote = ReplicatedStorage:()  
                  ReplicatedStorage.Remotes:()  
                  ReplicatedStorage.Remotes.Character:()

 mob = LocalPlayer.Data.Character.Value
 mob ~=   MobRemote 
    MobRemote:()
    .()


LagServer:()