Kill Aura OPEN SOURCE

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

.Config = {
	Enabled = ,
	Targets = {
		Guardians = ,
		Titans    = ,
		Players   = ,
		Dummies   = ,
		Ducks     = ,
		Chickens  = ,
	},
	Weapons = {
        , , , , ,
        , , , , ,
        , , , , ,
        , , , , ,
        , , , ,
		, , , , ,
		, , , , ,
		, , , ,
		, , , , ,
        , , , , ,
        , , , , , ,
	}
}

 SUMMONER_CLAWS = {
	summoner_claw_1 = ,
	summoner_claw_2 = ,
	summoner_claw_3 = ,
	summoner_claw_4 = ,
}

 Guardians = {}
 Titans    = {}
 Dummies   = {}
 Ducks     = {}
 Chickens  = {}

  (model)
	  model:()   
	 model.Name ==  
		.(Guardians, model)
	 model.Name ==  
		.(Titans, model)
	 model.Name:() 
		.(Dummies, model)
	 model.Name ==  
		.(Ducks, model)
	 model.Name ==  
		.(Chickens, model)
	


  (tbl, model)
	 i, v  (tbl) 
		 v == model  .(tbl, i)  
	


 _, obj  (Workspace:())  (obj) 
Workspace.ChildAdded:(classify)
Workspace.ChildRemoved:((obj)
	(Guardians, obj) (Titans, obj)
	(Dummies, obj)   (Ducks, obj)
	(Chickens, obj)
)

  (model)
	 model:()  model.PrimaryPart


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

	 myPos = myRoot.Position
	 closest, shortest = , .huge
	 cfg = .Config.Targets

	  (char)
		 root = (char)
		 root 
			 dist = (root.Position - myPos).Magnitude
			 dist < shortest  shortest = dist closest = char 
		
	

	 cfg.Players 
		 _, player  (Players:()) 
			 player ~= LocalPlayer  player.Character  (player.Character) 
		
	
	 cfg.Guardians   _, g  (Guardians)  (g)  
	 cfg.Titans      _, t  (Titans)     (t)  
	 cfg.Dummies     _, d  (Dummies)    (d)  
	 cfg.Ducks       _, d  (Ducks)      (d)  
	 cfg.Chickens    _, c  (Chickens)   (c)  

	 closest


  ()
	 myChar = LocalPlayer.Character
	  myChar    

	 weaponsSet = {}
	 _, name  (.Config.Weapons)  weaponsSet[name] =  

	 equippedAccessory = 
	 _, child  (myChar:()) 
		 child:()  weaponsSet[child.Name] 
			equippedAccessory = child
			
		
	
	  equippedAccessory    

	 weaponName = equippedAccessory.Name
	 invFolder = ReplicatedStorage:()
	  invFolder    

	 inv = invFolder:(LocalPlayer.Name)
	  inv    

	 _, item  (inv:()) 
		 item.Name == weaponName   item 
	
	 


  ()
	 myChar = LocalPlayer.Character
	  myChar    
	 weaponsSet = {}
	 _, name  (.Config.Weapons)  weaponsSet[name] =  
	 _, child  (myChar:()) 
		 child:()  weaponsSet[child.Name] 
			 child.Name
		
	
	 


  (name)
	 netManaged = ReplicatedStorage
		:()
		 ReplicatedStorage.rbxts_include
		:()
		 ReplicatedStorage.rbxts_include.node_modules
		:()
		 ReplicatedStorage.rbxts_include.node_modules[]
		:()
		 ReplicatedStorage.rbxts_include.node_modules[].net
		:()
		 ReplicatedStorage.rbxts_include.node_modules[].net.out
		:()
	  netManaged    
	 netManaged:(name)


 SwordHit          = ()
 SummonerClawRemote = ()

  (myRoot, targetRoot)
	  SummonerClawRemote   

	 direction = (targetRoot.Position - myRoot.Position).Unit

	 args = {
		{
			clientTime = (),
			direction  = direction,
			position   = myRoot.Position,
		}
	}

	(()
		SummonerClawRemote:((args))
	)


  (target, weapon, myRoot, targetRoot)
	  SwordHit   

	 args = {
		chargedAttack = { chargeRatio =  },
		entityInstance = target,
		validate = {
			selfPosition   = { value = myRoot.Position },
			targetPosition = { value = targetRoot.Position },
		},
		weapon = weapon,
	}

	(()
		SwordHit:(args)
	)


  ()
	 myChar = LocalPlayer.Character
	  myChar   

	 myRoot = (myChar)
	  myRoot   

	 target = ()
	  target   

	 targetRoot = (target)
	  targetRoot   

	 weaponName = ()
	  weaponName   

	 SUMMONER_CLAWS[weaponName] 
		(myRoot, targetRoot)
	
		 weapon = ()
		  weapon   
		(target, weapon, myRoot, targetRoot)
	


.(()
	.()
	  
		 .Config.Enabled 
			(attack)
		
		.()
	
)