Kill effects

 .__KillFXCleanup  (.__KillFXCleanup) 

 Players = :()
 TweenService = :()
 Debris = :()
 Lighting = :()
 RunService = :()
 UserInputService = :()
 SoundService = :()

 player = Players.LocalPlayer
 R = .random
 ONE, UP = .one, .(, , )

 state = {
	selected = ,
	mode = , 
	sound = ,
	quality = , 
	kills = ,
}
 MODES = { , ,  }
 RANGE = 

 conns, gui = {}, 
  (sig, fn)
	 c = sig:(fn)
	.(conns, c)
	 c

.__KillFXCleanup = ()
	 _, c  (conns)  (() c:() ) 
	 gui  gui:() 


  ()  .CurrentCamera 




 SND = {
	boom = ,
	bass = ,
	ping = ,
	snap = ,
	glass = ,
}
 TEX_SPARK = 
 TEX_FIRE = 
 TEX_SMOKE = 




  (obj, t, props, style, dir)
	 tw = TweenService:(obj, TweenInfo.(t, style  .EasingStyle.Quad, dir  .EasingDirection.Out), props)
	tw:()
	 tw


  (shape, size, color, cf, transparency, material, life)
	 p = .()
	p.Anchored, p.CanCollide, p.CanQuery, p.CanTouch, p.CastShadow = , , , , 
	p.Shape = shape
	p.Size = size
	p.Color = color
	p.Material = material  .Material.Neon
	p.Transparency = transparency  
	p.CFrame = cf
	p.Parent = 
	Debris:(p, life  )
	 p


  (a, b, c)
	 c 
		 NumberSequence.({ NumberSequenceKeypoint.(, a), NumberSequenceKeypoint.(, b), NumberSequenceKeypoint.(, c) })
	
	 NumberSequence.({ NumberSequenceKeypoint.(, a), NumberSequenceKeypoint.(, b) })



  (pos, cfg, count)
	count = .(, .(count * state.quality))
	 holder = (.PartType.Ball, ONE, .(), .(pos), )
	  (c, n, glowLayer)
		 e = .()
		e.Rate = 
		e.Texture = c.Texture  TEX_SPARK
		e.Color = c.Color  ColorSequence.(.(, , ))
		e.Size = c.Size  (, )
		e.Lifetime = c.Lifetime  NumberRange.(, )
		e.Speed = c.Speed  NumberRange.(, )
		e.SpreadAngle = c.Spread  .(, )
		e.LightEmission = c.LightEmission  
		e.LightInfluence = 
		e.Drag = c.Drag  
		e.Acceleration = c.Acceleration  .zero
		e.RotSpeed = NumberRange.(-, )
		e.Rotation = NumberRange.(, )
		e.Transparency = NumberSequence.({ NumberSequenceKeypoint.(, ), NumberSequenceKeypoint.(, ), NumberSequenceKeypoint.(, ) })
		e.Parent = holder
		e:(n)
	
	(cfg, count, )
	  cfg.NoGlow  count >=  
		({
			Color = cfg.Color, Texture = TEX_SPARK, Size = (, , ), Lifetime = NumberRange.(, ),
			Speed = NumberRange.(, ), Drag = , Spread = cfg.Spread,
		}, .(.(count * ), , ), )
	
	 holder


  (pos, color, size, life)
	(pos, {
		Color = ColorSequence.(color), Speed = NumberRange.(, ), Lifetime = NumberRange.(life, life),
		Size = NumberSequence.({ NumberSequenceKeypoint.(, size * ), NumberSequenceKeypoint.(, size), NumberSequenceKeypoint.(, ) }),
		Drag = , NoGlow = ,
	}, )


  (part, color, life, width)
	 a0, a1 = .(), .()
	a0.Position, a1.Position = .(, width / , ), .(, -width / , )
	a0.Parent, a1.Parent = part, part
	 t = .()
	t.Attachment0, t.Attachment1 = a0, a1
	t.Color = ColorSequence.(color, .(, , ))
	t.Transparency = (, )
	t.WidthScale = (, )
	t.Lifetime = life
	t.LightEmission = 
	t.FaceCamera = 
	t.Parent = part
	 t


  (pos, color, count, material, speed, size)
	count = .(, .(count * state.quality))
	 _ = , count 
		 s = (
			.PartType.Block,
			ONE * (size  ) * ( + () * ),
			color,
			.(pos) * .(() * , () * , () * ),
			,
			material
		)
		 dir = .(() - , () *  + , () - ).Unit
		(s,  + () * , {
			Position = pos + dir * speed * ( + ()) - .(, , ),
			Orientation = .((, ), (, ), (, )),
			Transparency = ,
		})
	


  (pos, color, brightness, range, t)
	 p = (.PartType.Ball, ONE * , color, .(pos), )
	 l = .()
	l.Color, l.Brightness, l.Range = color, brightness, range
	l.Parent = p
	(l, t, { Brightness = , Range =  })


  (pos, color, endSize, t, startTransparency)
	 r = (.PartType.Cylinder, .(, , ), color, .(pos) * .(, , .pi / ), startTransparency  )
	(r, t, { Size = .(, endSize, endSize), Transparency =  })


  (pos, color, endSize, t)
	 s = (.PartType.Ball, ONE * , color, .(pos), , .Material.ForceField)
	(s, t, { Size = ONE * endSize, Transparency =  })


  (pos, color, height, width, t)
	 p = (.PartType.Cylinder, .(, width, width), color, .(pos + UP * height / ) * .(, , .pi / ), )
	(p, , { Size = .(height, width, width) })
	.(, ()
		(p, t, { Size = .(height, , ), Transparency =  })
	)


  (color, t, strength)
	strength = strength  
	 cc = .()
	cc.Brightness, cc.Contrast, cc.TintColor = strength, strength * , color
	cc.Parent = Lighting
	(cc, t, { Brightness = , Contrast = , TintColor = .(, , ) })
	 bl = .()
	bl.Intensity, bl.Size, bl.Threshold = strength * , , 
	bl.Parent = Lighting
	(bl, t * , { Intensity =  })
	Debris:(cc, t + )
	Debris:(bl, t *  + )


  (size, t)
	 b = .()
	b.Size = size
	b.Parent = Lighting
	(b, t, { Size =  })
	Debris:(b, t + )


  (power, duration)
	.(()
		 t0 = .()
		 .() - t0 < duration 
			 char = player.Character
			 hum = char  char:()
			 hum 
				 k =  - (.() - t0) / duration
				hum.CameraOffset = .((() - ) * power * k, (() - ) * power * k, )
			
			RunService.RenderStepped:()
		
		 char = player.Character
		 hum = char  char:()
		 hum  hum.CameraOffset = .zero 
	)


 punching, baseFov = , 
  (amount, t)
	 c = ()
	  c   
	 punching ==   baseFov = c.FieldOfView 
	punching += 
	c.FieldOfView = baseFov + amount
	 tw = (c, t, { FieldOfView = baseFov }, .EasingStyle.Quart)
	tw.Completed:(() punching -=  )





  (s, fx)
	  (class, props)
		 e = .(class)
		 k, v  (props)  e[k] = v 
		e.Parent = s
	
	 fx ==  
		(, { DecayTime = , Density = , Diffusion = , DryLevel = , WetLevel = - })
		(, { LowGain = , MidGain = -, HighGain = - })
		(, { Level =  })
	 fx ==  
		(, { LowGain = , MidGain = -, HighGain = - })
		(, { DecayTime = , Density = , Diffusion = , DryLevel = , WetLevel = - })
	 fx ==  
		(, { LowGain = -, MidGain = , HighGain =  })
		(, { DecayTime = , Density = , Diffusion = , DryLevel = , WetLevel = - })
	 fx ==  
		(, { LowGain = -, MidGain = -, HighGain =  })
		(, { DecayTime = , Density = , Diffusion = , DryLevel = -, WetLevel =  })
	


  (id, vol, pitch, fx, )
	  state.sound   
	  ()
		 s = .()
		s.SoundId, s.Volume, s.PlaybackSpeed = id, vol  , pitch  
		(s, fx)
		s.Parent = SoundService
		s:()
		Debris:(s, )
	
	    >   .(, go)  () 


  (power, )
	power = power  
	(SND.boom,  * power, , , )
	(SND.bass,  * power, , , )
	(SND.boom,  * power, , , (  ) + )
	(SND.snap,  * power, , , )


  (pitch)
	(SND.ping, ,  * (pitch  ), )
	(SND.snap, ,  * (pitch  ), )
	(SND.bass, , , )


  (vol)
	(SND.ping, vol  , , )
	(SND.ping, (vol  ) * , , , )
	(SND.ping, (vol  ) * , , , )


  (dur, p0, p1, vol)
	  state.sound   
	vol = vol  
	 s = .()
	s.SoundId, s.Looped, s.Volume, s.PlaybackSpeed = SND.ping, , vol, p0
	(s, )
	s.Parent = SoundService
	s:()
	(s, dur, { PlaybackSpeed = p1, Volume = vol *  }, .EasingStyle.Quad, .EasingDirection.In)
	.(dur, () s:() s:() )





  (char)
	 list = {}
	 char 
		 _, d  (char:()) 
			 d:()  .(list, d) 
		
	
	 list


  (inst)
	 inst:()  inst:()  inst:()  inst.Transparency =  
	 _, d  (inst:()) 
		 d:()  d:()  d:()  d.Transparency =  
	


  (char)
	 char  (char) 


  (char)
	 _, p  ((char)) 
		p.Anchored = 
		p.CanCollide = 
	


  (char, pos, force, dur, spin)
	 _, p  ((char)) 
		p.Anchored, p.CanCollide = , 
		 away = p.Position - pos
		away = (away.Magnitude < )  UP  away.Unit
		away = (away + .((() - ) * , , (() - ) * )).Unit
		(p, dur, {
			 = p.CFrame * .(() * spin, () * spin, () * spin) + away * force * ( + () * ),
			Transparency = ,
		})
	


  (pos, text, color, size)
	 a = (.PartType.Ball, ONE * , color, .(pos + .(, , )), , , )
	 bb = .()
	bb.Size, bb.AlwaysOnTop, bb.Adornee = .(, ), , a
	bb.Parent = a
	 l = .()
	l.Size, l.BackgroundTransparency = .(, ), 
	l.Text, l.Font, l.TextSize, l.TextColor3 = text, .Font.GothamBlack, size  , color
	l.Parent = bb
	 st = .()
	st.Thickness, st.Color = , .(, , )
	st.Parent = l
	(a, , { Position = a.Position + .(, , ) })
	.(, ()
		(l, , { TextTransparency =  })
		(st, , { Transparency =  })
	)





 EFFECTS = {}
  (name, color, fn)
	.(EFFECTS, { name = name, color = color, fn = fn })



(, .(, , ), (char, pos)
	 orange, yellow = .(, , ), .(, , )
	()
	(.(, , ), , )
	(, )
	(, )
	(, )
	(pos, orange, , , )
	(pos, yellow, , )
	(pos, orange, , )
	(pos, yellow, , )
	(pos, orange, , , )

	 core = (.PartType.Ball, ONE * , .(, , ), .(pos), )
	(core, , { Size = ONE * , Transparency =  })
	 fire = (.PartType.Ball, ONE * , orange, .(pos), )
	(fire, , { Size = ONE * , Transparency =  })

	 i = ,  
		.((i - ) * , ()
			(pos, i ==   yellow  orange,  + i * , )
		)
	

	
	 stem = (.PartType.Cylinder, .(, , ), orange, .(pos) * .(, , .pi / ), )
	(stem, , { Size = .(, , ),  = .(pos + UP * ) * .(, , .pi / ) })
	 disc = (.PartType.Cylinder, .(, , ), yellow, .(pos) * .(, , .pi / ), )
	(disc, , { Size = .(, , ),  = .(pos + UP * ) * .(, , .pi / ) })
	 capBall = (.PartType.Ball, ONE * , orange, .(pos), )
	(capBall, , { Size = ONE * , Position = pos + UP *  })
	.(, ()
		(stem, , { Transparency =  })
		(disc, , { Transparency =  })
		(capBall, , { Transparency =  })
	)

	(pos, { Color = ColorSequence.(yellow, orange), Speed = NumberRange.(, ), Texture = TEX_FIRE, Size = (, ), Lifetime = NumberRange.(, ), Acceleration = .(, , ) }, )
	(pos, { Color = ColorSequence.(.(, , )), Texture = TEX_SMOKE, LightEmission = , Speed = NumberRange.(, ), Lifetime = NumberRange.(, ), Size = (, ), Acceleration = .(, , ), NoGlow =  }, )
	(pos, { Color = ColorSequence.(yellow), Speed = NumberRange.(, ), Acceleration = .(, -, ) }, )
	(pos, orange, , .Material.Neon, , )
	(char, pos, , , )
)


  (a, b, thick, color, tr, depth)
	 segs = 
	 prev = a
	 dir = b - a
	 i = , segs 
		 target
		 i == segs 
			target = b
		
			target = a + dir * (i / segs) + .((() - ) * , (() - ) * , (() - ) * )
		
		 dist = (target - prev).Magnitude
		 dist >  
			 seg = (.PartType.Block, .(thick, thick, dist), color, .(prev, target) * .(, , -dist / ), tr)
			(seg, , { Transparency = , Size = .(thick * , thick * , dist) })
			 depth <   i >   i < segs -   () <  
				(target, target + .((() - ) * , -( + () * ), (() - ) * ), thick * , color, tr, depth + )
			
		
		prev = target
	


(, .(, , ), (char, pos)
	 blue, white = .(, , ), .(, , )
	(char)
	 strike = ,  
		 top = pos + .((() - ) * , , (() - ) * )
		(top, pos, , blue, , )
		(top, pos, , white, , )
		( + strike * )
		(.(, , ), , )
		(, )
		(, )
		(pos, blue, , , )
		(pos, white, , )
		(pos, { Color = ColorSequence.(white, blue), Speed = NumberRange.(, ) }, )
		 _ = ,  
			 _, p  ((char)) 
				p.Material = .Material.Neon
				p.Color = (() < )  white  blue
			
			.()
		
		.()
	
	 _, p  ((char)) 
		p.Material = .Material.SmoothPlastic
		p.Color = .(, , )
	
	()
	(pos, blue, , )
	(, )
	(pos, white, , )
	(pos, blue, , )
	(pos, { Color = ColorSequence.(white, blue), Speed = NumberRange.(, ) }, )
	(char, pos, , , )
)


(, .(, , ), (char, pos)
	 ice, deep = .(, , ), .(, , )
	(char)
	 _, p  ((char)) 
		p.Material = .Material.Ice
		p.Color = ice
	
	(SND.snap, , , )
	(SND.glass, , , )
	(.(, , ), , )
	(pos, ice, , )
	(pos, { Color = ColorSequence.(.(, , ), ice), Speed = NumberRange.(, ), Lifetime = NumberRange.(, ) }, )

	 spikes = {}
	 i = ,  
		 ang = i /  * .pi *  + () * 
		 r =  + () * 
		 base = pos + .(.(ang) * r, -, .(ang) * r)
		 h =  + () * 
		 sp = (.PartType.Block, .(, , ), (() < )  ice  deep, .(base) * .((() - ) * , () * , (() - ) * ), , .Material.Glass)
		(sp,  + () * , { Size = .(, h, ),  = sp.CFrame * .(, h / , ) })
		.(spikes, sp)
	
	.()

	()
	(SND.glass, , , )
	(SND.glass, , , , )
	(char)
	 _, sp  (spikes)  (sp, , { Transparency =  }) 
	(pos, ice, , .Material.Ice, , )
	(pos, .(, , ), , .Material.Glass, , )
	(pos, ice, , )
	(pos, ice, , )
	(pos + .(, -, ), deep, , )
	(pos, { Color = ColorSequence.(.(, , )), Speed = NumberRange.(, ), Acceleration = .(, -, ), Lifetime = NumberRange.(, ) }, )
	(pos, ice, , , )
	(.(, , ), , )
	(, )
	(, )
)


(, .(, , ), (char, pos)
	 parts = (char)
	(char)
	(SND.bass, , , )
	(SND.snap, , , , )
	 wind = .(, , () *  - )
	 _, p  (parts) 
		 p.Transparency <  
			 vol = p.Size.X * p.Size.Y * p.Size.Z
			 n = .(.(vol *  * state.quality), , )
			 col = p.Color
			 _ = , n 
				 off = .((() - ) * p.Size.X, (() - ) * p.Size.Y, (() - ) * p.Size.Z)
				 at = p.CFrame:(off)
				 c = (.PartType.Block, ONE * ( + () * ), col, .(at) * .(() * , () * , () * ), , .Material.SmoothPlastic, )
				 height = .((at.Y - pos.Y + ) / , , )
				  = ( - height) *  + () * 
				.(, ()
					(c,  + () * , {
						Position = at + wind * ( + () * ) + .(, () * , (() - ) * ),
						Orientation = .((, ), (, ), (, )),
						Size = ONE * ,
						Transparency = ,
						Color = .(, , ),
					}, .EasingStyle.Sine, .EasingDirection.In)
					 () <  
						(at, { Color = ColorSequence.(.(, , )), Texture = TEX_SMOKE, LightEmission = , Speed = NumberRange.(, ), Lifetime = NumberRange.(, ), Acceleration = wind * , Size = (, ), NoGlow =  }, )
					
				)
			
		
	
	(char)
	(pos, { Color = ColorSequence.(.(, , )), Speed = NumberRange.(, ), Lifetime = NumberRange.(, ), Acceleration = wind *  }, )
	(.(, , ), , )
)


(, .(, , ), (char, pos)
	 purple, orange = .(, , ), .(, , )
	 center = pos + UP
	(SND.bass, , , )
	(SND.ping, , , , )
	(.(, , ), , )
	 halo = (.PartType.Ball, ONE, purple, .(center), , .Material.ForceField)
	 hole = (.PartType.Ball, ONE, .(, , ), .(center), , .Material.SmoothPlastic)
	 disc = (.PartType.Cylinder, .(, , ), orange, .(center) * .(, , .pi / ), )
	(halo, , { Size = ONE *  })
	(hole, , { Size = ONE *  })
	(disc, , { Size = .(, , ) })
	(center, purple, , , )
	(center, purple, , )

	 _, p  ((char)) 
		p.Anchored, p.CanCollide = , 
		(p, , {
			 = .(center) * .(() * , () * , () * ),
			Size = p.Size * ,
		}, .EasingStyle.Quad, .EasingDirection.In)
	

	 orbs = {}
	 i = , .( * state.quality) 
		orbs[i] = {
			part = (.PartType.Block, ONE * ( + () * ), (() < )  purple  orange, .(center), ),
			a = () * , r =  + () * , y = (() - ) * , s =  + () * ,
		}
		(orbs[i].part, orbs[i].part.Color, , )
	
	 T, t0 = , .()
	 .() - t0 < T 
		 a = (.() - t0) / T
		 _, o  (orbs) 
			 ang = o.a + a * o.s * 
			 rr = o.r * ( - a) ^ 
			o.part.Position = center + .(.(ang) * rr, o.y * ( - a), .(ang) * rr)
		
		RunService.Heartbeat:()
	
	 _, o  (orbs)  o.part:() 

	(char)
	(halo, , { Size = ONE, Transparency =  }, .EasingStyle.Back, .EasingDirection.In)
	(hole, , { Size = ONE *  }, .EasingStyle.Back, .EasingDirection.In)
	(disc, , { Size = .(, , ), Transparency =  })
	.()
	()
	(center, purple, , )
	(, )
	(center, purple, , )
	(center, orange, , )
	(center, .(, , ), , )
	(center, { Color = ColorSequence.(.(, , ), purple), Speed = NumberRange.(, ) }, )
	(center, purple, , .Material.Neon, , )
	(.(, , ), , )
	(, )
	(, )
)


(, .(, , ), (char, pos)
	 cyan, white = .(, , ), .(, , )
	(SND.ping, , , )
	(SND.bass, , , )
	 _, p  ((char)) 
		p.Anchored, p.CanCollide = , 
		(p, , { Color = white, Transparency = , Position = p.Position + .(, , ) })
	
	(pos, { Color = ColorSequence.(white, cyan), Speed = NumberRange.(, ), Acceleration = .(, , ), Lifetime = NumberRange.(, ) }, )
	(pos - UP * , cyan, , )
	(pos, cyan, , )

	 soul = (.PartType.Ball, ONE * , white, .(pos + UP), )
	 pl = .()
	pl.Color, pl.Brightness, pl.Range = cyan, , 
	pl.Parent = soul
	 em = .()
	em.Texture, em.Rate = TEX_SPARK,  * state.quality
	em.Color = ColorSequence.(white, cyan)
	em.Size = (, )
	em.Lifetime, em.Speed = NumberRange.(, ), NumberRange.(, )
	em.SpreadAngle, em.LightEmission = .(, ), 
	em.Acceleration = .(, , )
	em.Transparency = (, )
	em.Parent = soul

	 trail = {}
	 i = ,  
		trail[i] = (.PartType.Ball, ONE * .( - i * , ), cyan, .(pos),  + i * )
	
	  (a)
		 ang = a * .pi * 
		 pos + .(.(ang) * a * ,  + a * a * , .(ang) * a * )
	
	 T, t0 = , .()
	 .() - t0 < T 
		 a = (.() - t0) / T
		soul.Position = (a)
		 i, tp  (trail) 
			tp.Position = (.(a - i * , ))
		
		RunService.Heartbeat:()
	
	 top = ()
	em.Enabled = 
	(soul, , { Size = ONE * , Transparency =  })
	 _, tp  (trail)  (tp, , { Transparency =  }) 
	()
	()
	(top, white, , )
	(top, cyan, , )
	(top, { Color = ColorSequence.(white, cyan), Speed = NumberRange.(, ) }, )
	(top, cyan, , )
	(top, cyan, , , )
	(.(, , ), , )
)


(, .(, , ), (char, pos)
	 gold, bright = .(, , ), .(, , )
	(char)
	()
	 _, p  ((char)) 
		p.Material = .Material.Metal
		(p, , { Color = gold })
	
	(pos, gold, , , )
	(pos, bright, , )
	(pos, { Color = ColorSequence.(bright, gold), Speed = NumberRange.(, ) }, )
	(pos - UP * , gold, , )
	(.(, , ), , )
	.()

	(SND.snap, , , )
	(SND.glass, , , )
	()
	(char)
	 coins = .( * state.quality)
	 i = , coins 
		 dir = .(() - , , () - ).Unit
		 coin = (.PartType.Cylinder, .(, , ), gold, .(pos) * .(() * , () * , () * ), , .Material.Metal)
		 peak = pos + dir * ( + () * ) + .(,  + () * , )
		 land = pos + dir * ( + () * ) - .(, , )
		(coin, , {  = .(peak) * .(() * , () * , () * ) })
		.(, ()
			(coin, , {  = .(land) * .(() * , () * , () * ) }, .EasingStyle.Quad, .EasingDirection.In)
			.(, ()
				(coin, , { Transparency =  })
				 i %  ==   (SND.ping, ,  + () * , ) 
			)
		)
	
	(pos, gold, , .Material.Metal, , )
	(pos, { Color = ColorSequence.(bright, gold), Speed = NumberRange.(, ), Acceleration = .(, -, ) }, )
	(pos, gold, , )
	(pos, bright, , )
	(.(, , ), , )
	(, )
	(, )
)


(, .(, , ), (char, pos)
	 cols = { .(, , ), .(, , ), .(, , ) }
	 parts = (char)
	 orig = {}
	 _, p  (parts) 
		p.Anchored, p.CanCollide = , 
		p.Material = .Material.Neon
		orig[p] = p.CFrame
	
	(SND.ping, , , )
	 f = ,  
		 _, p  (parts) 
			p.CFrame = orig[p] + .((() - ) * , (() - ) * , (() - ) * )
			p.Color = cols[(, )]
			p.Transparency = (() < )    
		
		 _ = ,  
			 c = cols[(, )]
			 px = (.PartType.Block, ONE * ( + () * ), c, .(pos + .((() - ) * , (() - ) * , (() - ) * )), )
			(px, , { Transparency =  })
		
		 f %  ==   (SND.snap, ,  + () * , ) 
		 f %  ==   (cols[(, )], , ) 
		.()
	
	 _, p  (parts) 
		p.Transparency = 
		(p, , { Size = .(p.Size.X * , , p.Size.Z * ), Color = cols[] }, .EasingStyle.Quad, .EasingDirection.In)
	
	.()
	(char)
	()
	(SND.ping, , , )
	(pos, cols[], , )
	(pos, { Color = ColorSequence.(cols[], cols[]), Speed = NumberRange.(, ) }, )
	(pos, cols[], , )
	 _ = , .( * state.quality) 
		 top = pos + .((() - ) * ,  + () * , (() - ) * )
		 col = (.PartType.Block, .(,  + () * , ), cols[], .(top), , , )
		.(() * , ()
			(col, , { Position = top - .(, , ), Transparency =  }, .EasingStyle.Sine, .EasingDirection.In)
		)
	
	(, )
)


(, .(, , ), (char, pos)
	 colors = {
		.(, , ), .(, , ), .(, , ),
		.(, , ), .(, , ), .(, , ),
	}
	(SND.snap, , , )
	(SND.boom, , , )
	(char, pos, , , )
	 _, c  (colors) 
		(pos, { Color = ColorSequence.(c), Speed = NumberRange.(, ), Lifetime = NumberRange.(, ), Acceleration = .(, -, ), Drag = , Size = (, ) }, )
	
	(pos, .(, , ), , )
	(pos, .(, , ), , )
	(.(, , ), , )
	(, )

	 i = ,  
		.( + i * , ()
			 c = colors[(, #colors)]
			 c2 = colors[(, #colors)]
			 peak = pos + .((() - ) * ,  + () * , (() - ) * )
			 rocket = (.PartType.Ball, ONE * , c, .(pos), )
			(rocket, c, , )
			(rocket, , { Position = peak }, .EasingStyle.Quad, .EasingDirection.Out)
			.()
			rocket:()
			(SND.boom, ,  + () * , )
			(SND.snap, , , )
			(peak, c, , , )
			(peak, c, , )
			(peak, { Color = ColorSequence.(c, c2), Speed = NumberRange.(, ), Lifetime = NumberRange.(, ), Acceleration = .(, -, ), Size = (, ) }, )
			(peak, c, , )
		)
	
	 _ = , .( * state.quality) 
		 start = pos + .((() - ) * ,  + () * , (() - ) * )
		 rib = (.PartType.Block, .(, , ), colors[(, #colors)], .(start) * .(() * , () * , () * ), , , )
		.(() * , ()
			(rib, , { Position = start - .(, , ) + .((() - ) * , , (() - ) * ), Orientation = .((, ), (, ), (, )) }, .EasingStyle.Sine, .EasingDirection.InOut)
			.(, () (rib, , { Transparency =  }) )
		)
	
)


(, .(, , ), (char, pos)
	 cols = {
		.(, , ), .(, , ), .(, , ),
		.(, , ), .(, , ), .(, , ),
	}
	 gold, white = .(, , ), .(, , )
	  ()  cols[(, #cols)] 

	 head = char:()
	 hpos = (head  head:())  head.Position  (pos + UP * )

	
	 fake
	 ok, cl = (()  head  head:() )
	 ok  cl  cl:() 
		 _, c  (cl:()) 
			  (c:()  c:())  c:() 
		
		cl.Anchored, cl.CanCollide, cl.CanQuery, cl.CanTouch = , , , 
		cl.CFrame = .(hpos)
		cl.Parent = 
		Debris:(cl, )
		fake = cl
	
		fake = (.PartType.Ball, ONE * , gold, .(hpos), , .Material.Neon, )
	

	
	 head  (head) 
	 _, d  (char:()) 
		 d:()  (d) 
	

	
	(char)
	 _, p  ((char)) 
		 p.Transparency <  
			p.Material = .Material.Neon
			p.Color = ()
		
	
	(SND.snap, , , )
	(SND.boom, , , , )
	(hpos, gold, , )
	(hpos - UP, { Color = ColorSequence.(white, gold), Speed = NumberRange.(, ), Acceleration = .(, -, ), Lifetime = NumberRange.(, ) }, )
	(char, pos, , , )

	
	 peak = hpos + .((() - ) * ,  + () * , (() - ) * )
	(, , , )
	(fake, gold, , )
	 em = .()
	em.Texture, em.Rate = TEX_SPARK,  * state.quality
	em.Color = ColorSequence.(white, gold)
	em.Size = (, )
	em.Lifetime, em.Speed = NumberRange.(, ), NumberRange.(, )
	em.SpreadAngle, em.LightEmission, em.LightInfluence = .(, ), , 
	em.EmissionDirection = .NormalId.Bottom
	em.Acceleration = .(, -, )
	em.Transparency = (, )
	em.Parent = fake
	 pl = .()
	pl.Color, pl.Brightness, pl.Range = gold, , 
	pl.Parent = fake
	(fake, , { Position = peak, Orientation = .((, ), (, ), (, )) }, .EasingStyle.Quad, .EasingDirection.Out)
	.()
	fake:()

	
	  (center, a, b, scale)
		( * scale)
		(center, a, , , )
		(center, white,  * scale, )
		(center, a,  * scale, )
		(center, a,  * scale, )
		(center, a,  * scale, )
		 _, c  ({ a, b }) 
			(center, {
				Color = ColorSequence.(white, c), Speed = NumberRange.( * scale,  * scale),
				Lifetime = NumberRange.(, ), Drag = , Acceleration = .(, -, ), Size = (, ),
			}, )
		
		
		 tilt = .(() * , () * , () * )
		 i = , .( * state.quality) 
			 ang = i /  * .pi * 
			 dir = tilt:(.(.(ang), , .(ang)))
			 sp = (.PartType.Ball, ONE * , b, .(center), )
			(sp, b, , )
			(sp, , { Position = center + dir *  * scale - .(, , ), Transparency =  }, .EasingStyle.Sine, .EasingDirection.Out)
		
		
		(center, {
			Color = ColorSequence.(gold), Speed = NumberRange.(, ), Lifetime = NumberRange.(, ),
			Drag = , Acceleration = .(, -, ), Size = (, ),
		}, )
		
		(center, { Color = ColorSequence.(.(, , )), Texture = TEX_SMOKE, LightEmission = , Speed = NumberRange.(, ), Lifetime = NumberRange.(, ), Size = (, ), NoGlow =  }, )
		
		 _ = ,  
			.( + () * , ()
				 at = center + .((() - ) * , (() - ) *  - , (() - ) * ) * scale
				(at, { Color = ColorSequence.(white), Speed = NumberRange.(, ), Lifetime = NumberRange.(, ), Size = (, ) }, )
				(SND.snap, ,  + () * , )
			)
		
	

	(peak, (), (), )
	(.(, , ), , )
	(, )
	(, )
	(, )
	(peak, , gold, )
	.(, () (peak + .(, -, ), (), (), ) )
	.(, () (peak + .(-, -, -), (), (), ) )
)


(, .(, , ), (char, pos)
	 fire, lava = .(, , ), .(, , )
	 dark = .(, , )
	 start = pos + .(, , -)
	 rock = (.PartType.Ball, ONE * , dark, .(start), , .Material.Basalt, )
	(rock, fire, , )
	 pl = .()
	pl.Color, pl.Brightness, pl.Range = fire, , 
	pl.Parent = rock
	 em = .()
	em.Texture, em.Rate = TEX_FIRE,  * state.quality
	em.Color = ColorSequence.(.(, , ), lava)
	em.Size = (, )
	em.Lifetime, em.Speed = NumberRange.(, ), NumberRange.(, )
	em.SpreadAngle, em.LightEmission, em.LightInfluence = .(, ), , 
	em.Transparency = (, )
	em.Parent = rock
	(SND.bass, , , )
	(, , , )
	(rock, , { Position = pos }, .EasingStyle.Quad, .EasingDirection.In)
	.()
	rock:()

	()
	(.(, , ), , )
	(, )
	(, )
	(, )
	(pos, fire, , , )
	(pos, .(, , ), , )
	(pos, fire, , )
	(pos, fire, , )
	(pos, lava, , )
	(pos, lava, , , )
	 i = ,  
		.((i - ) * , () (pos - UP * , i ==   fire  lava,  + i * , ) )
	
	
	 scorch = (.PartType.Cylinder, .(, , ), .(, , ), .(pos - UP * ) * .(, , .pi / ), , .Material.SmoothPlastic, )
	(scorch, , { Size = .(, , ) })
	.(, () (scorch, , { Transparency =  }) )

	(pos, { Color = ColorSequence.(.(, , ), lava), Texture = TEX_FIRE, Speed = NumberRange.(, ), Size = (, ), Lifetime = NumberRange.(, ), Acceleration = .(, , ) }, )
	(pos, { Color = ColorSequence.(.(, , )), Texture = TEX_SMOKE, LightEmission = , Speed = NumberRange.(, ), Lifetime = NumberRange.(, ), Size = (, ), Acceleration = .(, , ), NoGlow =  }, )
	(pos, { Color = ColorSequence.(fire), Speed = NumberRange.(, ), Acceleration = .(, -, ), Lifetime = NumberRange.(, ) }, )
	(pos, dark, , .Material.Basalt, , )
	(pos, lava, , .Material.Neon, , )
	(char, pos, , , )
)


(, .(, , ), (char, pos)
	 cy, wh = .(, , ), .(, , )
	(char)
	(SND.ping, , , )
	(SND.bass, , , )
	 _, p  ((char)) 
		p.Material = .Material.Neon
		(p, , { Color = cy })
	
	(pos, cy, , )
	(pos, { Color = ColorSequence.(wh, cy), Speed = NumberRange.(, ), Lifetime = NumberRange.(, ) }, )
	.()

	 mid = .(pos + UP * ) * .(, , .pi / )
	 beam = (.PartType.Cylinder, .(, , ), wh, mid, )
	 outer = (.PartType.Cylinder, .(, , ), cy, mid, )
	()
	()
	(.(, , ), , )
	(, )
	(, )
	(, )
	(pos, cy, , , )
	(pos, wh, , )
	(pos, cy, , )
	(pos - UP * , cy, , )
	(pos - UP * , wh, , )

	 _, p  ((char)) 
		(p, , { Color = wh, Size = p.Size * , Position = p.Position + UP * , Transparency =  }, .EasingStyle.Quad, .EasingDirection.In)
	
	(pos, { Color = ColorSequence.(wh, cy), Speed = NumberRange.(, ), Spread = .(, ), Lifetime = NumberRange.(, ), Acceleration = .(, , ) }, )
	(pos, { Color = ColorSequence.(wh, cy), Speed = NumberRange.(, ) }, )
	 _ = ,  
		(pos + UP * , pos + .((() - ) * , -, (() - ) * ), , cy, , )
	
	.(, ()
		(beam, , { Size = .(, , ), Transparency =  })
		(outer, , { Size = .(, , ), Transparency =  })
	)
)


(, .(, , ), (char, pos)
	 gold, white = .(, , ), .(, , )
	(char)
	()
	(SND.bass, , , )
	(pos - UP * , white, , , )
	(pos, gold, , )
	(pos, gold, , , )
	(.(, , ), , )
	(pos - UP * , gold, , )
	(pos, gold, , )

	 _, p  ((char)) 
		p.Material = .Material.Neon
		(p, , { Color = white })
		(p, , { Position = p.Position + UP * , Transparency =  }, .EasingStyle.Sine, .EasingDirection.In)
	

	
	 c = ()
	 look = .(, , -)
	 right = .(, , )
	 c 
		 lv = .(c.CFrame.LookVector.X, , c.CFrame.LookVector.Z)
		 lv.Magnitude >  
			look = lv.Unit
			right = look:(UP)
		
	
	 feathers = {}
	 side = -, ,  
		 row = ,  
			 i = ,  
				 len =  + row *  + i * 
				 p = (.PartType.Block, .(, , len), (row == )  gold  white, .(pos), , .Material.Neon, )
				.(feathers, { p = p, side = side, th = .(- + i *  + row * ), len = len })
			
		
	
	(pos + UP * , { Color = ColorSequence.(white, gold), Speed = NumberRange.(, ), Acceleration = .(, , ), Lifetime = NumberRange.(, ) }, )

	 T, t0 = , .()
	 top = pos
	 .() - t0 < T 
		 a = (.() - t0) / T
		 flap = .(a * .pi * ) *  * ( - a * )
		 center = pos + UP * ( + a * a * )
		top = center
		 tr = 
		 a <   tr =  - a /   a >   tr = (a - ) /  
		 _, f  (feathers) 
			 th = f.th + flap
			 d = right * f.side * .(th) + UP * .(th)
			 mid = center + right * f.side *  + d * (f.len / )
			f.p.CFrame = .(mid, mid + d, look)
			f.p.Transparency = .(tr, , )
		
		RunService.Heartbeat:()
	
	 _, f  (feathers)  f.p:() 
	()
	(top, white, , )
	(top, gold, , )
	(top, gold, , )
	(top, { Color = ColorSequence.(white, gold), Speed = NumberRange.(, ), Acceleration = .(, , ), Lifetime = NumberRange.(, ) }, )
	(.(, , ), , )
)


(, .(, , ), (char, pos)
	 pool = {}
	 _, e  (EFFECTS) 
		 e.name ~=   .(pool, e) 
	
	pool[(, #pool)].(char, pos)
)

 byName = {}
 _, e  (EFFECTS)  byName[e.name] = e 




 combo, lastKill = , 
 updateKills = () 

  (char, pos)
	 e = byName[state.selected]
	 e  .(e.fn, char, pos) 


  (char, pos)
	 e = byName[state.selected]
	  e   
	 .() - lastKill <   combo +=   combo =  
	lastKill = .()
	state.kills += 
	()
	 pl = Players:(char)
	 name = pl  pl.DisplayName  char.Name
	(pos,  .. .(name), e.color, )
	 combo >  
		.(, () (pos + .(, , ),  .. combo .. , .(, , ), ) )
	
	(char, pos)





  (cf)
	 m = .()
	m.Name = 
	  (name, size, offset, color)
		 p = .()
		p.Name, p.Size, p.Anchored, p.CanCollide, p.Color = name, size, , , color
		p.CFrame = cf * .(offset)
		p.Parent = m
	
	 skin, shirt, pants = .(, , ), .(, , ), .(, , )
	(, .(, , ), .(, , ), skin)
	(, .(, , ), .zero, shirt)
	(, .(, , ), .(-, , ), skin)
	(, .(, , ), .(, , ), skin)
	(, .(, , ), .(-, -, ), pants)
	(, .(, , ), .(, -, ), pants)
	m.Parent = 
	Debris:(m, )
	 m, m.Torso.Position


  ()
	 char = player.Character
	 root = char  char:()
	  root   
	 flat = .(root.CFrame.LookVector.X, , root.CFrame.LookVector.Z)
	 flat.Magnitude <   flat = .(, , -) 
	 at = root.Position + flat.Unit * 
	 dummy, pos = (.(at))
	(dummy, pos)





 lastInput = 
(UserInputService.InputBegan, () lastInput = .() )

  (char, hum)
	 char == player.Character   
	 root = char:()  char:()  char.PrimaryPart
	 pos = root  root.Position
	  pos 
		 ok, pv = (()  char:().Position )
		 ok  pos = pv 
	
	  pos   

	 myChar = player.Character
	 myRoot = myChar  myChar:()
	 dist = myRoot  (pos - myRoot.Position).Magnitude  .huge

	 yes = 
	 tag = hum:()
	 tag  tag.Value == player 
		yes = 
	 state.mode ==  
		yes = (.() - lastInput < )  dist < 
	 state.mode ==  
		yes = dist <= RANGE
	
		yes = 
	
	 yes  (char, pos) 


 watched = {}
  (hum)
	 watched[hum]   
	 char = hum.Parent
	  char   char:()   
	watched[hum] = 
	 done = hum.Health <= 
	(hum.Died, ()
		 done   
		done = 
		(char, hum)
	)
	(hum.HealthChanged, (h)
		 h >  
			done = 
		  done 
			done = 
			(char, hum)
		
	)


 _, d  (:()) 
	 d:()  (d) 

(.DescendantAdded, (d)
	 d:()  .(watch, d) 
)




  (class, props, parent)
	 o = .(class)
	 k, v  (props)  o[k] = v 
	o.Parent = parent
	 o


  ()
	 ok, ui = (()  () )
	 ok  (ui) ==    ui 
	 player:()


 BG = .(, , )
 CARD = .(, , )
 CARD_ON = .(, , )

gui = (, {
	Name = , ResetOnSpawn = , IgnoreGuiInset = ,
	ZIndexBehavior = .ZIndexBehavior.Sibling, DisplayOrder = ,
}, ())


 openBtn = (, {
	Size = .(, ),
	Position = .(, , , -),
	BackgroundColor3 = BG,
	Text = ,
	Font = .Font.GothamBlack,
	TextSize = ,
	TextColor3 = .(, , ),
	AutoButtonColor = ,
	ZIndex = ,
}, gui)
(, { CornerRadius = .(, ) }, openBtn)
 openStroke = (, { Color = byName[state.selected].color, Thickness =  }, openBtn)
TweenService:(openStroke, TweenInfo.(, .EasingStyle.Sine, .EasingDirection.InOut, -, ), { Thickness =  }):()


 holder = (, {
	AnchorPoint = .(, ), Position = .(, ),
	Size = .(, ), BackgroundTransparency = , Visible = , ZIndex = ,
}, gui)
 fit = (, {}, holder)
 panel = (, {
	AnchorPoint = .(, ), Position = .(, ),
	Size = .(, ), BackgroundColor3 = BG,
}, holder)
 pop = (, { Scale =  }, panel)
(, { CornerRadius = .(, ) }, panel)
 panelStroke = (, { Color = byName[state.selected].color, Thickness =  }, panel)

(, {
	Position = .(, ), Size = .(, ),
	BackgroundTransparency = , Text = , Font = .Font.GothamBlack,
	TextSize = , TextColor3 = .(, , ), TextXAlignment = .TextXAlignment.Left,
}, panel)
 killsLabel = (, {
	Position = .(, -, , ), Size = .(, ),
	BackgroundTransparency = , Text = , Font = .Font.GothamBold,
	TextSize = , TextColor3 = .(, , ), TextXAlignment = .TextXAlignment.Right,
}, panel)
updateKills = () killsLabel.Text =  .. state.kills 

 closeBtn = (, {
	AnchorPoint = .(, ), Position = .(, -, , ), Size = .(, ),
	BackgroundColor3 = .(, , ), Text = , Font = .Font.GothamBlack,
	TextSize = , TextColor3 = .(, , ),
}, panel)
(, { CornerRadius = .(, ) }, closeBtn)

 grid = (, {
	Position = .(, ), Size = .(, ),
	BackgroundTransparency = , BorderSizePixel = , ScrollBarThickness = ,
	CanvasSize = .(), AutomaticCanvasSize = .AutomaticSize.Y,
}, panel)
(, { CellSize = .(, ), CellPadding = .(, ), SortOrder = .SortOrder.LayoutOrder }, grid)

 cards, strokes = {}, {}
 testBtn

  ()
	 sel = byName[state.selected]
	 name, b  (cards) 
		 on = name == state.selected
		(b, , { BackgroundColor3 = on  CARD_ON  CARD })
		strokes[name].Transparency = on    
	
	(panelStroke, , { Color = sel.color })
	(openStroke, , { Color = sel.color })
	 testBtn  (testBtn, , { BackgroundColor3 = sel.color }) 


 i, e  (EFFECTS) 
	 b = (, {
		BackgroundColor3 = CARD, Text = e.name, Font = .Font.GothamBold, TextSize = ,
		TextColor3 = .(, , ), AutoButtonColor = , LayoutOrder = i,
	}, grid)
	(, { CornerRadius = .(, ) }, b)
	(, { PaddingLeft = .(, ) }, b)
	strokes[e.name] = (, { Color = e.color, Thickness = , Transparency =  }, b)
	 bar = (, { Size = .(, , , ), Position = .(, -, , ), BackgroundColor3 = e.color }, b)
	(, { CornerRadius = .(, ) }, bar)
	cards[e.name] = b
	b.MouseButton1Click:(()
		state.selected = e.name
		()
	)


 controls = (, { Position = .(, ), Size = .(, ), BackgroundTransparency =  }, panel)
(, { FillDirection = .FillDirection.Horizontal, Padding = .(, ), SortOrder = .SortOrder.LayoutOrder }, controls)

  (text, order)
	 b = (, {
		Size = .(, ), BackgroundColor3 = CARD, Text = text, Font = .Font.GothamBold,
		TextSize = , TextColor3 = .(, , ), TextWrapped = , AutoButtonColor = , LayoutOrder = order,
	}, controls)
	(, { CornerRadius = .(, ) }, b)
	 b


testBtn = (, )
testBtn.Font, testBtn.TextSize = .Font.GothamBlack, 
testBtn.BackgroundColor3 = byName[state.selected].color
testBtn.MouseButton1Click:(testEffect)

 modeBtn = (, )
  () modeBtn.Text =  .. MODES[state.mode] 
modeBtn.MouseButton1Click:(()
	state.mode = state.mode % #MODES + 
	()
)

 soundBtn = (, )
  () soundBtn.Text =  .. (state.sound    ) 
soundBtn.MouseButton1Click:(()
	state.sound =  state.sound
	()
)

 qualBtn = (, )
  () qualBtn.Text =  .. (state.quality >=     ) 
qualBtn.MouseButton1Click:(()
	state.quality = (state.quality >= )    
	()
)

()
()
()
()


  ()
	 c = ()
	  c   
	 vp = c.ViewportSize
	fit.Scale = .(.(vp.X *  / , vp.Y *  / ), , )

()
 ()  (():(), refit) 

  (open)
	 open 
		()
		pop.Scale = 
		holder.Visible = 
		(pop, , { Scale =  }, .EasingStyle.Back)
	
		holder.Visible = 
	

  () ( holder.Visible) 

closeBtn.MouseButton1Click:(() () )
(UserInputService.InputBegan, (input, processed)
	  processed  input.KeyCode == .KeyCode.K  () 
)


 dragging, moved, dragStart, startPos = , , , 
openBtn.InputBegan:((input)
	 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
		dragging, moved = , 
		dragStart, startPos = input.Position, openBtn.Position
		input.Changed:(()
			 input.UserInputState == .UserInputState.End 
				dragging = 
				  moved  () 
			
		)
	
)
(UserInputService.InputChanged, (input)
	 dragging  (input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch) 
		 d = input.Position - dragStart
		 d.Magnitude >   moved =  
		 moved 
			openBtn.Position = .(startPos.X.Scale, startPos.X.Offset + d.X, startPos.Y.Scale, startPos.Y.Offset + d.Y)
		
	
)

()