Upgraded Rocket launcher for NPC ONLY FE credits by DuaKNo

 LocalPlayer = :().LocalPlayer

  ()
	(() (LocalPlayer, , ) )
	(() (, ) )


()

.(()
	  
		.()
		()
	
)




  (f, scri)
	 oldenv = (f)
	 newenv = ({}, {
		__index = (_, k)
			 k:() ==    scri   oldenv[k] 
		
	})
	(f, newenv)
	(() () )


 cors = {}

 mas = .(, :())
mas.Name = 

 Tool          = .()
 Handle        = .()
 Mesh          = .()
 ReloadSound   = .()
 ToolScript    = .()
 MouseIcon     = .()
 ShuHold       = .()

Tool.Name = 
Tool.Parent = mas
Tool.TextureId = 
Tool.Grip = .(, -, -) * .(, .(-), .(-))
Tool.CanBeDropped = 

Handle.Name = 
Handle.Parent = Tool
Handle.Position = .(, , )
Handle.Rotation = .(-, , -)
Handle.CanCollide = 
Handle.FormFactor = .FormFactor.Custom
Handle.Size = .(, , )
Handle.CFrame = .(, , , -, , , , , , , , -)
Handle.BottomSurface = .SurfaceType.Smooth
Handle.TopSurface = .SurfaceType.Smooth

Mesh.Parent = Handle
Mesh.MeshId = 
Mesh.TextureId = 
Mesh.Scale = .(, , )
Mesh.MeshType = .MeshType.FileMesh

ReloadSound.Name = 
ReloadSound.Parent = Handle
ReloadSound.SoundId = 
ReloadSound.Volume = 
ReloadSound.Pitch = 
ReloadSound.RollOffMaxDistance = 
ReloadSound.RollOffMinDistance = 
ReloadSound.RollOffMode = .RollOffMode.InverseTapered

ToolScript.Name = 
ToolScript.Parent = Tool
.(cors, .(()
	()
	(()
		 SHOT_SPEED = 
		 SHOT_TIME  = 
		 MUZZLE_LOCAL_OFFSET = .(, , )
		 EXPLOSION_RADIUS = 
		 EXPLOSION_SOUND_ID = 

		 ROCKET_FORWARD_OFFSET = 
		 MAX_CLICK_RANGE = 

		 ROCKET_MESH_ID = 
		 ROCKET_MESH_SCALE = .(, , )
		 ROCKET_COLOR = 
		 ROCKET_FIRE_HEAT = 
		 ROCKET_FIRE_SIZE = 

		 ROCKET_INITIAL_ARC   = 
		 ROCKET_STEER_P       = 
		 ROCKET_STEER_D       = 
		 ROCKET_DETONATE_DIST = 
		 ROCKET_ARC_MIN_DIST  = 
		 ROCKET_ARC_FULL_DIST = 
		 ROCKET_ARM_TIME      = 

		 ROCKET_SLOWDOWN_DIST = 
		 ROCKET_MIN_SPEED_FRACTION = 
		 ROCKET_CORNER_MIN_SPEED = 

		 WHOOSH_START_VOLUME = 
		 WHOOSH_FADE_START   = 
		 WHOOSH_FADE_END     = 

		
		 ROCKET_OBSTACLE_LOOKAHEAD   = 
		 ROCKET_OBSTACLE_AVOID_PULL  = 
		 ROCKET_AVOID_BLEND          = 
		 ROCKET_AVOID_STICKY_TIME    = 
		 ROCKET_AVOID_RAMP_EXP       = 

		 ROCKET_MAX_LEAD_TIME = 
		 ROCKET_MIN_LEAD_SPEED = 

		 ROCKET_TERMINAL_LOCK_DIST = 
		 ROCKET_OVERSHOOT_DIST = 

		
		 EXPLOSION_BLAST_PRESSURE   =      
		 BLAST_KNOCKBACK_STRENGTH   =    
		 NPC_KNOCKBACK_STRENGTH     =    

		 PlayersService     = Game:()
		 DebrisService      = Game:()
		 RunService         = Game:()
		 SoundService       = Game:()
		 UserInputService   = Game:()

		 Workspace = 
		 LocalPlayer = PlayersService.LocalPlayer

		 Tool = .Parent
		 Handle = Tool:()
		 ReloadSound = Handle:()

		 Character, Humanoid, Player = , , 
		 BaseShot = 

		 ActiveShot     = 
		 ActiveWhoosh   = 
		 ActiveUpdateConn = 

		  ()
			 ActiveUpdateConn 
				ActiveUpdateConn:()
				ActiveUpdateConn = 
			
			 ActiveWhoosh 
				ActiveWhoosh:()
				ActiveWhoosh:()
				ActiveWhoosh = 
			
			 ActiveShot 
				ActiveShot = 
			
		

		  (soundId, position, volume, pitch)
			 anchor = .()
			anchor.Anchored = 
			anchor.CanCollide = 
			anchor.Transparency = 
			anchor.Size = .(, , )
			anchor.CFrame = .(position)
			anchor.Parent = Workspace

			 s = .()
			s.SoundId = soundId
			s.Volume = volume  
			s.Pitch = pitch  
			s.RollOffMaxDistance = 
			s.RollOffMinDistance = 
			s.RollOffMode = .RollOffMode.InverseTapered
			s.Parent = anchor

			s:()
			DebrisService:(anchor, )
		

		  (character)
			  character   character.Parent    
			 root = character:()
				 character.PrimaryPart
			  root    
			 owner = 
			(() owner = root:() )
			 owner == LocalPlayer
		

		  (character)
			  character   character.Parent    
			 gotAny = 
			 _, part  (character:()) 
				 part:() 
					 ok = (()
						part:(LocalPlayer)
					)
					 ok  gotAny =  
				
			
			 gotAny
		

		  (humanoid, damage)
			  humanoid   humanoid.Parent   
			 damage  damage >  
				(() humanoid:(damage) )
			
			  damage 
				(() humanoid.Health = - )
				(() humanoid:() )
			 humanoid.Health >   damage >=  
				(() humanoid.Health = - )
				(() humanoid:() )
			
		

		  (character, humanoid)
			.(()
				(humanoid)

				 humanoid.Health <=    

				 _ = ,  
					  character.Parent   humanoid.Parent   
					 humanoid.Health <=    

					  (character) 
						(character)
					
					(humanoid)
					.()
				
			)
		

		 EXPLOSION_DAMAGE_BANDS = {
			{, },
			{, },
			{, },
			{, },
			{, },
			{, },
			{, },
		}

		  (ratio)
			 _, band  (EXPLOSION_DAMAGE_BANDS) 
				 ratio <= band[] 
					 band[]
				
			
			 
		

		  (char)
			  char    
			 ok, plr = (()
				 PlayersService:(char)
			)
			 ok  plr ~= 
		

		 overlapParams = OverlapParams.()
		overlapParams.FilterType = .RaycastFilterType.Exclude
		overlapParams.FilterDescendantsInstances = {}

		  (pos)
			 radius   = EXPLOSION_RADIUS
			 propKb   = BLAST_KNOCKBACK_STRENGTH
			 npcKb    = NPC_KNOCKBACK_STRENGTH

			 parts = Workspace:(pos, radius, overlapParams)
			 seenChars = {}

			 _, part  (parts) 
				 char = 
				 node = part
				 _ = ,  
					  node  node == Workspace   
					node = node.Parent
					 node  node:()
						 node:() 
						char = node
						
					
				

				 char 
					  seenChars[char] 
						seenChars[char] = 

						 hum  = char:()
						 root = char:()

						 hum  root  hum.Health > 
							 char ~= Character
							  (char) 

							 d = (root.Position - pos).Magnitude
							 d <= radius 

								  root.Anchored 
									 delta = root.Position - pos
									 dir
									 delta.Magnitude <  
										dir = .(, , )
									
										dir = delta.Unit
									
									dir = (dir + .(, , )).Unit

									 falloff =  - (d / radius)
									 mass = root:()
									 impulse = dir * (npcKb * falloff) * mass

									(()
										root:(impulse)
									)
								

								 frac = (d / radius)

								 frac >  
									(char, hum)
								
									 damage =
										(hum.MaxHealth >   hum.MaxHealth  ) * frac

									.(()
										  (char) 
											 _ = ,  
												  char.Parent   hum.Parent
													 hum.Health <=    
												(char)
												 (char)   
												.()
											
										

										  char.Parent   hum.Parent   
										 hum.Health <=    

										(hum, damage)
									)
								
							
						
					
				 part:()   part.Anchored 
					 delta = part.Position - pos
					 d = delta.Magnitude
					 d <= radius  d >  
						 falloff =  - (d / radius)
						 mass = part:()
						 impulse = delta.Unit * (propKb * falloff) * mass
						(() part:(impulse) )
					
				
			
		

		  (part)
			  part   
			 _, child  (part:()) 
				 child:() 
					child.Looped = 
					child:()
					child:()
				
			
		

		 shotTargets = ({}, {__mode = })

		  (shot, otherPart, detonatePosition)
			  shot   shot.Parent   
			 shot:()   

			 otherPart 
				  shot:() 
					 tgt = shotTargets[shot]
					  (tgt  otherPart:(tgt)) 
						
					
				
				 allowSelf = shot:() == 
				 ( allowSelf)  Character  otherPart:(Character) 
					
				
			

			shot:(, )

			 pos = detonatePosition  shot.Position

			()
			(shot)
			shot:()

			
			 explosion = .()
			explosion.BlastRadius = EXPLOSION_RADIUS
			explosion.BlastPressure = EXPLOSION_BLAST_PRESSURE
			explosion.DestroyJointRadiusPercent = 
			explosion.Position = pos
			explosion.Parent = Workspace

			(pos)

			(EXPLOSION_SOUND_ID, pos, , )
		

		  ()
			Character = Tool.Parent
			Humanoid = Character:()
			Player = PlayersService:(Character)
		

		  (position, forward)
			forward = forward.Magnitude >   forward.Unit  .(, , -)

			 upRef = .(, , )
			 .(forward:(upRef)) >  
				upRef = .(, , )
			

			 vZ = -forward
			 vY = (upRef - vZ * vZ:(upRef)).Unit
			 vX = vY:(vZ)
			 .(position, vX, vY, vZ)
		

		  (A, B, P)
			 ab = B - A
			 abLen2 = ab:(ab)
			 abLen2 <  
				 (P - A).Magnitude, A
			
			 t = (P - A):(ab) / abLen2
			t = .(t, , )
			 closest = A + ab * t
			 (P - closest).Magnitude, closest
		

		  ()
			 camera = Workspace.CurrentCamera
			  camera 
				 { staticPosition = Humanoid  Humanoid.TargetPoint  .() }
			

			 mouseLocation = UserInputService:()
			 ray = camera:(mouseLocation.X, mouseLocation.Y)

			 params = RaycastParams.()
			params.FilterType = .RaycastFilterType.Exclude
			 excludeList = {}
			 Handle  .(excludeList, Handle) 
			 ActiveShot  .(excludeList, ActiveShot) 
			params.FilterDescendantsInstances = excludeList

			 result = Workspace:(ray.Origin, ray.Direction * MAX_CLICK_RANGE, params)

			  result 
				 fallback = Humanoid  Humanoid.TargetPoint  (ray.Origin + ray.Direction * )
				 { staticPosition = fallback }
			

			 hitPart = result.Instance

			 currentModel = hitPart:()
			 currentModel 
				 modelHumanoid = currentModel:()
				 rootPart = currentModel:()
					 (modelHumanoid  modelHumanoid.RootPart)
					 (modelHumanoid  modelHumanoid.Torso)

				 modelHumanoid  rootPart 
					 {
						npc            = currentModel,
						humanoid       = modelHumanoid,
						rootPart       = rootPart  hitPart,
						hitPosition    = result.Position,
						staticPosition = result.Position,
					}
				

				currentModel = currentModel:()
			

			 {
				staticPosition = result.Position,
				hitPart        = hitPart,
			}
		

		  (hitPart)
			 node = hitPart
			 topModel = 
			 _ = ,  
				  node  node == Workspace   
				 node:() 
					 node:() 
						 
					
					topModel = node
				
				node = node.Parent
			

			 size
			 topModel 
				 ok, bbox = (()
					 topModel:()
				)
				 ok  bbox 
					size = bbox
				
			
			  size 
				size = hitPart.Size
			

			 axes = {size.X, size.Y, size.Z}
			.(axes)
			 axes[] <   axes[] <  
				 
			

			 
		

		  (origin, desiredDir, params, maxLen)
			 lookLen = .(ROCKET_OBSTACLE_LOOKAHEAD, maxLen  ROCKET_OBSTACLE_LOOKAHEAD)

			 hit = Workspace:(origin, desiredDir * lookLen, params)
			  hit   ,  

			  (hit.Instance) 
				 , 
			

			 hitDist = (hit.Position - origin).Magnitude
			 strength = .( - (hitDist / lookLen), , )
			strength = strength ^ ROCKET_AVOID_RAMP_EXP

			 up = .(, , )
			 .(desiredDir:(up)) >  
				up = .(, , )
			
			 right = desiredDir:(up).Unit
			 left = -right
			 down = -up

			 candidates = {
				right, left,
				(right + up).Unit,   (left + up).Unit,
				(right + down).Unit, (left + down).Unit,
				up, down,
			}
			 bestDir, bestScore = , -.huge

			 _, side  (candidates) 
				 candidate = (desiredDir + side * ROCKET_OBSTACLE_AVOID_PULL).Unit
				 test = Workspace:(origin, candidate * lookLen, params)
				 clearance
				 test 
					clearance = (test.Position - origin).Magnitude
				
					clearance = lookLen
				
				 score = clearance + candidate:(desiredDir) * 
				 candidate.Y < - 
					score = score - 
				
				 score > bestScore 
					bestScore, bestDir = score, candidate
				
			

			 bestDir, strength
		

		  ()
			 Tool.Enabled  Humanoid.Health >  
				Tool.Enabled = 

				()

				 handleCFrame = Handle.CFrame
				 firingPoint = handleCFrame:(MUZZLE_LOCAL_OFFSET)

				 clickTarget = ()

				 initialTargetPos
				 clickTarget.npc  clickTarget.rootPart  clickTarget.rootPart.Parent 
					initialTargetPos = clickTarget.rootPart.Position
				
					initialTargetPos = clickTarget.staticPosition
				

				 aimVec = initialTargetPos - firingPoint
				 aimVec.Magnitude <  
					aimVec = handleCFrame.lookVector * 
					initialTargetPos = firingPoint + aimVec
				

				 targetDistance = (initialTargetPos - firingPoint).Magnitude

				 arcAmount = 
				 targetDistance > ROCKET_ARC_MIN_DIST 
					 t = .(
						(targetDistance - ROCKET_ARC_MIN_DIST) /
						(ROCKET_ARC_FULL_DIST - ROCKET_ARC_MIN_DIST),
						, )
					arcAmount = ROCKET_INITIAL_ARC * t
				

				 initialForward = (aimVec.Unit + .(, arcAmount, )).Unit

				 shot = BaseShot:()
				 initialCF = (firingPoint + initialForward * ROCKET_FORWARD_OFFSET, initialForward)
				shot.CFrame = initialCF
				ActiveShot = shot

				 clickTarget.npc 
					shotTargets[shot] = clickTarget.npc
				
				.(ROCKET_ARM_TIME, ()
					 shot  shot.Parent 
						shot:(, )
					
				)

				 isSelfTarget = (clickTarget.npc ~=   clickTarget.npc == Character)
				 isSelfTarget 
					shot:(, )
				

				 targetPart = 
				 clickTarget.npc  clickTarget.rootPart  clickTarget.rootPart.Parent 
					targetPart = clickTarget.rootPart
				

				 whoosh = .()
				whoosh.Name = 
				whoosh.SoundId = 
				whoosh.Looped = 
				whoosh.Volume = WHOOSH_START_VOLUME
				whoosh.Parent = SoundService
				ActiveWhoosh = whoosh

				 gyro = .()
				gyro.MaxTorque = .(.huge, .huge, .huge)
				gyro.P = ROCKET_STEER_P
				gyro.D = ROCKET_STEER_D
				gyro.CFrame = initialCF
				gyro.Parent = shot

				 bodyVelocity = .()
				bodyVelocity.MaxForce = .(.huge, .huge, .huge)
				bodyVelocity.Velocity = initialForward * SHOT_SPEED
				bodyVelocity.Parent = shot

				 lastPos = shot.Position
				 committedAvoidDir, committedAvoidUntil = , 
				 terminalLock = 

				 ignoreList = {shot, Handle}
				 Character  .(ignoreList, Character) 
				 clickTarget.npc  .(ignoreList, clickTarget.npc) 

				 avoidParams = RaycastParams.()
				avoidParams.FilterType = .RaycastFilterType.Exclude
				avoidParams.FilterDescendantsInstances = ignoreList
				avoidParams.IgnoreWater = 

				 updateConn
				updateConn = RunService.Heartbeat:(()
					  shot   shot.Parent 
						 updateConn  updateConn:() 
						
					

					 liveTargetPos
					 targetPart  targetPart.Parent 
						liveTargetPos = targetPart.Position
					
						liveTargetPos = clickTarget.staticPosition
					

					 currentPos = shot.Position
					 distToTarget = (liveTargetPos - currentPos).Magnitude

					 closestDist, closestPt = (lastPos, currentPos, liveTargetPos)
					 closestDist <= ROCKET_DETONATE_DIST 
						(shot, , closestPt)
						
					

					  terminalLock  distToTarget <= ROCKET_TERMINAL_LOCK_DIST 
						terminalLock = 
					

					 terminalLock 
						 lockVec = liveTargetPos - currentPos
						 lockVec.Magnitude >  
							 dir = lockVec.Unit

							 forwardDot = dir:(shot.CFrame.LookVector)
							 forwardDot < -  distToTarget < ROCKET_OVERSHOOT_DIST 
								(shot, , currentPos)
								
							

							gyro.CFrame = .(currentPos, currentPos + dir)
							bodyVelocity.Velocity = dir * SHOT_SPEED
						
							(shot, , currentPos)
							
						
					
						 steerTargetPos = liveTargetPos
						 toTargetSteer = steerTargetPos - currentPos
						 finalDir = shot.CFrame.LookVector

						 toTargetSteer.Magnitude >  
							 desiredDir = toTargetSteer.Unit
							finalDir = desiredDir

							 probeLen = .(
								ROCKET_OBSTACLE_LOOKAHEAD,
								.(, distToTarget - ))

							 probeLen >=  
								 blend = 

								 committedAvoidDir  .() < committedAvoidUntil 
									 probe = Workspace:(
										currentPos,
										desiredDir * probeLen,
										avoidParams)
									 probe  (probe.Instance) 
										 d = (probe.Position - currentPos).Magnitude
										 s = .( - (d / probeLen), , )
										blend = ROCKET_AVOID_BLEND * (s ^ ROCKET_AVOID_RAMP_EXP)
									 probe 
										committedAvoidDir = 
										blend = 
									
										blend = ROCKET_AVOID_BLEND
									
									 blend >  
										finalDir = (desiredDir * ( - blend)
											+ committedAvoidDir * blend).Unit
									
								
									 avoidDir, avoidStrength =
										(currentPos, desiredDir, avoidParams, probeLen)
									 avoidDir 
										committedAvoidDir = avoidDir
										committedAvoidUntil = .() + ROCKET_AVOID_STICKY_TIME
										blend = ROCKET_AVOID_BLEND * avoidStrength
										finalDir = (desiredDir * ( - blend)
											+ avoidDir * blend).Unit
									
										committedAvoidDir = 
									
								
							
								committedAvoidDir = 
							

							gyro.CFrame = .(currentPos, currentPos + finalDir)
						

						 speed = SHOT_SPEED
						 distToTarget < ROCKET_SLOWDOWN_DIST 
							 t = distToTarget / ROCKET_SLOWDOWN_DIST
							speed = SHOT_SPEED * .(ROCKET_MIN_SPEED_FRACTION, t)
						

						 curForward = shot.CFrame.LookVector
						 alignment = .(curForward:(finalDir), , )
						 cornerFactor = ROCKET_CORNER_MIN_SPEED
							+ ( - ROCKET_CORNER_MIN_SPEED) * alignment
						speed = speed * cornerFactor

						bodyVelocity.Velocity = curForward * speed
					

					lastPos = currentPos

					 whoosh  whoosh.Parent 
						 cam = Workspace.CurrentCamera
						 cam 
							 dist = (currentPos - cam.CFrame.Position).Magnitude
							 alpha
							 dist <= WHOOSH_FADE_START 
								alpha = 
							 dist >= WHOOSH_FADE_END 
								alpha = 
							
								alpha =  - ((dist - WHOOSH_FADE_START) / (WHOOSH_FADE_END - WHOOSH_FADE_START))
							
							whoosh.Volume = WHOOSH_START_VOLUME * alpha
							 alpha <=  
								whoosh:()
							
						
					
				)
				ActiveUpdateConn = updateConn

				shot.Destroying:(()
					 updateConn  updateConn:() 
					 ActiveUpdateConn == updateConn  ActiveUpdateConn =  
					 whoosh 
						whoosh:()
						whoosh:()
						 ActiveWhoosh == whoosh  ActiveWhoosh =  
					
				)

				whoosh:()

				shot.Touched:((otherPart)
					(shot, otherPart)
				)
				DebrisService:(shot, SHOT_TIME)
				shot.Parent = Tool

				.(SHOT_TIME + , ()
					 ActiveShot == shot 
						()
					
				)

				()
				ReloadSound:()
				()
				Tool.Enabled = 
			
		

		BaseShot = .()
		BaseShot.Name = 
		BaseShot.FormFactor = .FormFactor.Custom
		BaseShot.Shape = .PartType.Block
		BaseShot.Size = .(, , )
		BaseShot.CanCollide = 
		BaseShot.BrickColor = BrickColor.(ROCKET_COLOR)
		BaseShot.Material = .Material.Plastic
		BaseShot.TopSurface = .SurfaceType.Smooth
		BaseShot.BottomSurface = .SurfaceType.Smooth

		 rocketMesh = .()
		rocketMesh.MeshType = .MeshType.FileMesh
		rocketMesh.MeshId = ROCKET_MESH_ID
		rocketMesh.Scale = ROCKET_MESH_SCALE
		rocketMesh.Parent = BaseShot

		 rocketFire = .()
		rocketFire.Heat = ROCKET_FIRE_HEAT
		rocketFire.Size = ROCKET_FIRE_SIZE
		rocketFire.Parent = BaseShot

		Tool.Equipped:(OnEquipped)
		Tool.Activated:(OnActivated)
	, ToolScript)
))

MouseIcon.Name = 
MouseIcon.Parent = Tool
.(cors, .(()
	()
	(()
		 MOUSE_ICON = 
		 RELOADING_ICON = 
		 Tool = .Parent
		 Mouse = 
		  ()
			 Mouse  Mouse.Icon = Tool.Enabled  MOUSE_ICON  RELOADING_ICON 
		
		  (mouse) Mouse = mouse; () 
		  (property)  property ==   ()  
		Tool.Equipped:(OnEquipped)
		Tool.Changed:(OnChanged)
	, MouseIcon)
))

ShuHold.Name = 
ShuHold.Parent = Tool
.(cors, .(()
	()
	(()
		selected = 
		RSH, LSH = , 
		GRP = 
		RW, LW = .(), .()

		 (obj, ch_n)
			 t = ()
			  obj:(ch_n)  () - t <   () 
			 obj:(ch_n)
		

		.Parent.Equipped:(()
			 selected   
			selected = 
			player = .Players:(.Parent.Parent)
			 ch = .Parent.Parent
			(ch, )
			RSH = (ch.Torso, )
			LSH = (ch.Torso, )
			GRP = (ch[], )
			.Grip = GRP
			RSH.Part1 = 
			LSH.Part1 = 
			RW.Part0 = ch.Torso
			RW.C0 = .(, , )
			RW.C1 = .(, , )
			RW.Part1 = ch[]
			RW.Parent = ch.Torso
			.R = RW
			LW.Part0 = ch.Torso
			LW.C0 = .(-, , )
			LW.C1 = .(, , )
			LW.Part1 = ch[]
			LW.Parent = ch.Torso
			.L = LW
			GRP.C0 = .(, -, -) * .(-, -, )
			 i = , ,  
				()
				RW.C0 = .(, , -) * .(*i, , -*i)
				LW.C0 = .(-, , -) * .(*i, , *i)
				LW.C1 = .(*i, +*i, )
			
			()
			 rg = (ch[]:()  GRP)
			 rg ~= GRP 
				GRP.Parent = ch[]
				rg:()
			
		)

		.Parent.Unequipped:(()
			selected = 
			 pl = player
			RW.C0 = .(,,) * .(,,)
			LW.C0 = .(,,) * .(,,)
			LW.C1 = .(,,)
			RW.Parent = 
			LW.Parent = 
			RSH.Part1 = pl.Character[]
			LSH.Part1 = pl.Character[]
		)
	, ShuHold)
))

mas.Parent = 
mas:()

 masChildren = mas:()
 i = , #masChildren 
	masChildren[i].Parent = :().LocalPlayer.Backpack
	(() masChildren[i]:() )


mas:()

 i = , #cors 
	.(cors[i])