--!strict

local System = require(script.Parent)
local Animations = System.Animations
local Sounds = System.Sounds
local Enums = System.Enums
local Util = System.Util

local Action = Enums.Action
local ActionFlags = Enums.ActionFlags

local AirStep = Enums.AirStep
local MarioEyes = Enums.MarioEyes
local InputFlags = Enums.InputFlags
local MarioFlags = Enums.MarioFlags
local ParticleFlags = Enums.ParticleFlags

type Mario = System.Mario

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-- Helpers
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

local function stopRising(m: Mario)
	if m.Velocity.Y > 0 then
		m.Velocity *= Vector3.new(1, 0, 1)
	end
end

local function playFlipSounds(m: Mario, frame1: number, frame2: number, frame3: number)
	local animFrame = m.AnimFrame

	if animFrame == frame1 or animFrame == frame2 or animFrame == frame3 then
		m:PlaySound(Sounds.ACTION_SPIN)
	end
end

local function playKnockbackSound(m: Mario)
	if m.ActionArg == 0 and math.abs(m.ForwardVel) >= 28 then
		m:PlaySoundIfNoFlag(Sounds.MARIO_DOH, MarioFlags.MARIO_SOUND_PLAYED)
	else
		m:PlaySoundIfNoFlag(Sounds.MARIO_UH, MarioFlags.MARIO_SOUND_PLAYED)
	end
end

local function lavaBoostOnWall(m: Mario)
	local wall = m.Wall

	if wall then
		local angle = Util.Atan2s(wall.Normal.Z, wall.Normal.X)
		m.FaceAngle = Util.SetY(m.FaceAngle, angle)
	end

	if m.ForwardVel < 24 then
		m.ForwardVel = 24
	end

	if not m.Flags:Has(MarioFlags.METAL_CAP) then
		m.HurtCounter += if m.Flags:Has(MarioFlags.CAP_ON_HEAD) then 12 else 18
	end

	m:PlaySound(Sounds.MARIO_ON_FIRE)
	m:SetAction(Action.LAVA_BOOST, 1)
end

local function checkFallDamage(m: Mario, hardFallAction: number): boolean
	local fallHeight = m.PeakHeight - m.Position.Y
	local damageHeight = 1150

	if m.Action() == Action.TWIRLING then
		return false
	end

	if m.Velocity.Y < -55 and fallHeight > 3000 then
		m.HurtCounter += if m.Flags:Has(MarioFlags.CAP_ON_HEAD) then 16 else 24
		m:PlaySound(Sounds.MARIO_ATTACKED)
		m:SetAction(hardFallAction, 4)
	elseif fallHeight > damageHeight and not m:FloorIsSlippery() then
		m.HurtCounter += if m.Flags:Has(MarioFlags.CAP_ON_HEAD) then 8 else 12
		m:PlaySound(Sounds.MARIO_ATTACKED)
		m.SquishTimer = 30
	end

	return false
end

local function checkKickOrDiveInAir(m: Mario): boolean
	if m.Input:Has(InputFlags.B_PRESSED) then
		return m:SetAction(if m.ForwardVel > 28 then Action.DIVE else Action.JUMP_KICK)
	end

	return false
end

local function updateAirWithTurn(m: Mario)
	local dragThreshold = if m.Action() == Action.LONG_JUMP then 48 else 32
	m.ForwardVel = Util.ApproachFloat(m.ForwardVel, 0, 0.35)

	if m.Input:Has(InputFlags.NONZERO_ANALOG) then
		local intendedDYaw = m.IntendedYaw - m.FaceAngle.Y
		local intendedMag = m.IntendedMag / 32

		m.ForwardVel += 1.5 * Util.Coss(intendedDYaw) * intendedMag
		m.FaceAngle += Vector3int16.new(0, 512 * Util.Sins(intendedDYaw) * intendedMag, 0)
	end

	if m.ForwardVel > dragThreshold then
		m.ForwardVel -= 1
	end

	if m.ForwardVel < -16 then
		m.ForwardVel += 2
	end

	m.SlideVelX = m.ForwardVel * Util.Sins(m.FaceAngle.Y)
	m.SlideVelZ = m.ForwardVel * Util.Coss(m.FaceAngle.Y)
	m.Velocity = Vector3.new(m.SlideVelX, m.Velocity.Y, m.SlideVelZ)
end

local function updateAirWithoutTurn(m: Mario)
	local dragThreshold = 32

	if m.Action() == Action.LONG_JUMP then
		dragThreshold = 48
	end

	local sidewaysSpeed = 0
	m.ForwardVel = Util.ApproachFloat(m.ForwardVel, 0, 0.35)

	if m.Input:Has(InputFlags.NONZERO_ANALOG) then
		local intendedDYaw = m.IntendedYaw - m.FaceAngle.Y
		local intendedMag = m.IntendedMag / 32

		m.ForwardVel += intendedMag * Util.Coss(intendedDYaw) * 1.5
		sidewaysSpeed = intendedMag * Util.Sins(intendedDYaw) * 10
	end

	--! Uncapped air speed. Net positive when moving forward.
	if m.ForwardVel > dragThreshold then
		m.ForwardVel -= 1
	end

	if m.ForwardVel < -16 then
		m.ForwardVel += 2
	end

	m.SlideVelX = m.ForwardVel * Util.Sins(m.FaceAngle.Y)
	m.SlideVelZ = m.ForwardVel * Util.Coss(m.FaceAngle.Y)

	m.SlideVelX += sidewaysSpeed * Util.Sins(m.FaceAngle.Y + 0x4000)
	m.SlideVelZ += sidewaysSpeed * Util.Coss(m.FaceAngle.Y + 0x4000)

	m.Velocity = Vector3.new(m.SlideVelX, m.Velocity.Y, m.SlideVelZ)
end

local function updateLavaBoostOrTwirling(m: Mario)
	if m.Input:Has(InputFlags.NONZERO_ANALOG) then
		local intendedDYaw = m.IntendedYaw - m.FaceAngle.Y
		local intendedMag = m.IntendedMag / 32

		m.ForwardVel += Util.Coss(intendedDYaw) * intendedMag
		m.FaceAngle += Vector3int16.new(0, Util.Sins(intendedDYaw) * intendedMag * 1024, 0)

		if m.ForwardVel < 0 then
			m.FaceAngle += Vector3int16.new(0, 0x8000, 0)
			m.ForwardVel *= -1
		end

		if m.ForwardVel > 32 then
			m.ForwardVel -= 2
		end
	end

	m.SlideVelX = m.ForwardVel * Util.Sins(m.FaceAngle.Y)
	m.SlideVelZ = m.ForwardVel * Util.Coss(m.FaceAngle.Y)

	m.Velocity = Vector3.new(m.SlideVelX, m.Velocity.Y, m.SlideVelZ)
end

local function updateFlyingYaw(m: Mario)
	local targetYawVel = -Util.SignedShort(m.Controller.StickX * (m.ForwardVel / 4))

	if targetYawVel > 0 then
		if m.AngleVel.Y < 0 then
			m.AngleVel += Vector3int16.new(0, 0x40, 0)

			if m.AngleVel.Y > 0x10 then
				m.AngleVel = Util.SetY(m.AngleVel, 0x10)
			end
		else
			local y = Util.ApproachInt(m.AngleVel.Y, targetYawVel, 0x10, 0x20)
			m.AngleVel = Util.SetY(m.AngleVel, y)
		end
	elseif targetYawVel < 0 then
		if m.AngleVel.Y > 0 then
			m.AngleVel -= Vector3int16.new(0, 0x40, 0)

			if m.AngleVel.Y < -0x10 then
				m.AngleVel = Util.SetY(m.AngleVel, -0x10)
			end
		else
			local y = Util.ApproachInt(m.AngleVel.Y, targetYawVel, 0x20, 0x10)
			m.AngleVel = Util.SetY(m.AngleVel, y)
		end
	else
		local y = Util.ApproachInt(m.AngleVel.Y, 0, 0x40)
		m.AngleVel = Util.SetY(m.AngleVel, y)
	end

	m.FaceAngle += Vector3int16.new(0, m.AngleVel.Y, 0)
	m.FaceAngle = Util.SetZ(m.FaceAngle, 20 * -m.AngleVel.Y)
end

local function updateFlyingPitch(m: Mario)
	local targetPitchVel = -Util.SignedShort(m.Controller.StickY * (m.ForwardVel / 5))

	if targetPitchVel > 0 then
		if m.AngleVel.X < 0 then
			m.AngleVel += Vector3int16.new(0x40, 0, 0)

			if m.AngleVel.X > 0x20 then
				m.AngleVel = Util.SetX(m.AngleVel, 0x20)
			end
		else
			local x = Util.ApproachInt(m.AngleVel.X, targetPitchVel, 0x20, 0x40)
			m.AngleVel = Util.SetX(m.AngleVel, x)
		end
	elseif targetPitchVel < 0 then
		if m.AngleVel.X > 0 then
			m.AngleVel -= Vector3int16.new(0x40, 0, 0)

			if m.AngleVel.X < -0x20 then
				m.AngleVel = Util.SetX(m.AngleVel, -0x20)
			end
		else
			local x = Util.ApproachInt(m.AngleVel.X, targetPitchVel, 0x40, 0x20)
			m.AngleVel = Util.SetX(m.AngleVel, x)
		end
	else
		local x = Util.ApproachInt(m.AngleVel.X, 0, 0x40)
		m.AngleVel = Util.SetX(m.AngleVel, x)
	end
end

local function updateFlying(m: Mario)
	updateFlyingPitch(m)
	updateFlyingYaw(m)

	m.ForwardVel -= 2 * (m.FaceAngle.X / 0x4000) + 0.1
	m.ForwardVel -= 0.5 * (1 - Util.Coss(m.AngleVel.Y))

	if m.ForwardVel < 0 then
		m.ForwardVel = 0
	end

	if m.ForwardVel > 16 then
		m.FaceAngle += Vector3int16.new((m.ForwardVel - 32) * 6, 0, 0)
	elseif m.ForwardVel > 4 then
		m.FaceAngle += Vector3int16.new((m.ForwardVel - 32) * 10, 0, 0)
	else
		m.FaceAngle -= Vector3int16.new(0x400, 0, 0)
	end

	m.FaceAngle += Vector3int16.new(m.AngleVel.X, 0, 0)

	if m.FaceAngle.X > 0x2AAA then
		m.FaceAngle = Util.SetX(m.FaceAngle, 0x2AAA)
	end

	if m.FaceAngle.X < -0x2AAA then
		m.FaceAngle = Util.SetX(m.FaceAngle, -0x2AAA)
	end

	local velX = Util.Coss(m.FaceAngle.X) * Util.Sins(m.FaceAngle.Y)
	m.SlideVelX = m.ForwardVel * velX

	local velZ = Util.Coss(m.FaceAngle.X) * Util.Coss(m.FaceAngle.Y)
	m.SlideVelZ = m.ForwardVel * velZ

	local velY = Util.Sins(m.FaceAngle.X)
	m.Velocity = m.ForwardVel * Vector3.new(velX, velY, velZ)
end

local function commonAirActionStep(m: Mario, landAction: number, anim: Animation, stepArg: number): number
	local stepResult
	do
		updateAirWithoutTurn(m)
		stepResult = m:PerformAirStep(stepArg)
	end

	if stepResult == AirStep.NONE then
		m:SetAnimation(anim)
	elseif stepResult == AirStep.LANDED then
		if not checkFallDamage(m, Action.HARD_BACKWARD_GROUND_KB) then
			m:SetAction(landAction)
		end
	elseif stepResult == AirStep.HIT_WALL then
		m:SetAnimation(anim)

		if m.ForwardVel > 16 then
			m:BonkReflection()
			m.FaceAngle += Vector3int16.new(0, 0x8000, 0)

			if m.Wall then
				m:SetAction(Action.AIR_HIT_WALL)
			else
				stopRising(m)

				if m.ForwardVel >= 38 then
					m.ParticleFlags:Add(ParticleFlags.VERTICAL_STAR)
					m:SetAction(Action.BACKWARD_AIR_KB)
				else
					if m.ForwardVel > 8 then
						m:SetForwardVel(-8)
					end

					m:SetAction(Action.SOFT_BONK)
				end
			end
		else
			m:SetForwardVel(0)
		end
	elseif stepResult == AirStep.GRABBED_LEDGE then
		m:SetAnimation(Animations.IDLE_ON_LEDGE)
		m:SetAction(Action.LEDGE_GRAB)
	elseif stepResult == AirStep.GRABBED_CEILING then
		m:SetAction(Action.START_HANGING)
	elseif stepResult == AirStep.HIT_LAVA_WALL then
		lavaBoostOnWall(m)
	end

	return stepResult
end

local function commonRolloutStep(m: Mario, anim: Animation)
	local stepResult

	if m.ActionState == 0 then
		m.Velocity = Util.SetY(m.Velocity, 30)
		m.ActionState = 1
	end

	m:PlaySound(Sounds.ACTION_TERRAIN_JUMP)
	updateAirWithoutTurn(m)

	stepResult = m:PerformAirStep()

	if stepResult == AirStep.NONE then
		if m.ActionState == 1 then
			if m:SetAnimation(anim) == 4 then
				m:PlaySound(Sounds.ACTION_SPIN)
			end
		else
			m:SetAnimation(Animations.GENERAL_FALL)
		end
	elseif stepResult == AirStep.LANDED then
		m:SetAction(Action.FREEFALL_LAND_STOP)
		m:PlayLandingSound()
	elseif stepResult == AirStep.HIT_WALL then
		m:SetForwardVel(0)
	elseif stepResult == AirStep.HIT_LAVA_WALL then
		lavaBoostOnWall(m)
	end

	if m.ActionState == 1 and m:IsAnimPastEnd() then
		m.ActionState = 2
	end
end

local function commonAirKnockbackStep(
	m: Mario,
	landAction: number,
	hardFallAction: number,
	anim: Animation,
	speed: number
)
	local stepResult
	do
		m:SetForwardVel(speed)
		stepResult = m:PerformAirStep()
	end

	if stepResult == AirStep.NONE then
		m:SetAnimation(anim)
	elseif stepResult == AirStep.LANDED then
		if not checkFallDamage(m, hardFallAction) then
			local action = m.Action()

			if action == Action.THROWN_FORWARD or action == Action.THROWN_BACKWARD then
				m:SetAction(landAction, m.HurtCounter)
			else
				m:SetAction(landAction, m.ActionArg)
			end
		end
	elseif stepResult == AirStep.HIT_WALL then
		m:SetAnimation(Animations.BACKWARD_AIR_KB)
		m:BonkReflection()

		stopRising(m)
		m:SetForwardVel(-speed)
	elseif stepResult == AirStep.HIT_LAVA_WALL then
		lavaBoostOnWall(m)
	end

	return stepResult
end

local function checkWallKick(m: Mario)
	if m.WallKickTimer ~= 0 then
		if m.Input:Has(InputFlags.A_PRESSED) then
			if m.PrevAction() == Action.AIR_HIT_WALL then
				m.FaceAngle += Vector3int16.new(0, 0x8000, 0)
			end
		end
	end

	return false
end

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-- Actions
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

local AIR_STEP_CHECK_BOTH = bit32.bor(AirStep.CHECK_LEDGE_GRAB, AirStep.CHECK_HANG)
local DEF_ACTION: (number, (Mario) -> boolean) -> () = System.RegisterAction

DEF_ACTION(Action.JUMP, function(m: Mario)
	if checkKickOrDiveInAir(m) then
		return true
	end

	if m.Input:Has(InputFlags.Z_PRESSED) then
		return m:SetAction(Action.GROUND_POUND)
	end

	m:PlayMarioSound(Sounds.ACTION_TERRAIN_JUMP)
	commonAirActionStep(m, Action.JUMP_LAND, Animations.SINGLE_JUMP, AIR_STEP_CHECK_BOTH)

	return false
end)

DEF_ACTION(Action.DOUBLE_JUMP, function(m: Mario)
	local anim = if m.Velocity.Y >= 0 then Animations.DOUBLE_JUMP_RISE else Animations.DOUBLE_JUMP_FALL

	if checkKickOrDiveInAir(m) then
		return true
	end

	if m.Input:Has(InputFlags.Z_PRESSED) then
		return m:SetAction(Action.GROUND_POUND)
	end

	m:PlayMarioSound(Sounds.ACTION_TERRAIN_JUMP, Sounds.MARIO_HOOHOO)
	commonAirActionStep(m, Action.DOUBLE_JUMP_LAND, anim, AIR_STEP_CHECK_BOTH)

	return false
end)

DEF_ACTION(Action.TRIPLE_JUMP, function(m: Mario)
	if m.Input:Has(InputFlags.B_PRESSED) then
		return m:SetAction(Action.DIVE)
	end

	if m.Input:Has(InputFlags.Z_PRESSED) then
		return m:SetAction(Action.GROUND_POUND)
	end

	m:PlayMarioSound(Sounds.ACTION_TERRAIN_JUMP)
	commonAirActionStep(m, Action.TRIPLE_JUMP_LAND, Animations.TRIPLE_JUMP, 0)

	playFlipSounds(m, 2, 8, 20)
	return false
end)

DEF_ACTION(Action.BACKFLIP, function(m: Mario)
	if m.Input:Has(InputFlags.Z_PRESSED) then
		return m:SetAction(Action.GROUND_POUND)
	end

	m:PlayMarioSound(Sounds.ACTION_TERRAIN_JUMP, Sounds.MARIO_YAH_WAH_HOO)
	commonAirActionStep(m, Action.BACKFLIP_LAND, Animations.BACKFLIP, 0)

	playFlipSounds(m, 2, 3, 17)
	return false
end)

DEF_ACTION(Action.FREEFALL, function(m: Mario)
	if m.Input:Has(InputFlags.B_PRESSED) then
		return m:SetAction(Action.DIVE)
	end

	if m.Input:Has(InputFlags.Z_PRESSED) then
		return m:SetAction(Action.GROUND_POUND)
	end

	local anim

	if m.ActionArg == 0 then
		anim = Animations.GENERAL_FALL
	elseif m.ActionArg == 1 then
		anim = Animations.FALL_FROM_SLIDE
	elseif m.ActionArg == 2 then
		anim = Animations.FALL_FROM_SLIDE_KICK
	end

	commonAirActionStep(m, Action.FREEFALL_LAND, anim, AirStep.CHECK_LEDGE_GRAB)
	return false
end)

DEF_ACTION(Action.SIDE_FLIP, function(m: Mario)
	if m.Input:Has(InputFlags.B_PRESSED) then
		return m:SetAction(Action.DIVE, 0)
	end

	if m.Input:Has(InputFlags.Z_PRESSED) then
		return m:SetAction(Action.GROUND_POUND)
	end

	m:PlayMarioSound(Sounds.ACTION_TERRAIN_JUMP)
	commonAirActionStep(m, Action.SIDE_FLIP_LAND, Animations.SLIDEFLIP, AirStep.CHECK_LEDGE_GRAB)

	if m.AnimFrame == 6 then
		m:PlaySound(Sounds.ACTION_SIDE_FLIP)
	end

	return false
end)

DEF_ACTION(Action.WALL_KICK_AIR, function(m: Mario)
	if m.Input:Has(InputFlags.B_PRESSED) then
		return m:SetAction(Action.DIVE)
	end

	if m.Input:Has(InputFlags.Z_PRESSED) then
		return m:SetAction(Action.GROUND_POUND)
	end

	m:PlayJumpSound()
	commonAirActionStep(m, Action.JUMP_LAND, Animations.SLIDEJUMP, AirStep.CHECK_LEDGE_GRAB)

	return false
end)

DEF_ACTION(Action.LONG_JUMP, function(m: Mario)
	local anim = if m.LongJumpIsSlow then Animations.SLOW_LONGJUMP else Animations.FAST_LONGJUMP

	m:PlayMarioSound(Sounds.ACTION_TERRAIN_JUMP, Sounds.MARIO_YAHOO)
	commonAirActionStep(m, Action.LONG_JUMP_LAND, anim, AirStep.CHECK_LEDGE_GRAB)

	return false
end)

DEF_ACTION(Action.TWIRLING, function(m: Mario)
	local startTwirlYaw = m.TwirlYaw
	local yawVelTarget = 0x1000

	if m.Input:Has(InputFlags.A_DOWN) then
		yawVelTarget = 0x2000
	end

	local yVel = Util.ApproachInt(m.AngleVel.Y, yawVelTarget, 0x200)
	m.AngleVel = Util.SetY(m.AngleVel, yVel)
	m.TwirlYaw += yVel

	m:SetAnimation(if m.ActionArg == 0 then Animations.START_TWIRL else Animations.TWIRL)

	if m:IsAnimPastEnd() then
		m.ActionArg = 1
	end

	if startTwirlYaw > m.TwirlYaw then
		m:PlaySound(Sounds.ACTION_TWIRL)
	end

	local step = m:PerformAirStep()

	if step == AirStep.LANDED then
		m:SetAction(Action.TWIRL_LAND)
	elseif step == AirStep.HIT_WALL then
		m:BonkReflection(false)
	elseif step == AirStep.HIT_LAVA_WALL then
		lavaBoostOnWall(m)
	end

	m.GfxAngle += Vector3int16.new(0, m.TwirlYaw, 0)
	return false
end)

DEF_ACTION(Action.DIVE, function(m: Mario)
	local airStep

	if m.ActionArg == 0 then
		m:PlayMarioSound(Sounds.ACTION_THROW, Sounds.MARIO_HOOHOO)
	else
		m:PlayMarioSound(Sounds.ACTION_TERRAIN_JUMP)
	end

	m:SetAnimation(Animations.DIVE)
	updateAirWithoutTurn(m)
	airStep = m:PerformAirStep()

	if airStep == AirStep.NONE then
		if m.Velocity.Y < 0 and m.FaceAngle.X > -0x2AAA then
			m.FaceAngle -= Vector3int16.new(0x200, 0, 0)

			if m.FaceAngle.X < -0x2AAA then
				m.FaceAngle = Util.SetX(m.FaceAngle, -0x2AAA)
			end
		end

		m.GfxAngle = Util.SetX(m.GfxAngle, -m.FaceAngle.X)
	elseif airStep == AirStep.LANDED then
		if not checkFallDamage(m, Action.HARD_FORWARD_GROUND_KB) then
			m:SetAction(Action.DIVE_SLIDE)
		end

		m.FaceAngle *= Vector3int16.new(0, 1, 1)
	elseif airStep == AirStep.HIT_WALL then
		m:BonkReflection(true)
		m.FaceAngle *= Vector3int16.new(0, 1, 1)

		stopRising(m)

		m.ParticleFlags:Add(ParticleFlags.VERTICAL_STAR)
		m:SetAction(Action.BACKWARD_AIR_KB)
	elseif airStep == AirStep.HIT_LAVA_WALL then
		lavaBoostOnWall(m)
	end

	return false
end)

DEF_ACTION(Action.WATER_JUMP, function(m: Mario)
	if m.ForwardVel < 15 then
		m:SetForwardVel(15)
	end

	m:PlaySound(Sounds.ACTION_WATER_EXIT)
	m:SetAnimation(Animations.SINGLE_JUMP)

	local step = m:PerformAirStep(AirStep.CHECK_LEDGE_GRAB)

	if step == AirStep.LANDED then
		m:SetAction(Action.JUMP_LAND)
	elseif step == AirStep.HIT_WALL then
		m:SetForwardVel(15)
	elseif step == AirStep.GRABBED_LEDGE then
		m:SetAnimation(Animations.IDLE_ON_LEDGE)
		m:SetAction(Action.LEDGE_GRAB)
	elseif step == AirStep.HIT_LAVA_WALL then
		lavaBoostOnWall(m)
	end

	return false
end)

DEF_ACTION(Action.STEEP_JUMP, function(m: Mario)
	local airStep

	if m.Input:Has(InputFlags.B_PRESSED) then
		return m:SetAction(Action.DIVE)
	end

	m:PlayMarioSound(Sounds.ACTION_TERRAIN_JUMP)
	m:SetForwardVel(0.98 * m.ForwardVel)
	airStep = m:PerformAirStep()

	if airStep == AirStep.LANDED then
		if not checkFallDamage(m, Action.HARD_BACKWARD_GROUND_KB) then
			m.FaceAngle *= Vector3int16.new(0, 1, 1)
			m:SetAction(if m.ForwardVel < 0 then Action.BEGIN_SLIDING else Action.JUMP_LAND)
		end
	elseif airStep == AirStep.HIT_WALL then
		m:SetForwardVel(0)
	elseif airStep == AirStep.HIT_LAVA_WALL then
		lavaBoostOnWall(m)
	end

	m:SetAnimation(Animations.SINGLE_JUMP)
	m.GfxAngle = Util.SetY(m.GfxAngle, m.SteepJumpYaw)

	return false
end)

DEF_ACTION(Action.GROUND_POUND, function(m: Mario)
	local stepResult
	local yOffset

	m:PlaySoundIfNoFlag(Sounds.ACTION_THROW, MarioFlags.ACTION_SOUND_PLAYED)

	if m.ActionState == 0 then
		if m.ActionTimer < 10 then
			yOffset = 20 - 2 * m.ActionTimer

			if m.Position.Y + yOffset + 160 < m.CeilHeight then
				m.Position += Vector3.new(0, yOffset, 0)
				m.PeakHeight = m.Position.Y
			end
		end

		m.Velocity = Util.SetY(m.Velocity, -50)
		m:SetForwardVel(0)

		m:SetAnimation(if m.ActionArg == 0 then Animations.START_GROUND_POUND else Animations.TRIPLE_JUMP_GROUND_POUND)

		if m.ActionTimer == 0 then
			m:PlaySound(Sounds.ACTION_SPIN)
		end

		m.ActionTimer += 1
		m.GfxAngle = Vector3int16.new(0, m.FaceAngle.Y, 0)

		if m.ActionTimer >= m.AnimFrameCount + 4 then
			m:PlaySound(Sounds.MARIO_GROUND_POUND_WAH)
			m.ActionState = 1
		end
	else
		m:SetAnimation(Animations.GROUND_POUND)
		stepResult = m:PerformAirStep()

		if stepResult == AirStep.LANDED then
			m:PlayHeavyLandingSound(Sounds.ACTION_HEAVY_LANDING)

			if not checkFallDamage(m, Action.HARD_BACKWARD_GROUND_KB) then
				m.ParticleFlags:Add(ParticleFlags.MIST_CIRCLE, ParticleFlags.HORIZONTAL_STAR)
				m:SetAction(Action.GROUND_POUND_LAND)
			end
		elseif stepResult == AirStep.HIT_WALL then
			m:SetForwardVel(-16)
			stopRising(m)

			m.ParticleFlags:Add(ParticleFlags.VERTICAL_STAR)
			m:SetAction(Action.BACKWARD_AIR_KB)
		end
	end

	return false
end)

DEF_ACTION(Action.BURNING_JUMP, function(m: Mario)
	m:PlayMarioSound(Sounds.ACTION_TERRAIN_JUMP)
	m:SetForwardVel(m.ForwardVel)

	if m:PerformAirStep() == AirStep.LANDED then
		m:PlayLandingSound()
		m:SetAction(Action.BURNING_GROUND)
	end

	m:SetAnimation(Animations.GENERAL_FALL)
	m.ParticleFlags:Add(ParticleFlags.FIRE)
	m:PlaySound(Sounds.MOVING_LAVA_BURN)

	m.BurnTimer += 3
	m.Health -= 10

	if m.Health < 0x100 then
		m.Health = 0xFF
	end

	return false
end)

DEF_ACTION(Action.BURNING_FALL, function(m: Mario)
	m:SetForwardVel(m.ForwardVel)

	if m:PerformAirStep() == AirStep.LANDED then
		m:PlayLandingSound(Sounds.ACTION_TERRAIN_LANDING)
		m:SetAction(Action.BURNING_GROUND)
	end

	m:SetAnimation(Animations.GENERAL_FALL)
	m.ParticleFlags:Add(ParticleFlags.FIRE)

	m.BurnTimer += 3
	m.Health -= 10

	if m.Health < 0x100 then
		m.Health = 0xFF
	end

	return false
end)

DEF_ACTION(Action.BACKWARD_AIR_KB, function(m: Mario)
	if checkWallKick(m) then
		return true
	end

	playKnockbackSound(m)
	commonAirKnockbackStep(
		m,
		Action.BACKWARD_GROUND_KB,
		Action.HARD_BACKWARD_GROUND_KB,
		Animations.BACKWARD_AIR_KB,
		-16
	)

	return false
end)

DEF_ACTION(Action.FORWARD_AIR_KB, function(m: Mario)
	if checkWallKick(m) then
		return true
	end

	playKnockbackSound(m)
	commonAirKnockbackStep(m, Action.FORWARD_GROUND_KB, Action.HARD_FORWARD_GROUND_KB, Animations.FORWARD_AIR_KB, 16)

	return false
end)

DEF_ACTION(Action.HARD_BACKWARD_AIR_KB, function(m: Mario)
	if checkWallKick(m) then
		return true
	end

	playKnockbackSound(m)
	commonAirKnockbackStep(
		m,
		Action.HARD_BACKWARD_GROUND_KB,
		Action.HARD_BACKWARD_GROUND_KB,
		Animations.BACKWARD_AIR_KB,
		-16
	)

	return false
end)

DEF_ACTION(Action.HARD_FORWARD_AIR_KB, function(m: Mario)
	if checkWallKick(m) then
		return true
	end

	playKnockbackSound(m)
	commonAirKnockbackStep(
		m,
		Action.HARD_FORWARD_GROUND_KB,
		Action.HARD_FORWARD_GROUND_KB,
		Animations.FORWARD_AIR_KB,
		16
	)

	return false
end)

DEF_ACTION(Action.THROWN_BACKWARD, function(m: Mario)
	local landAction = if m.ActionArg ~= 0 then Action.HARD_BACKWARD_GROUND_KB else Action.BACKWARD_GROUND_KB

	m:PlaySoundIfNoFlag(Sounds.MARIO_WAAAOOOW, MarioFlags.MARIO_SOUND_PLAYED)
	commonAirKnockbackStep(m, landAction, Action.HARD_BACKWARD_GROUND_KB, Animations.BACKWARD_AIR_KB, m.ForwardVel)

	m.ForwardVel *= 0.98
	return false
end)

DEF_ACTION(Action.THROWN_FORWARD, function(m: Mario)
	local landAction = if m.ActionArg ~= 0 then Action.HARD_FORWARD_GROUND_KB else Action.FORWARD_GROUND_KB

	m:PlaySoundIfNoFlag(Sounds.MARIO_WAAAOOOW, MarioFlags.MARIO_SOUND_PLAYED)

	if
		commonAirKnockbackStep(m, landAction, Action.HARD_FORWARD_GROUND_KB, Animations.FORWARD_AIR_KB, m.ForwardVel)
		== AirStep.NONE
	then
		local pitch = Util.Atan2s(m.ForwardVel, -m.Velocity.Y)

		if pitch > 0x1800 then
			pitch = 0x1800
		end

		m.GfxAngle = Util.SetX(m.GfxAngle, pitch + 0x1800)
	end

	m.ForwardVel *= 0.98
	return false
end)

DEF_ACTION(Action.SOFT_BONK, function(m: Mario)
	if checkWallKick(m) then
		return true
	end

	playKnockbackSound(m)
	commonAirKnockbackStep(
		m,
		Action.FREEFALL_LAND,
		Action.HARD_BACKWARD_GROUND_KB,
		Animations.GENERAL_FALL,
		m.ForwardVel
	)

	return false
end)

DEF_ACTION(Action.AIR_HIT_WALL, function(m: Mario)
	m.ActionTimer += 1

	if m.ActionTimer <= 2 then
		if m.Input:Has(InputFlags.A_PRESSED) then
			m.Velocity = Util.SetY(m.Velocity, 52)
			m.FaceAngle += Vector3int16.new(0, 0x8000, 0)
			return m:SetAction(Action.WALL_KICK_AIR)
		end
	elseif m.ForwardVel >= 38 then
		m.WallKickTimer = 5

		if m.Velocity.Y > 0 then
			m.Velocity = Util.SetY(m.Velocity, 0)
		end

		m.ParticleFlags:Add(ParticleFlags.VERTICAL_STAR)
		return m:SetAction(Action.BACKWARD_AIR_KB)
	else
		m.WallKickTimer = 5

		if m.Velocity.Y > 0 then
			m.Velocity = Util.SetY(m.Velocity, 0)
		end

		if m.ForwardVel > 8 then
			m:SetForwardVel(-8)
		end

		return m:SetAction(Action.SOFT_BONK)
	end

	return m:SetAnimation(Animations.START_WALLKICK) > 0
end)

DEF_ACTION(Action.FORWARD_ROLLOUT, function(m: Mario)
	commonRolloutStep(m, Animations.FORWARD_SPINNING)
	return false
end)

DEF_ACTION(Action.BACKWARD_ROLLOUT, function(m: Mario)
	commonRolloutStep(m, Animations.BACKWARD_SPINNING)
	return false
end)

DEF_ACTION(Action.BUTT_SLIDE_AIR, function(m: Mario)
	local stepResult
	m.ActionTimer += 1

	if m.ActionTimer > 30 and m.Position.Y - m.FloorHeight > 500 then
		return m:SetAction(Action.FREEFALL, 1)
	end

	updateAirWithTurn(m)
	stepResult = m:PerformAirStep()

	if stepResult == AirStep.LANDED then
		if m.ActionState == 0 and m.Velocity.Y < 0 then
			local floor = m.Floor

			if floor and floor.Normal.Y > 0.9848077 then
				m.Velocity *= Vector3.new(1, -0.5, 1)
				m.ActionState = 1
			else
				m:SetAction(Action.BUTT_SLIDE)
			end
		else
			m:SetAction(Action.BUTT_SLIDE)
		end

		m:PlayLandingSound()
	elseif stepResult == AirStep.HIT_WALL then
		stopRising(m)
		m.ParticleFlags:Add(ParticleFlags.VERTICAL_STAR)
		m:SetAction(Action.BACKWARD_AIR_KB)
	elseif stepResult == AirStep.HIT_LAVA_WALL then
		lavaBoostOnWall(m)
	end

	m:SetAnimation(Animations.SLIDE)
	return false
end)

DEF_ACTION(Action.LAVA_BOOST, function(m: Mario)
	local stepResult
	m:PlaySoundIfNoFlag(Sounds.MARIO_ON_FIRE, MarioFlags.MARIO_SOUND_PLAYED)

	if not m.Input:Has(InputFlags.NONZERO_ANALOG) then
		m.ForwardVel = Util.ApproachFloat(m.ForwardVel, 0, 0.35)
	end

	updateLavaBoostOrTwirling(m)
	stepResult = m:PerformAirStep()

	if stepResult == AirStep.LANDED then
		local floor = m.Floor
		local floorType: Enum.Material?

		if floor then
			floorType = floor.Material
		end

		if floorType == Enum.Material.CrackedLava then
			m.ActionState = 0

			if not m.Flags:Has(MarioFlags.METAL_CAP) then
				m.HurtCounter += if m.Flags:Has(MarioFlags.CAP_ON_HEAD) then 12 else 18
			end

			m.Velocity = Util.SetY(m.Velocity, 84)
			m:PlaySound(Sounds.MARIO_ON_FIRE)
		else
			m:PlayHeavyLandingSound(Sounds.ACTION_TERRAIN_BODY_HIT_GROUND)

			if m.ActionState < 2 and m.Velocity.Y < 0 then
				m.Velocity *= Vector3.new(1, -0.4, 1)
				m:SetForwardVel(m.ForwardVel / 2)
				m.ActionState += 1
			else
				m:SetAction(Action.LAVA_BOOST_LAND)
			end
		end
	elseif stepResult == AirStep.HIT_WALL then
		m:BonkReflection()
	elseif stepResult == AirStep.HIT_LAVA_WALL then
		lavaBoostOnWall(m)
	end

	m:SetAnimation(Animations.FIRE_LAVA_BURN)

	if not m.Flags:Has(MarioFlags.METAL_CAP) and m.Velocity.Y > 0 then
		m.ParticleFlags:Add(ParticleFlags.FIRE)

		if m.ActionState == 0 then
			m:PlaySound(Sounds.MOVING_LAVA_BURN)
		end
	end

	m.BodyState.EyeState = MarioEyes.DEAD
	return false
end)

DEF_ACTION(Action.SLIDE_KICK, function(m: Mario)
	local stepResult

	if m.ActionState == 0 and m.ActionTimer == 0 then
		m:PlayMarioSound(Sounds.ACTION_TERRAIN_JUMP, Sounds.MARIO_HOOHOO)
		m:SetAnimation(Animations.SLIDE_KICK)
	end

	m.ActionTimer += 1

	if m.ActionTimer > 30 and m.Position.Y - m.FloorHeight > 500 then
		return m:SetAction(Action.FREEFALL, 2)
	end

	updateAirWithoutTurn(m)
	stepResult = m:PerformAirStep()

	if stepResult == AirStep.NONE then
		if m.ActionState == 0 then
			local tilt = Util.Atan2s(m.ForwardVel, -m.Velocity.Y)

			if tilt > 0x1800 then
				tilt = 0x1800
			end

			m.GfxAngle = Util.SetX(m.GfxAngle, tilt)
		end
	elseif stepResult == AirStep.LANDED then
		if m.ActionState == 0 and m.Velocity.Y < 0 then
			m.Velocity *= Vector3.new(1, -0.5, 1)
			m.ActionState = 1
			m.ActionTimer = 0
		else
			m:SetAction(Action.SLIDE_KICK_SLIDE)
		end

		m:PlayLandingSound()
	elseif stepResult == AirStep.HIT_WALL then
		stopRising(m)
		m.ParticleFlags:Add(ParticleFlags.VERTICAL_STAR)
		m:SetAction(Action.BACKWARD_AIR_KB)
	elseif stepResult == AirStep.HIT_LAVA_WALL then
		lavaBoostOnWall(m)
	end

	return false
end)

DEF_ACTION(Action.JUMP_KICK, function(m: Mario)
	local stepResult

	if m.ActionState == 0 then
		m:PlaySoundIfNoFlag(Sounds.MARIO_PUNCH_HOO, MarioFlags.MARIO_SOUND_PLAYED)
		m.AnimReset = true

		m:SetAnimation(Animations.AIR_KICK)
		m.ActionState = 1
	end

	local animFrame = m.AnimFrame

	if animFrame == 0 then
		m.BodyState.PunchType = 2
		m.BodyState.PunchTimer = 6
	end

	if animFrame >= 0 and animFrame < 8 then
		m.Flags:Add(MarioFlags.KICKING)
	end

	updateAirWithoutTurn(m)
	stepResult = m:PerformAirStep()

	if stepResult == AirStep.LANDED then
		if not checkFallDamage(m, Action.HARD_BACKWARD_GROUND_KB) then
			m:SetAction(Action.FREEFALL_LAND)
		end
	elseif stepResult == AirStep.HIT_WALL then
		m:SetForwardVel(0)
	end

	return false
end)

DEF_ACTION(Action.FLYING, function(m: Mario)
	local startPitch = m.FaceAngle.X

	if m.Input:Has(InputFlags.Z_PRESSED) then
		return m:SetAction(Action.GROUND_POUND)
	end

	if not m.Flags:Has(MarioFlags.WING_CAP) then
		return m:SetAction(Action.FREEFALL)
	end

	if m.ActionState == 0 then
		if m.ActionArg == 0 then
			m:SetAnimation(Animations.FLY_FROM_CANNON)
		else
			m:SetAnimation(Animations.FORWARD_SPINNING_FLIP)

			if m.AnimFrame == 1 then
				m:PlaySound(Sounds.ACTION_SPIN)
			end
		end

		if m:IsAnimAtEnd() then
			m:SetAnimation(Animations.WING_CAP_FLY)
			m.ActionState = 1
		end
	end

	local stepResult
	do
		updateFlying(m)
		stepResult = m:PerformAirStep()
	end

	if stepResult == AirStep.NONE then
		m.GfxAngle = Util.SetX(m.GfxAngle, -m.FaceAngle.X)
		m.GfxAngle = Util.SetZ(m.GfxAngle, m.FaceAngle.Z)
		m.ActionTimer = 0
	elseif stepResult == AirStep.LANDED then
		m:SetAction(Action.DIVE_SLIDE)
		m:SetAnimation(Animations.DIVE)

		m:SetAnimToFrame(7)
		m.FaceAngle *= Vector3int16.new(0, 1, 1)
	elseif stepResult == AirStep.HIT_WALL then
		if m.Wall then
			m:SetForwardVel(-16)
			m.FaceAngle *= Vector3int16.new(0, 1, 1)

			stopRising(m)
			m:PlaySound(if m.Flags:Has(MarioFlags.METAL_CAP) then Sounds.ACTION_METAL_BONK else Sounds.ACTION_BONK)

			m.ParticleFlags:Add(ParticleFlags.VERTICAL_STAR)
			m:SetAction(Action.BACKWARD_AIR_KB)
		else
			m.ActionTimer += 1

			if m.ActionTimer == 0 then
				m:PlaySound(Sounds.ACTION_HIT)
			end

			if m.ActionTimer == 30 then
				m.ActionTimer = 0
			end

			m.FaceAngle -= Vector3int16.new(0x200, 0, 0)

			if m.FaceAngle.X < -0x2AAA then
				m.FaceAngle = Util.SetX(m.FaceAngle, -0x2AAA)
			end

			m.GfxAngle = Util.SetX(m.GfxAngle, -m.FaceAngle.X)
			m.GfxAngle = Util.SetZ(m.GfxAngle, m.FaceAngle.Z)
		end
	elseif stepResult == AirStep.HIT_LAVA_WALL then
		lavaBoostOnWall(m)
	end

	if m.FaceAngle.X > 0x800 and m.ForwardVel >= 48 then
		m.ParticleFlags:Add(ParticleFlags.DUST)
	end

	if startPitch <= 0 and m.FaceAngle.X > 0 and m.ForwardVel >= 48 then
		m:PlaySound(Sounds.ACTION_FLYING_FAST)
		m:PlaySound(Sounds.MARIO_YAHOO_WAHA_YIPPEE)
	end

	m:PlaySound(Sounds.MOVING_FLYING)
	m:AdjustSoundForSpeed()

	return false
end)

DEF_ACTION(Action.FLYING_TRIPLE_JUMP, function(m: Mario)
	if m.Input:Has(InputFlags.B_PRESSED) then
		return m:SetAction(Action.DIVE)
	end

	if m.Input:Has(InputFlags.Z_PRESSED) then
		return m:SetAction(Action.GROUND_POUND)
	end

	m:PlayMarioSound(Sounds.ACTION_TERRAIN_JUMP, Sounds.MARIO_YAHOO)

	if m.ActionState == 0 then
		m:SetAnimation(Animations.TRIPLE_JUMP_FLY)

		if m.AnimFrame == 7 then
			m:PlaySound(Sounds.ACTION_SPIN)
		end

		if m:IsAnimPastEnd() then
			m:SetAnimation(Animations.FORWARD_SPINNING)
			m.ActionState = 1
		end
	end

	if m.ActionState == 1 and m.AnimFrame == 1 then
		m:PlaySound(Sounds.ACTION_SPIN)
	end

	if m.Velocity.Y < 4 then
		if m.ForwardVel < 32 then
			m:SetForwardVel(32)
		end

		m:SetAction(Action.FLYING, 1)
	end

	m.ActionTimer += 1

	local stepResult
	do
		updateAirWithoutTurn(m)
		stepResult = m:PerformAirStep()
	end

	if stepResult == AirStep.LANDED then
		if not checkFallDamage(m, Action.HARD_BACKWARD_GROUND_KB) then
			m:SetAction(Action.DOUBLE_JUMP_LAND)
		end
	elseif stepResult == AirStep.HIT_WALL then
		m:BonkReflection()
	elseif stepResult == AirStep.HIT_LAVA_WALL then
		lavaBoostOnWall(m)
	end

	return false
end)

DEF_ACTION(Action.SPAWN_SPIN_AIRBORNE, function(m: Mario)
	m:SetForwardVel(m.ForwardVel)

	if m:PerformAirStep() == AirStep.LANDED then
		m:PlayLandingSound(Sounds.ACTION_TERRAIN_LANDING)
		m:SetAction(Action.SPAWN_SPIN_LANDING)
	end

	if m.ActionState == 0 and m.Position.Y - m.FloorHeight > 300 then
		if m:SetAnimation(Animations.FORWARD_SPINNING) == 0 then
			m:PlaySound(Sounds.ACTION_SPIN)
		end
	else
		m.ActionState = 1
		m:SetAnimation(Animations.GENERAL_FALL)
	end

	return false
end)

DEF_ACTION(Action.SPAWN_SPIN_LANDING, function(m: Mario)
	m:StopAndSetHeightToFloor()
	m:SetAnimation(Animations.GENERAL_LAND)

	if m:IsAnimAtEnd() then
		m:SetAction(Action.IDLE)
	end

	return false
end)

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------