Simple closet autoparry

 Players = :()
 RunService = :()
 Workspace = :()
 .bladeball 
	()

.bladeball = 

 RADIUS = 
 COMPENSATION =  / 

 LocalPlayer = Players.LocalPlayer

 Bin

	Bin = ({}, {
		__tostring = ()
			 
		,
	})
	Bin.__index = Bin
	 Bin.(...)
		 self = ({}, Bin)
		 self:(...)  self
	
	 Bin:()
	
	 Bin:(item)
		 node = {
			item = item,
		}
		 self.head ==  
			self.head = node
		
		 self.tail 
			self.tail.next = node
		
		self.tail = node
		 item
	
	 Bin:(...)
		 args = { ... }
		 _, item  args 
			 node = {
				item = item,
			}
			 self.head ==  
				self.head = node
			
			 self.tail 
				self.tail.next = node
			
			self.tail = node
		
		 args
	
	 Bin:()
		 self.head 
			 item = self.head.item
			 (item) ==  
				()
			 (item) ==  
				item:()
			 (item) ==  
				.(item)
			 item.destroy ~=  
				item:()
			 item.Destroy ~=  
				item:()
			
			self.head = self.head.next
		
	
	 Bin:()
		 self.head == 
	

  (x, y, z, vx, vy, vz, R)
	 a = vx ^  + vy ^  + vz ^ 
	 b =  * (vx * x + vy * y + vz * z)
	 c = x ^  + y ^  + z ^  - R ^ 
	 discriminant = b ^  -  * a * c
	 discriminant <  
		 
	
	 sqrtDiscriminant = .(discriminant)
	 denominator =  * a
	 t0 = (-b - sqrtDiscriminant) / denominator
	 t0 >  
		 t0
	
	 t1 = (-b + sqrtDiscriminant) / denominator
	 t1 >  
		 t1
	
	 


 BaseComponent

	BaseComponent = ({}, {
		__tostring = ()
			 
		,
	})
	BaseComponent.__index = BaseComponent
	 BaseComponent.(...)
		 self = ({}, BaseComponent)
		 self:(...)  self
	
	 BaseComponent:(instance)
		self.instance = instance
		self.bin = Bin.()
	
	 BaseComponent:()
		self.bin:()
	

 BallComponent

	 super = BaseComponent
	BallComponent = ({}, {
		__tostring = ()
			 
		,
		__index = super,
	})
	BallComponent.__index = BallComponent
	 BallComponent.(...)
		 self = ({}, BallComponent)
		 self:(...)  self
	
	 BallComponent:(instance)
		super.(self, instance)
		self.active = 
		self.target = 
		self.isHit = 
		self.delay = 
		self:()
		self:()
		 bin = self.bin
		bin:(instance:():(()
			 self:()
		), instance:():(()
			 self:()
		))
		bin:(()
			 _active = BallComponent.active
			 _instance = instance
			
			 _valueExisted = _active[_instance] ~= 
			_active[_instance] = 
			
			 _valueExisted
		, instance.Destroying:(()
			 self:()
		))
		 _active = BallComponent.active
		 _instance = instance
		 _self = self
		_active[_instance] = _self
	
	 BallComponent:()
		self.isHit = 
		self.delay = 
		self.target = self.instance:()
	
	 BallComponent:()
		self.isHit = 
		self.delay = 
		self.active = self.instance:() == 
	
	 BallComponent:()
		self.isHit = 
		self.delay = 
		.( + COMPENSATION / , ()
			  self.delay 
				 
			
			self.delay = 
			self.isHit = 
		)
	
	 BallComponent:()
		  self.isHit
	
	 BallComponent:()
		 self.target
	
	 BallComponent:()
		 self.active
	
	BallComponent.active = {}

 RigComponent

	 super = BaseComponent
	RigComponent = ({}, {
		__tostring = ()
			 
		,
		__index = super,
	})
	RigComponent.__index = RigComponent
	 RigComponent.(...)
		 self = ({}, RigComponent)
		 self:(...)  self
	
	 RigComponent:(instance)
		super.(self, instance)
		 root = instance:()
		 root ==  
			()
		
		 humanoid = instance:()
		 humanoid ==  
			()
		
		self.root = root
		self.humanoid = humanoid
		 bin = self.bin
		bin:(humanoid.Died:(()
			 self:()
		), instance.Destroying:(()
			 self:()
		))
	

 CharacterComponent

	 super = RigComponent
	CharacterComponent = ({}, {
		__tostring = ()
			 
		,
		__index = super,
	})
	CharacterComponent.__index = CharacterComponent
	 CharacterComponent.(...)
		 self = ({}, CharacterComponent)
		 self:(...)  self
	
	 CharacterComponent:(instance)
		super.(self, instance)
	
	CharacterComponent.active = {}

 PlayerComponent

	 super = BaseComponent
	PlayerComponent = ({}, {
		__tostring = ()
			 
		,
		__index = super,
	})
	PlayerComponent.__index = PlayerComponent
	 PlayerComponent.(...)
		 self = ({}, PlayerComponent)
		 self:(...)  self
	
	 PlayerComponent:(instance)
		super.(self, instance)
		self.name = self.instance.Name
		 character = instance.Character
		 character 
			.(()
				 self:(character)
			)
		
		 bin = self.bin
		bin:(instance.CharacterAdded:((character)
			 self:(character)
		), instance.CharacterRemoving:(()
			 self:()
		))
		bin:(()
			 _active = PlayerComponent.active
			 _instance = instance
			
			 _valueExisted = _active[_instance] ~= 
			_active[_instance] = 
			
			 _valueExisted
		)
		 _active = PlayerComponent.active
		 _instance = instance
		 _self = self
		_active[_instance] = _self
	
	 PlayerComponent:(character)
		 _result = self.character
		 _result ~=  
			_result:()
		
		self.character = CharacterComponent.(character)
	
	 PlayerComponent:()
		 _result = self.character
		 _result ~=  
			_result:()
		
		self.character = 
	
	 PlayerComponent:()
		 self.name
	
	 PlayerComponent:()
		 self.character
	
	PlayerComponent.active = {}


 ComponentController = {}

	 _container = ComponentController
	 BallFolder = Workspace:(, )
	 onBallAdded = (instance)
		 instance:() 
			BallComponent.(instance)
		
	
	 onPlayerAdded = (instance)
		PlayerComponent.(instance)
	
	
	  ()
		 _exp = BallFolder:()
		
		 _callback = (instance)
			 .(onBallAdded, instance)
		
		 _k, _v  _exp 
			(_v, _k - , _exp)
		
		
		BallFolder.ChildAdded:(onBallAdded)
		 _exp_1 = Players:()
		
		 _callback_1 = (instance)
			 .(onPlayerAdded, instance)
		
		 _k, _v  _exp_1 
			(_v, _k - , _exp_1)
		
		
		Players.PlayerAdded:(onPlayerAdded)
		Players.PlayerRemoving:((instance)
			 _active = PlayerComponent.active
			 _instance = instance
			 _result = _active[_instance]
			 _result ~=  
				_result = _result:()
			
			 _result
		)
	
	_container.__init = __init

 ParryController = {}

	 _container = ParryController
	 Vector2D = .(, , )
	 useParry = (ball)
		()
		()
		ball:()
	
	
	  ()
		 player = PlayerComponent.active[LocalPlayer]
		RunService.Heartbeat:(()
			 character = player:()
			  character 
				 
			
			 name = player:()
			 root = character.root
			 origin = root.Position
			 motion = root.AssemblyLinearVelocity * Vector2D
			 _exp = BallComponent.active
			
			 _callback = (ball, instance)
				  ball:() 
					 
				
				 ball:() ~= name 
					 
				
				 position = instance.Position - origin
				 position.Magnitude < RADIUS 
					 (ball)
				
				 velocity = instance.AssemblyLinearVelocity - motion
				 intercept = (position.X, position.Y, position.Z, velocity.X, velocity.Y, velocity.Z, RADIUS)
				 intercept ==  
					 
				
				 intercept > COMPENSATION 
					 
				
				 (ball)
			
			 _k, _v  _exp 
				(_v, _k, _exp)
			
			
		)
	
	_container.__init = __init


ComponentController.()
ParryController.()