Thunder anim v4

 .()  :()

 Players      = :()
 TweenService = :()
 RunService   = :()
 Lighting     = :()

 LocalPlayer = Players.LocalPlayer  Players.PlayerAdded:()


 CFG = {
	size        = ,
	thickness   = ,
	corner      = ,
	duration    = ,    
	spinDeg     = ,
	spinTime    = ,
	breathMin   = ,
	breathMax   = ,
	bubbleCount = ,
	bubbleScale = ,
	bubbleGap   = ,
	creditText  = ,
	rainbowSeconds = , 
	rainbowTurns   =  
}

 BLUE_LIGHT = .(, , )
 BLUE_MAIN  = .( , , )
 BLUE_DEEP  = .( ,  , )
 CYAN_SOFT  = .(, , )
 BG_COLOR   = .(  ,   ,  )

  ()
	 ok, root = (()  (gethui  ()) )
	 ok  root   root 
	ok, root = (()  (get_hidden_gui  ()) )
	 ok  root   root 
	ok, root = (()  (gethiddengui  ()) )
	 ok  root   root 
	 pg = LocalPlayer:()  LocalPlayer:(, )
	 pg  :()


(()
	 .ThunderIntro_Stop  .() 
)

 parent  = ()
 running = 

 blur = .()
blur.Size = 
blur.Name = 
blur.Parent = Lighting

 sg = .()
sg.Name = 
sg.IgnoreGuiInset = 
sg.ResetOnSpawn = 
(()    .protect_gui  .(sg)  )
sg.Parent = parent


 bg = .()
bg.Size = .(,)
bg.BackgroundColor3 = BG_COLOR
bg.BackgroundTransparency = 
bg.Parent = sg

 main = .()
main.Size = .(CFG.size, CFG.size)
main.AnchorPoint = .(,)
main.Position = .(,)
main.BackgroundTransparency = 
main.Parent = sg

 ring = .()
ring.Size = .(,)
ring.BackgroundTransparency = 
ring.Parent = main
 rCorner = .(); rCorner.CornerRadius = .(, CFG.corner); rCorner.Parent = ring
 rStroke = .()
rStroke.Thickness = CFG.thickness
rStroke.Color = BLUE_MAIN
(() rStroke.ApplyStrokeMode = .ApplyStrokeMode.Border )
rStroke.Parent = ring

 glowRing = .()
glowRing.Size = .(,)
glowRing.BackgroundTransparency = 
glowRing.ZIndex = -
glowRing.Parent = main
 gCorner = .(); gCorner.CornerRadius = .(, CFG.corner); gCorner.Parent = glowRing
 gStroke = .()
gStroke.Thickness = CFG.thickness * 
gStroke.Color = CYAN_SOFT
gStroke.Transparency = 
(() gStroke.ApplyStrokeMode = .ApplyStrokeMode.Border )
gStroke.Parent = glowRing

 inner = .()
inner.Size = .(CFG.size - CFG.thickness*, CFG.size - CFG.thickness*)
inner.AnchorPoint = .(,)
inner.Position = .(,)
inner.BackgroundTransparency = 
inner.Parent = main

 title = .()
title.Size = .(,)
title.AnchorPoint = .(,)
title.Position = .(,)
title.BackgroundTransparency = 
title.Text = 
title.TextScaled = 
title.Font = .Font.GothamBlack
title.TextColor3 = BLUE_MAIN
title.TextTransparency = 
title.Parent = inner
 grad = .()
grad.Color = ColorSequence.{
	ColorSequenceKeypoint.(, BLUE_LIGHT),
	ColorSequenceKeypoint.(, BLUE_MAIN),
	ColorSequenceKeypoint.(, BLUE_DEEP)
}
grad.Rotation = 
grad.Parent = title

 sub = .()
sub.Size = .(,)
sub.AnchorPoint = .(,)
sub.Position = .(,)
sub.BackgroundTransparency = 
sub.Text = 
sub.TextScaled = 
sub.Font = .Font.GothamMedium
sub.TextColor3 = BLUE_LIGHT
sub.TextTransparency = 
sub.Parent = inner

.(()
	 running 
		grad.Rotation = (grad.Rotation + ) % 
		.()
	
)


 orb = .()
orb.AnchorPoint = .(,)
orb.Position = .(,)
orb.Size = .(,)
orb.BackgroundColor3 = CYAN_SOFT
orb.BackgroundTransparency = 
orb.ZIndex = -
orb.Parent = inner
 orbCorner = .(); orbCorner.CornerRadius = .(,); orbCorner.Parent = orb

  ()
	 s = .()
	s.Size = .(,)
	s.AnchorPoint = .(,)
	s.Position = orb.Position
	s.BackgroundColor3 = .(,,)
	s.BackgroundTransparency = 
	s.ZIndex = 
	s.Parent = inner

	 goalPos = orb.Position + .(.(-,), .(-,))
	TweenService:(s, TweenInfo.(), {Position = goalPos, BackgroundTransparency = }):()
	:():(s, )


 i=,  .(i*, Spark) 

  (ui)
	 orig = ui.Position
	 i = ,  
		ui.Position = orig + .(.(-,), .(-,))
		.()
	
	ui.Position = orig

(main)


 credit = .()
credit.Size = .(,)
credit.AnchorPoint = .(,)
credit.Position = .(,)
credit.BackgroundTransparency = 
credit.Text = CFG.creditText
credit.TextColor3 = .(,,)
credit.Font = .Font.Gotham
credit.TextSize = 
credit.TextTransparency = 
credit.Parent = sg

 sweep = .()
sweep.BackgroundTransparency = 
sweep.Size = .(,)
sweep.AnchorPoint = .(,)
sweep.Position = .(-,)
sweep.Rotation = -
sweep.ZIndex = 
sweep.Parent = inner
 sweepGrad = .()
sweepGrad.Color = ColorSequence.{
	ColorSequenceKeypoint.(, .(,,)),
	ColorSequenceKeypoint.(, .(,,)),
	ColorSequenceKeypoint.(, .(,,)),
}
sweepGrad.Transparency = NumberSequence.{
	NumberSequenceKeypoint.(,),
	NumberSequenceKeypoint.(,),
	NumberSequenceKeypoint.(,),
	NumberSequenceKeypoint.(,),
	NumberSequenceKeypoint.(,),
}
sweepGrad.Parent = sweep


 bubbleFolder = .()
bubbleFolder.Name = 
bubbleFolder.Parent = main

  ()
	 b = .()
	b.AnchorPoint = .(,)
	b.Position = .(,)
	b.Size = .(,)
	b.BackgroundTransparency = 
	b.ZIndex = -
	b.Parent = bubbleFolder
	 s = .()
	s.Thickness = 
	s.Color = CYAN_SOFT
	s.Transparency = 
	s.Parent = b
	 c = .(); c.CornerRadius = .(,); c.Parent = b
	 b, s



 ringScale = .(); ringScale.Scale = ; ringScale.Parent = ring
 mainScale = .(); mainScale.Scale = ; mainScale.Parent = main


.ThunderIntro_Stop = ()
	  running   
	running = 
	 sg  sg.Parent  sg:() 
	 blur  blur.Parent  blur:() 


 ORIG = {
	rStroke = rStroke.Color,
	gStroke = gStroke.Color,
	titleGradient = grad.Color,
	sub = sub.TextColor3,
	orb = orb.BackgroundColor3
}

  (h, s, v)  .(h % , s, v) 

  (h)
	grad.Color = ColorSequence.{
		ColorSequenceKeypoint.(, (h,     ,)),
		ColorSequenceKeypoint.(, (h+,,)),
		ColorSequenceKeypoint.(, (h+,,))
	}


  ()
	 dur  = .(, CFG.rainbowSeconds)
	 turns = CFG.rainbowTurns
	 start = .()
	 running 
		 t = .() - start
		 t > dur   
		 u = t / dur
		 h = u * turns
		rStroke.Color = (h, , )
		gStroke.Color = (h+, , )
		(h)
		sub.TextColor3 = (h+, , )
		orb.BackgroundColor3 = (h+, , )
		RunService.Heartbeat:()
	


	rStroke.Color = ORIG.rStroke
	gStroke.Color = ORIG.gStroke
	grad.Color    = ORIG.titleGradient
	sub.TextColor3 = ORIG.sub
	orb.BackgroundColor3 = ORIG.orb



.(RainbowBurst)


.(()
	 flash = .()
	flash.Size = .(,)
	flash.BackgroundColor3 = .(,,)
	flash.BackgroundTransparency = 
	flash.ZIndex = 
	flash.Parent = sg
	 fIn  = TweenService:(flash, TweenInfo.(), {BackgroundTransparency = })
	 fOut = TweenService:(flash, TweenInfo.(), {BackgroundTransparency = })
	fIn:(); fIn.Completed:(); fOut:(); fOut.Completed:()
	flash:()
)

.(()
	 running 
		 t1 = TweenService:(ring,     TweenInfo.(CFG.spinTime, .EasingStyle.Exponential, .EasingDirection.InOut), {Rotation = ring.Rotation + CFG.spinDeg})
		 t2 = TweenService:(glowRing, TweenInfo.(CFG.spinTime, .EasingStyle.Exponential, .EasingDirection.InOut), {Rotation = glowRing.Rotation + CFG.spinDeg})
		t1:(); t2:(); t1.Completed:()
	
)

.(()
	 running 
		TweenService:(ringScale, TweenInfo.(, .EasingStyle.Sine, .EasingDirection.Out), {Scale = CFG.breathMax}):()
		.()
		TweenService:(ringScale, TweenInfo.(, .EasingStyle.Sine, .EasingDirection.In),  {Scale = CFG.breathMin}):()
		.()
	
)

.(()
	.()
	TweenService:(title,  TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out), {TextTransparency = }):()
	.()
	TweenService:(sub,    TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out), {TextTransparency = }):()
	TweenService:(credit, TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out), {TextTransparency = }):()
)

.(()
	 running 
		 up = TweenService:(orb, TweenInfo.(, .EasingStyle.Sine, .EasingDirection.Out), {BackgroundTransparency = , Size = .(,)})
		 dn = TweenService:(orb, TweenInfo.(, .EasingStyle.Sine, .EasingDirection.In),  {BackgroundTransparency = , Size = .(,)})
		up:(); up.Completed:(); dn:(); dn.Completed:()
	
)


  ()

	 baseT = bg.BackgroundTransparency
	 flashDown = TweenService:(bg, TweenInfo.(, .EasingStyle.Sine, .EasingDirection.Out), {BackgroundTransparency = .(, baseT - )})
	 flashUp   = TweenService:(bg, TweenInfo.(, .EasingStyle.Sine, .EasingDirection.In),  {BackgroundTransparency = baseT})
	flashDown:(); flashDown.Completed:(); flashUp:()

	 oldThick = rStroke.Thickness
	 oldColor = rStroke.Color
	 boostA = TweenService:(rStroke, TweenInfo.(, .EasingStyle.Quart, .EasingDirection.Out), {Thickness = oldThick * , Color = CYAN_SOFT})
	 boostB = TweenService:(rStroke, TweenInfo.(, .EasingStyle.Quad,  .EasingDirection.In),  {Thickness = oldThick,               Color = oldColor})
	boostA:(); boostA.Completed:(); boostB:()

	 thumpUp = TweenService:(mainScale, TweenInfo.(, .EasingStyle.Back, .EasingDirection.Out), {Scale = })
	 thumpDn = TweenService:(mainScale, TweenInfo.(, .EasingStyle.Quad,  .EasingDirection.In),  {Scale = })
	thumpUp:(); thumpUp.Completed:(); thumpDn:()

	 i = , CFG.bubbleCount 
		.(()
			 b, s = ()
			 grow = TweenService:(b, TweenInfo.(, .EasingStyle.Cubic, .EasingDirection.Out), {Size = .(CFG.size * CFG.bubbleScale, CFG.size * CFG.bubbleScale)})
			 fade = TweenService:(s, TweenInfo.(, .EasingStyle.Sine,  .EasingDirection.Out), {Transparency = })
			grow:(); fade:(); grow.Completed:()
			b:()
		)
		.(CFG.bubbleGap)
	


.(()
	()
)

.(()
	.()
	 flash = .()
	flash.Size = .(,)
	flash.BackgroundColor3 = .(,,)
	flash.BackgroundTransparency = 
	flash.ZIndex = -
	flash.Parent = sg
	 fIn  = TweenService:(flash, TweenInfo.(, .EasingStyle.Sine,  .EasingDirection.Out), {BackgroundTransparency = })
	 fOut = TweenService:(flash, TweenInfo.(, .EasingStyle.Sine,  .EasingDirection.In),  {BackgroundTransparency = })
	fIn:(); fIn.Completed:(); fOut:(); fOut.Completed:()
	flash:()
)

.(()
	.()
	TweenService:(sweep, TweenInfo.(, .EasingStyle.Sine, .EasingDirection.Out), {Position = .(, )}):()
)

  ()
	 ring = main:()
	ring.Size = .(, )
	ring.BackgroundTransparency = 
	ring.Parent = inner

	TweenService:(ring, TweenInfo.(, .EasingStyle.Quart), {
		Size = .(, ),
		BackgroundTransparency = 
	}):()

	:():(ring, )


 bubbleTween  bubbleTween.Completed:(PulseRing) 
 popSound  popSound.Ended:(PulseRing) 

 CFG.duration  CFG.duration >  
	.(CFG.duration, ()
		  running   
		 fade = TweenInfo.(, .EasingStyle.Quad, .EasingDirection.InOut)
		TweenService:(rStroke,  fade, {Transparency = }):()
		TweenService:(gStroke,  fade, {Transparency = }):()
		TweenService:(title,    fade, {TextTransparency = }):()
		TweenService:(sub,      fade, {TextTransparency = }):()
		TweenService:(credit,   fade, {TextTransparency = }):()
		TweenService:(bg,       fade, {BackgroundTransparency = }):()
		.()
		.()
	)