Spider-Man Ai GPT-6 ASTRA UPDATED SCRIPT

 Players = :()
 Workspace = :()
 RunService = :()
 UserInputService = :()
 Debris = :()

 player = Players.LocalPlayer
 playerGui = player:()

 CONFIG = {
	SwingForward = ,
	SwingHeight = ,
	SwingBoost = ,
	SwingAcceleration = ,
	SwingAssist = ,
	SwingMaxSpeed = ,
	RopeMinLength = ,
	RopeMaxLength = ,
	RopeReelSpeed = ,

	ZipDistance = ,
	ZipSpeed = ,
	ZipDuration = ,

	PullDistance = ,
	PullSpeed = ,
	PullDuration = ,

	ClimbReach = ,
	ClimbSpeed = ,
	ClimbSprintSpeed = ,
	SurfaceOffset = ,
	SurfaceStickSpeed = ,
	SurfaceGraceTime = ,

	SlingDistance = ,
	SlingChargeTime = ,
	SlingMinSpeed = ,
	SlingMaxSpeed = ,
	SlingLift = ,

	Cooldowns = {
		Swing = ,
		Zip = ,
		Pull = ,
		Climb = ,
		Sling = ,
	},
}

 COLORS = {
	Red = .(, , ),
	Blue = .(, , ),
	Dark = .(, , ),
	Active = .(, , ),
	White = .(, , ),
}

 previous = playerGui:()
 previous 
	 oldShutdown = previous:()
	 oldShutdown  oldShutdown:() 
		oldShutdown:()
	
	previous:()


 previousSling = playerGui:()
 previousSling 
	previousSling:()


 gui = .()
gui.Name = 
gui.ResetOnSpawn = 
gui.ZIndexBehavior = .ZIndexBehavior.Sibling
gui.Parent = playerGui

 shutdown = .()
shutdown.Name = 
shutdown.Parent = gui

 running = 
 connections = {}
 deathConnection
 characterGeneration = 

 character
 humanoid
 root

 cooldowns = {}
 keys = {}
 actionHolds = {}
 crawlTouches = {}
 ropeTouches = {}
 buttons = {}

 notice = 
 noticeUntil = 

 state = {
	mode = ,
	objects = {},
}

 stopMode
 startSwing
 startZip
 startPull
 toggleClimb
 slingAction
 leapOff

  (signal, callback)
	 connection = signal:(callback)
	.(connections, connection)
	 connection


  ()
	 running
		 character ~= 
		 character.Parent ~= 
		 root ~= 
		 root.Parent ~= 
		 humanoid ~= 
		 humanoid.Health > 


  (vector, fallback)
	 vector.Magnitude >  
		 vector.Unit
	
	 fallback


  (vector, normal)
	 vector - normal * vector:(normal)


  (object)
	.(state.objects, object)
	 object


  (text)
	notice = text
	noticeUntil = .() + 


  (action)
	 .() >= (cooldowns[action]  )


  (action)
	cooldowns[action] = .() + CONFIG.Cooldowns[action]


  (id, volume, speed)
	  ()   

	 sound = .()
	sound.SoundId =  .. (id)
	sound.Volume = volume  
	sound.PlaybackSpeed = speed  
	sound.Parent = root
	sound:()
	Debris:(sound, )


  ()
	 camera = Workspace.CurrentCamera
	 camera  camera.CFrame.LookVector
		 root.CFrame.LookVector


  (input)
	 input.UserInputType == .UserInputType.Touch
		 input.UserInputType == .UserInputType.MouseButton1


  (parent, name, text, color, size)
	 button = .()
	button.Name = name
	button.Size = size  .(, )
	button.BackgroundColor3 = color
	button.TextColor3 = COLORS.White
	button.Text = text
	button.TextSize = 
	button.TextWrapped = 
	button.Font = .Font.GothamBold
	button.AutoButtonColor = 
	button.Parent = parent

	 corner = .()
	corner.CornerRadius = .(, )
	corner.Parent = button

	 stroke = .()
	stroke.Color = COLORS.White
	stroke.Transparency = 
	stroke.Thickness = 
	stroke.Parent = button

	 button


 status = .()
status.AnchorPoint = .(, )
status.Position = .(, )
status.Size = .(, , , )
status.BackgroundTransparency = 
status.Font = .Font.GothamBold
status.TextSize = 
status.TextWrapped = 
status.TextColor3 = COLORS.White
status.TextStrokeTransparency = 
status.Text = 
status.Parent = gui

 actionPanel = .()
actionPanel.AnchorPoint = .(, )
actionPanel.Position = .(, -, , )
actionPanel.Size = .(, )
actionPanel.BackgroundTransparency = 
actionPanel.Parent = gui

 actionScale = .()
actionScale.Parent = actionPanel

 actionLayout = .()
actionLayout.Padding = .(, )
actionLayout.HorizontalAlignment = .HorizontalAlignment.Center
actionLayout.SortOrder = .SortOrder.LayoutOrder
actionLayout.Parent = actionPanel

 definitions = {
	{, , COLORS.Red},
	{, , COLORS.Blue},
	{, , COLORS.Dark},
	{, , COLORS.Red},
	{, , COLORS.Blue},
}

 index, definition  (definitions) 
	 action, text, color = .(definition)
	 button = (actionPanel, action, text, color)
	button.LayoutOrder = index

	buttons[action] = {
		button = button,
		text = text,
		color = color,
	}


 crawlPanel = .()
crawlPanel.AnchorPoint = .(, )
crawlPanel.Position = .(, , , -)
crawlPanel.Size = .(, )
crawlPanel.BackgroundTransparency = 
crawlPanel.Visible = 
crawlPanel.Parent = gui

 crawlScale = .()
crawlScale.Parent = crawlPanel

  (name, text, x, y)
	 button = (
		crawlPanel,
		name,
		text,
		COLORS.Dark,
		.(, )
	)
	button.Position = .(x, y)
	 button


 upButton = (, , , )
 downButton = (, , , )
 leftButton = (, , , )
 rightButton = (, , , )

 leapButton = (
	gui,
	,
	,
	COLORS.Blue,
	.(, )
)
leapButton.AnchorPoint = .(, )
leapButton.Position = .(, , , )
leapButton.Visible = 

 ropePanel = .()
ropePanel.AnchorPoint = .(, )
ropePanel.Position = .(, , , -)
ropePanel.Size = .(, )
ropePanel.BackgroundTransparency = 
ropePanel.Visible = 
ropePanel.Parent = gui

 ropeScale = .()
ropeScale.Parent = ropePanel

 reelButton = (
	ropePanel,
	,
	,
	COLORS.Blue,
	.(, )
)

 extendButton = (
	ropePanel,
	,
	,
	COLORS.Dark,
	.(, )
)
extendButton.Position = .(, )


  (position)
	 part = (.())
	part.Name = 
	part.Size = .(, , )
	part.Anchored = 
	part.CanCollide = 
	part.CanTouch = 
	part.CanQuery = 
	part.CastShadow = 
	part.Transparency = 
	part.Position = position
	part.Parent = Workspace

	 attachment = (.())
	attachment.Name = 
	attachment.Parent = part

	 attachment


  (side)
	 character:(side .. )
		 character:(side .. )


  (side, target)
	 hand = (side)
	  hand   

	 attachment = (.())
	attachment.Name =  .. side .. 
	attachment.Position = .(, -hand.Size.Y * , )
	attachment.Parent = hand

	 beam = (.())
	beam.Name = 
	beam.Attachment0 = attachment
	beam.Attachment1 = target
	beam.Width0 = 
	beam.Width1 = 
	beam.FaceCamera = 
	beam.Segments = 
	beam.LightEmission = 
	beam.Color = ColorSequence.(COLORS.White)
	beam.Parent = hand


  ()
	state.pose = {
		targets = {},
		shoulders = {},
	}

	 _, side  ({, }) 
		 hand = (side)
		 upperArm = character:(side .. )

		 humanoid.RigType == .HumanoidRigType.R15
			 hand  upperArm 

			 target = (.())
			target.Name =  .. side .. 
			target.Parent = root
			state.pose.targets[side] = target

			 ik = (.())
			ik.Name =  .. side .. 
			ik.Type = .IKControlType.Position
			ik.ChainRoot = upperArm
			ik.EndEffector = hand
			ik.Target = target
			ik.Weight = 
			ik.SmoothTime = 
			ik.Priority = 
			ik.Parent = humanoid
		
			 torso = character:()
			 shoulder = torso
				 torso:(side .. )

			 shoulder  shoulder:() 
				state.pose.shoulders[side] = {
					motor = shoulder,
					transform = shoulder.Transform,
				}
			
		
	


  ()
	  state.pose   state.anchors   

	 _, side  ({, }) 
		 index = side ==     
		 anchor = state.anchors[index]  state.anchors[]
		 target = state.pose.targets[side]

		 target  anchor  anchor.Parent 
			 shoulderPosition =
				root.Position + root.CFrame.UpVector * 

			 direction = (
				anchor.WorldPosition - shoulderPosition,
				root.CFrame.UpVector
			)

			 separation = side ==   -  
			 grip = shoulderPosition
				+ direction * 
				+ root.CFrame.RightVector * separation

			target.Position = root.CFrame:(grip)
		
	


  (firstPosition, secondPosition)
	 first = (firstPosition)
	 second = secondPosition
		 (secondPosition)
		 first

	state.anchors = {first, second}

	(, first)
	(, second)
	()
	()


  ()
	  state.anchors    

	 _, anchor  (state.anchors) 
		  anchor:(Workspace) 
			 
		
	

	 


  (useVelocity)
	 attachment = (.())
	attachment.Name = 
	attachment.Parent = root
	state.motionAttachment = attachment

	 orientation = (.())
	orientation.Mode = .OrientationAlignmentMode.OneAttachment
	orientation.Attachment0 = attachment
	orientation.MaxTorque = 
	orientation.MaxAngularVelocity = 
	orientation.Responsiveness = 
	orientation.CFrame = root.CFrame.Rotation
	orientation.Parent = root
	state.orientation = orientation

	 useVelocity 
		 velocity = (.())
		velocity.Attachment0 = attachment
		velocity.RelativeTo = .ActuatorRelativeTo.World
		velocity.VelocityConstraintMode =
			.VelocityConstraintMode.Vector
		velocity.ForceLimitsEnabled = 
		velocity.VectorVelocity = .zero
		velocity.Parent = root
		state.velocity = velocity
	


stopMode = ()
	 old = state
	 old.mode ==    

	state = {
		mode = ,
		objects = {},
	}

	 old.pose 
		 _, entry  (old.pose.shoulders) 
			 entry.motor.Parent 
				entry.motor.Transform = entry.transform
			
		
	

	 index = #old.objects, , - 
		old.objects[index]:()
	

	 old.saved  old.saved.humanoid.Parent 
		 hum = old.saved.humanoid
		hum.AutoRotate = old.saved.autoRotate
		hum.PlatformStand = old.saved.platformStand

		 hum.Health >    hum.PlatformStand 
			hum:(.HumanoidStateType.Freefall)
		
	

	crawlPanel.Visible = 
	leapButton.Visible = 
	ropePanel.Visible = 

	.(crawlTouches)
	.(ropeTouches)

	 old.mode == 
		 old.mode == 
		 old.mode == 
		 old.mode ==  
		(old.mode)
	


  (mode, useVelocity)
	  ()    

	()

	state.mode = mode
	state.started = .()
	state.saved = {
		humanoid = humanoid,
		autoRotate = humanoid.AutoRotate,
		platformStand = humanoid.PlatformStand,
	}

	humanoid.AutoRotate = 
	humanoid.PlatformStand = 
	(useVelocity)

	 


  (direction, preferredUp)
	 forward = (direction, root.CFrame.LookVector)
	 up = preferredUp  .yAxis

	 .(forward:(up)) >  
		up = root.CFrame.RightVector
	

	 .(forward:(up)) >  
		up = .zAxis
	

	 .(forward:(up)) >  
		up = .xAxis
	

	state.orientation.CFrame = .(
		.zero,
		forward,
		up
	)


  ()
	 look = ()
	 fallback = (
		(root.CFrame.LookVector, .yAxis),
		.(, , -)
	)

	 forward = (
		(look, .yAxis),
		fallback
	)

	 root.Position
		+ forward * CONFIG.SwingForward
		+ .yAxis * (
			CONFIG.SwingHeight + .(look.Y, ) * 
		)


  (distance)
	 root.Position
		+ .yAxis * 
		+ ((), root.CFrame.LookVector) * distance


startSwing = ()
	  ()   ()   
	 state.mode ==    

	 position = ()

	  (, )   
	(position)

	 rope = (.())
	rope.Attachment0 = state.motionAttachment
	rope.Attachment1 = state.anchors[]
	rope.Length = .(
		(position - root.Position).Magnitude,
		CONFIG.RopeMinLength,
		CONFIG.RopeMaxLength
	)
	rope.Visible = 
	rope.Restitution = 
	rope.Parent = root
	state.rope = rope

	 force = (.())
	force.Attachment0 = state.motionAttachment
	force.RelativeTo = .ActuatorRelativeTo.World
	force.ApplyAtCenterOfMass = 
	force.Force = .zero
	force.Parent = root
	state.force = force

	 radial = (position - root.Position, .yAxis)
	 forward = (
		((), radial),
		((root.CFrame.LookVector, radial), .zero)
	)

	root.AssemblyLinearVelocity += forward * CONFIG.SwingBoost

	ropePanel.Visible = 
	(, )


startZip = ()
	  ()   ()   

	 position = (CONFIG.ZipDistance)

	  (, )   

	(position)
	state.deadline = .() + CONFIG.ZipDuration
	()
	(, , )


startPull = ()
	  ()   ()   
	 state.mode ==    

	 position = (CONFIG.PullDistance)

	  (, )   

	(position)
	state.deadline = .() + CONFIG.PullDuration
	(, , )


slingAction = ()
	  ()   

	 state.mode ==  
		  () 
			()
			
		

		 charge = .(
			(.() - state.started) / CONFIG.SlingChargeTime,
			,
			
		)

		 middle = (
			state.anchors[].WorldPosition
				+ state.anchors[].WorldPosition
		) * 

		 direction = (
			middle - root.Position,
			()
		)

		 speed = CONFIG.SlingMinSpeed
			+ (CONFIG.SlingMaxSpeed - CONFIG.SlingMinSpeed) * charge

		()

		root.AssemblyLinearVelocity =
			direction * speed
			+ .yAxis * CONFIG.SlingLift

		(, , )
		
	

	  () 
		()
		
	

	 camera = Workspace.CurrentCamera
	  camera   

	 middle = root.Position
		+ .yAxis * 
		+ camera.CFrame.LookVector * CONFIG.SlingDistance

	 first = middle - camera.CFrame.RightVector * 
	 second = middle + camera.CFrame.RightVector * 

	  (, )   

	(first, second)
	state.holdPosition = root.Position
	root.AssemblyLinearVelocity = .zero
	state.velocity.VectorVelocity = .zero

	(, , )



  (origin, direction)
	  character    

	 params = RaycastParams.()
	params.FilterType = .RaycastFilterType.Exclude
	params.FilterDescendantsInstances = {character}
	params.IgnoreWater = 
	params.RespectCanCollide = 

	 Workspace:(origin, direction, params)


  (normal, preferred)
	 up = (preferred, normal)

	 up.Magnitude <  
		up = (.yAxis, normal)
	
	 up.Magnitude <  
		up = (.zAxis, normal)
	
	 up.Magnitude <  
		up = (.xAxis, normal)
	

	up = up.Unit
	 right = (up:(normal), .xAxis)

	 up, right


  ()
	 directions = {
		(),
		root.CFrame.LookVector,
		root.CFrame.UpVector,
		-root.CFrame.UpVector,
		root.CFrame.RightVector,
		-root.CFrame.RightVector,
		-root.CFrame.LookVector,
	}

	 _, direction  (directions) 
		 hit = (
			root.Position,
			direction * CONFIG.ClimbReach
		)
		 hit   hit 
	

	 


toggleClimb = ()
	 state.mode ==  
		()
		
	

	  ()   ()   

	 hit = ()
	  hit 
		()
		
	

	  (, )   

	state.normal = hit.Normal
	state.surfaceUp = (hit.Normal, root.CFrame.UpVector)
	state.bodyUp = state.surfaceUp
	state.lastSurface = .()

	crawlPanel.Visible = 
	leapButton.Visible = 


  ()
	 x, y = , 

	 keys[.KeyCode.A]  x -=  
	 keys[.KeyCode.D]  x +=  
	 keys[.KeyCode.W]  y +=  
	 keys[.KeyCode.S]  y -=  

	 directions = {}
	 _, direction  (crawlTouches) 
		directions[direction] = 
	

	 directions.Left  x -=  
	 directions.Right  x +=  
	 directions.Up  y +=  
	 directions.Down  y -=  

	 input = .(x, y)
	 input.Magnitude >   input.Unit  input


  (movement)
	 normal = state.normal
	 origin = root.Position

	 movement.Magnitude >  
		 ahead = (
			origin,
			movement.Unit * (CONFIG.SurfaceOffset + )
		)

		 ahead  ahead.Normal:(normal) <  
			 ahead
		
	

	 current = (
		origin,
		-normal * CONFIG.ClimbReach
	)

	 current   current 

	 movement.Magnitude >  
		 direction = movement.Unit

		 forwardSurface = (
			origin + direction * ,
			-normal * CONFIG.ClimbReach
		)
		 forwardSurface   forwardSurface 

		 around = (
			origin
				+ direction * 
				- normal * (CONFIG.SurfaceOffset + ),
			-direction * 
		)
		 around   around 
	

	 


leapOff = ()
	  ()   

	 state.mode ==  
		 normal = state.normal
		 travel = state.bodyUp

		()

		root.AssemblyLinearVelocity =
			normal * 
			+ travel * 
			+ .yAxis * 
	 state.mode ~=  
		()
	


  (dt)
	 target = state.anchors[].WorldPosition
	 radial = (target - root.Position, .yAxis)
	 velocity = root.AssemblyLinearVelocity

	 steering = (humanoid.MoveDirection, radial)
	 cameraTangent = ((), radial)
	 travelTangent = (velocity, radial)

	 assistDirection
	 travelTangent.Magnitude >  
		assistDirection = travelTangent.Unit
	
		assistDirection = (
			cameraTangent,
			((root.CFrame.LookVector, radial), .zero)
		)
	

	 acceleration =
		steering * CONFIG.SwingAcceleration
		+ assistDirection * CONFIG.SwingAssist

	state.force.Force = acceleration * root.AssemblyMass

	 velocity.Magnitude > CONFIG.SwingMaxSpeed 
		 excess = velocity.Magnitude - CONFIG.SwingMaxSpeed
		state.force.Force -=
			velocity.Unit * excess * root.AssemblyMass * 
	

	 reelDirection = 

	 keys[.KeyCode.Space] 
		reelDirection -= 
	
	 keys[.KeyCode.LeftShift]
		 keys[.KeyCode.RightShift] 
		reelDirection += 
	

	 _, direction  (ropeTouches) 
		reelDirection += direction
	

	state.rope.Length = .(
		state.rope.Length
			+ .(reelDirection, -, )
			* CONFIG.RopeReelSpeed
			* dt,
		CONFIG.RopeMinLength,
		CONFIG.RopeMaxLength
	)

	 facing = travelTangent
	 facing.Magnitude <  
		facing = cameraTangent
	

	(facing, radial)


  ()
	 delta = state.anchors[].WorldPosition - root.Position
	 distance = delta.Magnitude
	 isZip = state.mode == 
	 stopDistance = 

	 distance <= stopDistance  .() >= state.deadline 
		  isZip  distance <= stopDistance 
			root.AssemblyLinearVelocity *= 
		
		()
		
	

	 direction = delta / distance
	 maxSpeed = isZip  CONFIG.ZipSpeed  CONFIG.PullSpeed
	 speed = .(
		maxSpeed,
		.(, (distance - stopDistance) * )
	)

	state.velocity.VectorVelocity = direction * speed
	(direction)


  (dt)
	 input = ()
	 up, right = (state.normal, state.surfaceUp)
	 movement = right * input.X + up * input.Y
	 hit = (movement)

	  hit 
		state.velocity.VectorVelocity = .zero

		 .() - state.lastSurface > CONFIG.SurfaceGraceTime 
			()
		
		
	

	state.lastSurface = .()
	state.normal = hit.Normal
	state.surfaceUp, right = (hit.Normal, state.surfaceUp)

	up = state.surfaceUp
	movement = right * input.X + up * input.Y

	 sprinting = keys[.KeyCode.LeftShift]
		 keys[.KeyCode.RightShift]

	 speed = sprinting
		 CONFIG.ClimbSprintSpeed
		 CONFIG.ClimbSpeed

	 gap = (root.Position - hit.Position):(hit.Normal)
	 correction = .(
		(CONFIG.SurfaceOffset - gap) * ,
		-CONFIG.SurfaceStickSpeed,
		CONFIG.SurfaceStickSpeed
	)

	 surfaceVelocity = .zero
	 hit.Instance:() 
		surfaceVelocity = hit.Instance:(hit.Position)
	

	state.velocity.VectorVelocity =
		movement * speed
		+ hit.Normal * correction
		+ surfaceVelocity

	
	 movement.Magnitude >  
		 desiredUp = movement.Unit
		 currentUp = (
			(state.bodyUp, hit.Normal),
			up
		)

		 angle = .(
			hit.Normal:(currentUp:(desiredUp)),
			.(currentUp:(desiredUp), -, )
		)

		 .(angle) > .pi -  
			angle = .pi
		

		state.bodyUp = .(
			hit.Normal,
			angle * .(dt * , )
		):(currentUp)
	
		state.bodyUp = (
			(state.bodyUp, hit.Normal),
			up
		)
	

	(-hit.Normal, state.bodyUp)


  ()
	 correction = (state.holdPosition - root.Position) * 

	 correction.Magnitude >  
		correction = correction.Unit * 
	

	state.velocity.VectorVelocity = correction

	 middle = (
		state.anchors[].WorldPosition
			+ state.anchors[].WorldPosition
	) * 

	(middle - root.Position)


  (action)
	 action ==  
		()
	 action ==  
		()
	 action ==  
		()
	 action ==  
		()
	 action ==  
		()
	


  (action)
	 _, held  (actionHolds) 
		 held == action    
	
	 


  (action)
	 (action)   

	 (action ==   state.mode == )
		 (action ==   state.mode == ) 
		()
	


 action, entry  (buttons) 
	 action ==   action ==  
		(entry.button.InputBegan, (input)
			  (input)   
			actionHolds[input] = action
			(action)
		)
	
		(entry.button.Activated, ()
			(action)
		)
	


  (button, direction)
	(button.InputBegan, (input)
		 (input)  state.mode ==  
			crawlTouches[input] = direction
		
	)


(upButton, )
(downButton, )
(leftButton, )
(rightButton, )

  (button, direction)
	(button.InputBegan, (input)
		 (input)  state.mode ==  
			ropeTouches[input] = direction
		
	)


(reelButton, -)
(extendButton, )
(leapButton.Activated, leapOff)

 keyActions = {
	[.KeyCode.Q] = ,
	[.KeyCode.E] = ,
	[.KeyCode.R] = ,
	[.KeyCode.C] = ,
	[.KeyCode.F] = ,
}

(UserInputService.InputBegan, (input, processed)
	 processed  UserInputService:()   
	 input.UserInputType ~= .UserInputType.Keyboard   

	keys[input.KeyCode] = 

	 action = keyActions[input.KeyCode]
	 action 
		 action ==   action ==  
			actionHolds[input.KeyCode] = action
		
		(action)
	 input.KeyCode == .KeyCode.X 
		()
	
)

(UserInputService.InputEnded, (input)
	keys[input.KeyCode] = 

	 pointerAction = actionHolds[input]
	actionHolds[input] = 
	 pointerAction 
		(pointerAction)
	

	 keyboardAction = actionHolds[input.KeyCode]
	actionHolds[input.KeyCode] = 
	 keyboardAction 
		(keyboardAction)
	

	crawlTouches[input] = 
	ropeTouches[input] = 
)

(UserInputService.JumpRequest, ()
	 UserInputService:()   

	
	 state.mode ~=  
		()
	
)

  ()
	.(keys)
	.(actionHolds)
	.(crawlTouches)
	.(ropeTouches)


(UserInputService.WindowFocusReleased, ()
	()
	()
)

(UserInputService.TextBoxFocused, ()
	()
	()
)

(RunService.PreSimulation, ()
	  ()   state.pose   

	
	 side, entry  (state.pose.shoulders) 
		 entry.motor.Parent 
			 spread = side ==   -  
			entry.motor.Transform = .(
				.(),
				,
				.(spread)
			)
		
	
)

(RunService.Heartbeat, (dt)
	  () 
		()
		
	

	 state.mode ==    

	 state.anchors   () 
		()
		
	

	 state.mode ==  
		(dt)
	 state.mode ==   state.mode ==  
		()
	 state.mode ==  
		(dt)
	 state.mode ==  
		()
	

	()
)

(RunService.RenderStepped, ()
	 now = .()
	 camera = Workspace.CurrentCamera

	 camera 
		 viewport = camera.ViewportSize
		 scale = .(
			.(viewport.Y / , viewport.X / ),
			,
			
		)

		actionScale.Scale = scale
		crawlScale.Scale = scale
		ropeScale.Scale = scale
	

	 action, entry  (buttons) 
		 remaining = .(
			,
			(cooldowns[action]  ) - now
		)

		 active = state.mode == action

		entry.button.BackgroundColor3 = active
			 COLORS.Active
			 remaining >   COLORS.Dark
			 entry.color

		 action ==   state.mode ==  
			 charge = .(
				(now - state.started) / CONFIG.SlingChargeTime,
				,
				
			)

			entry.button.Text = .(
				,
				.(charge * )
			)
		 remaining >    active 
			entry.button.Text = .(
				,
				action:(),
				remaining
			)
		
			entry.button.Text = entry.text
		
	

	 now < noticeUntil 
		status.Text = notice
	 state.mode ==  
		status.Text = 
	 state.mode ==  
		status.Text = 
	 state.mode ==  
		status.Text = 
	 state.mode ==  
		status.Text = 
	 state.mode ==  
		status.Text = 
	
		status.Text = 
	
)

  (newCharacter)
	characterGeneration += 
	 generation = characterGeneration

	()
	()
	.(cooldowns)

	 deathConnection 
		deathConnection:()
		deathConnection = 
	

	character, humanoid, root = , , 

	 newHumanoid = newCharacter:(, )
	 newRoot = newCharacter:(, )

	  running
		 generation ~= characterGeneration
		 player.Character ~= newCharacter
		  newHumanoid
		  newRoot 
		
	

	character = newCharacter
	humanoid = newHumanoid
	root = newRoot

	deathConnection = humanoid.Died:(()
		()
		()
	)


(player.CharacterAdded, bindCharacter)

(player.CharacterRemoving, (removingCharacter)
	 removingCharacter == character 
		characterGeneration += 
		()
		()
		character, humanoid, root = , , 
	
)

  ()
	  running   

	running = 
	characterGeneration += 

	()
	()

	 deathConnection 
		deathConnection:()
		deathConnection = 
	

	 _, connection  (connections) 
		connection:()
	

	.(connections)


(shutdown.Event, ()
	()
	gui:()
)

(gui.Destroying, cleanup)
(.Destroying, ()
	()
	gui:()
)

 player.Character 
	.(bindCharacter, player.Character)