Announcing a new series of short posts, TTYD Battle Bits!

I’m excited to finally announce this new project! I’m going to be doing a brand-new series of posts called “Paper Mario: TTYD Battle Bits”, which covers various unknown, obscure, or misunderstood aspects or interactions of the game’s battle system in little bite-size chunks!

Catch updates on my @ttydbattlebits Twitter account, here on my Super Mario Files blog, or other social platforms on Linktree! I’ll be aiming to get new posts out weekly, but we’ll see how much I can get in the habit of getting out on a sustainable basis.

Demystifying the Mystic: The Mechanics Behind Merlee

Mario pondering purchasing a package of Merlee's spells.

Merlee, a recurring character from the ’00s Paper Mario games, is a fortune-teller who speaks in riddles and gives Mario various boons at random intervals. These effects can be timely at their best and pointless at their worst, but despite the unpredictability of their activation, they’re at least a fun curiosity. Merlee’s magic works fairly similarly in the first two Paper Mario titles, but there’s a surprising amount of little differences between them, and quirks in each, so I thought it’d be worth doing a deep dive on both.

Overview

In both games, Merlee sells packages of spells (or “curses”) that activate a certain number of times before running out, for increasing duration (and oddly enough, increasing cost per spell for the more expensive packages): 5 spells for 5 coins, 10 spells for 20 coins, or 20 spells for 50 coins.

The effects of these spells include:

  • ATK-Up: Mario’s next jump or hammer attack will have its attack power raised by 3*.
  • DEF-Up: On Mario’s next defending turn, his defense power will be raised by 3.
  • EXP Bonus: Experience points earned from a fight will be doubled.
  • Coin Bonus: Coins dropped after a fight will be tripled. (This effect stacks multiplicatively with Money Money in 64, but additively in TTYD; e.g. having 2 Money Moneys equipped will give you an additional +2x from the curse and +2x from the badges, for a total of 5x, not 9x).

* Beneficiaries of this curse might also include exploding Bulky Bob-ombs, if Mario opts to use a boosted Fire Drive on them.

Broadly, each curse has a turn count before the next curse is allowed to activate, but the specifics of when the turn count elapses, as well as when the curse type is determined, differs a fair bit between the games, so let’s just tackle the games individually. Let’s start with The Thousand-Year Door, since its mechanics are generally simpler:

Merlee in The Thousand-Year Door

In TTYD, Merlee’s spells choose a turn count before activation, then only when those turns have elapsed is a type of curse chosen. This spell is then activated at the earliest possible time, persisting across battles, if necessary.

The current state of Merlee’s spells is stored in three variables in “PouchData“:

  • Number of spells remaining (this doesn’t include the current spell, if a turn count is counting down or if a specific spell has been chosen but not activated.)
  • Turn count before the current spell’s type is chosen. Will be set to -1 if the previous spell was activated and a new turn countdown is ready to start.
  • Type of curse to activate next, determined once the turn count reaches 0 for a given spell.

Purchasing a new package

On purchasing a new package of spells, if the current number of spells remaining variable is less than the total number in the purchased package, then the number of spells remaining will be set to that number, and the current curse (either in progress or stored) will be lost. For example, if you have 11 curses remaining, and 3 turns until a new one will be chosen, buying the most expensive package will leave you with 20 curses and no turn count in progress.

If the current number of spells remaining is greater than or equal to the number in the purchased package, nothing will happen; both the current curse progress and the number of banked spells will remain as it is. (Merlee’s more than happy to take your coins regardless.)

Turn count advancement

In-battle, at the start of every turn from the 2nd onward, the spell turn count will progress if there isn’t one currently waiting to activate.

  • If the number of remaining curses is non-zero and the turn count is -1 (i.e. there isn’t a turn count in progress or a spell waiting to activate), a new turn count is picked, from 5 to 10 inclusive, and the remaining number of spells is decremented.
  • If instead, the turn count is non-zero, it is decremented. If it hits 0 on a turn, then a curse type is picked randomly (30 / 30 / 20 / 20% chance for ATK, DEF, EXP or coins), and stored until it is able to be used. From this point on, the spell will not pick a new turn count until the stored curse is activated.

Curse activation

A stored curse will activate at the earliest opportunity, waiting across battles if necessary:

  • ATK-Up: whenever Mario next attacks with a jump or hammer move.
  • DEF-Up: whenever the enemies are next given a turn to attack.
  • EXP Bonus: whenever a fight is finished. The bonus will activate even if 0 EXP are earned from the fight (and will double the ‘pity Star Point’ if no Star Points were going to be earned, but Mario is not yet level 99).
  • Coin Bonus: whenever a field encounter is finished.

Once a curse activates, the turn count is set to -1, and the stored curse type to 0, signaling that a new turn count should be picked if there are curses remaining.

Quirks / Exploits

Curses being stored across battles means that you can get stuck with a stored curse for a very long time if you never give it a chance to activate (e.g. never letting Mario attack with an ATK-Up curse, or never fighting normal field encounters with a coin curse stored).

You would think that the curse type not being determined until the turn count elapses would limit the number of ways you could abuse foreknowledge of a curse with save points, but you can still set up particular effects to happen on the first possible turn of a battle (and even do so for most curses without using save points, provided you’re okay with wasting curses). Some examples:

  • ATK-Up: Let 12 turns pass in a field encounter without attacking with Mario, then finish the fight. If no DEF, EXP, or coin curses occur, you have an ATK curse stored.
  • DEF-Up: Defeat 11 consecutive field encounters with Mario attacking on the second turn to finish the fight. If no ATK, EXP or coin curses occur, you have a DEF curse stored.
  • Coin-Up: Let 12 turns pass in a non-field encounter (e.g. fights in the Glitz Pit), and finish the fight. If no ATK, DEF or EXP curses occur, you have a coin curse stored.
  • EXP-Up is impossible to isolate without it possibly being a coin curse instead, but you can do similar steps to the above curses, attack once with Mario and then run away to have it be a 50-50 shot. You could also just use a save point once you’re sure some curse is stored, then verify if you have the EXP one.

Alternatively, if you want to trigger an ATK or DEF effect on a given turn and don’t mind banking on the random 30% chance of getting the right effect, you can save after the turn count is rolled the turn after a previous curse activates, then keep clearing fights on the 2nd turn with a Mario attack until you get the ATK/EXP/coin curse to trigger, or the DEF curse to trigger on turn 1 of the following fight; the number of fights it took to trigger the curse would be equal to the turn count you saved with.

Merlee in 64

In 64, Merlee chooses a turn count and spell type at the same time, rather than only choosing the latter after the turn count elapses. Once the turn count elapses, the spell is only stored for the current fight, meaning that you can’t rely on save-point-less manipulation of an effect.

The current state of Merlee’s spells is stored in three variables that persist in the player’s data (the equivalent of TTYD’s “pouch”):

  • Number of spells remaining (this does include the current in-progress spell)
  • Turn count before the current spell’s type is allowed to activate.
  • Type of upcoming curse

and one variable in the battle data, which does not persist after the battle ends:

  • Type of curse ready for activation (set once the current curse’s turn count elapses).

Purchasing a new package

When purchasing a new package, the number of spells the player has is set to the larger of its current value and the number of offered by the package. In addition, the current curse’s progress is wiped, picking a new one with equal probability of ATK/DEF/EXP/coins, and a turn count from 1-3. For example, if you have 12 curses remaining, including the current one (which is an ATK curse set to be stored for activation in 8 turns), after purchasing the 5-spell package, you’ll still have 12 curses, but the current curse will be a new one with a turn count of 1-3 turns.

Turn count advancement

At the start of every turn in battle (including turn 1:

  • If the turn count is non-zero, the turn count decrements. If it hits 0 in doing so, the current curse is stored, and the remaining spell count decrements.
  • If the turn count is 0 and there are spells remaining, a new curse is chosen (ATK/DEF/EXP/coin with roughly 30/30/20/20 probability), and a turn count of 6-16 inclusive (which will immediately decrement to between 5-15).

In addition, if the player first strikes with a Jump, Hammer or partner move (not Dizzy Attack), the Merlee curse will do additional checks:

  • If the current curse type is an EXP or coin bonus and has a nonzero turn count, the turn count decrements. If it hits 0 in doing so, the current curse is stored, and the remaining spell count decrements.
  • If the turn count is 0 and there are spells remaining, the a new curse is chosen with the same probability as above, but with a turn count of 5-10, or 5-13 for coin curses specifically. This turn count will also immediately decrement if the curse type chosen was an EXP or coin bonus.

Curse activation, quirks, etc.

A stored curse will activate at the earliest opportunity within or after winning a battle, under the same circumstances as TTYD’s. If a new curse is stored before a previous one (stored in the same battle) is able to activate, the old stored curse will be overwritten.

If the player ends a battle without allowing a stored ATK or DEF curse to activate, or ends the fight by running away or similar, the stored curse is wasted. If this occurs on the last spell of a package, then there will never be an indication that the spell’s power ran out, as there normally is supposed to be on the final curse’s activation.

If an EXP or coin curse is stored when finishing a fight that would not yield any EXP or coins, it won’t activate; however, the the current spell’s turn count will be set to 0, and the number of spells remaining increased by one, effectively picking a new curse in place of the current one in the next battle and resetting its progress. This might have been done to try to ensure that the player never silently ends a package of spells on a failed EXP/coin curse, perhaps (despite the aforementioned other ways this can occur).

Unlike TTYD, curses not being stored across fights means that you can never predict what’s coming next without using save points, but since the curse turn count and type are both determined at once, using trial-and-error with save points is much more powerful if you want to have any type of curse activate on a particular turn of a battle (up through turn 10 or so, at least).

Closing thoughts

That’s it for this relatively short article! Shout-outs once again to the PM64 decomp team for their super-well documented Merlee state variables, which helped fill in a lot of gaps in my knowledge (especially regarding first strikes and ‘wasted curses’). I might drop other shorter articles like this from time to time in the future.

Troublemakers’ Tactics: An Overview of Enemy Battle Scripts

At last, we’ve come to the final big area of Paper Mario: The Thousand-Year Door‘s battle system mechanics I’ve been meaning to cover, enemies’ battle scripts / “AI”. Naturally there’s a ton of complexity that goes into covering anything as broad as the entirety of enemies’ script code, so I’ll be covering mostly general trends, with a few examples and deep dives into a few particular areas.

If you’re interested in looking further into the script code yourself for any particular enemy or boss, my ttyd-utils GitHub repository has tools to dump all the EvtScripts in the game in a text format (using the ttydasm tool from PistonMiner’s tools repository). I’ll be showing some excerpts of these scripts throughout this article, so you can get a sense of what they look like; as a note, internally TTYD refers to scripts in this format as “events”, so I may use that term interchangeably.

Event Types

First off, all enemies (and in fact, all actors or ‘battle units’ in general) have a handful of different top-level scripts to perform certain functions:

  • Initialization event – Runs as soon as the actor is spawned, generally in the initial battle setup (but can be later, when an enemy spawns helpers, or such).
  • Entry event – Runs when the actor “enters” the battle, at the start of the “first act”.
  • Damage event – Runs whenever the actor receives a hit that could deal damage or inflict a status effect.
  • Phase event – Handles events that are intended to occur ‘between’ attacking phases.
  • Unison phase event – Similar, but all actors execute this simultaneously.
  • Attack event – For non-playable actors, handles their attacking action. (For player-controlled ones, this is done largely through a completely different system).
  • Confusion event – Handles the actor’s attacking action on turns that they are afflicted by the Confuse status.
  • Idle (“Wait”) event – Runs by default whenever the actor enters an idle state (after any of their other events finishes executing). Generally, this doesn’t actually do anything but change their animation to the idle pose.

In the course of a fight, actors will run their init event during battle loading, then their entry event at the start of the “first act” (entities spawned later in the fight will run their init events as soon as they are spawned). In each of the five phases of each turn, all actors will all run their unison phase events simultaneously, then their regular phase events individually. Enemies in particular will run their attack events after all phase events are finished in the fourth phase (or their confusion event if they get confused for that turn). At any point, if an actor receives a hit intended to deal damage or status, they will run their damage event concurrently with any currently executing events. My previous post on turn structure covers the execution order of these events in greater detail.

Actors additionally have a variable-length “data table” that serves as a map of additional events used for specific circumstances, such as being defeated, being countered by or countering an opponent with spikes / elemental hazards, getting flipped over or losing their wings, and so on.

Let’s take a look at examples of each of these types of events.

Initialization + Entry events

An actor’s init event generally sets what script to use for all of their other events, as well setting up any ‘work variables’ that need to be initialized to specific values, spawning any child actors needed, and so forth. Here’s Arantula’s init event, as an example:

# sets up remaining event types
callc [btlevtcmd_SetEventWait battle_event_cmd.o] -2 [wait_event unit_piders.o]
callc [btlevtcmd_SetEventUnisonPhase battle_event_cmd.o] -2 [unison_phase_event unit_piders.o]
callc [btlevtcmd_SetEventAttack battle_event_cmd.o] -2 [attack_event unit_piders.o]
callc [btlevtcmd_SetEventDamage battle_event_cmd.o] -2 [damage_event unit_piders.o]
callc [btlevtcmd_SetEventConfusion battle_event_cmd.o] -2 [attack_event unit_piders.o]
callc [btlevtcmd_SetEventEntry battle_event_cmd.o] -2 [entry_event unit_piders.o]

# additional initialization / processing
callc [btlevtcmd_SetUnitWork battle_event_cmd.o] -2 0 0
callc [btlevtcmd_SetUnitWork battle_event_cmd.o] -2 2 0
callc [btlevtcmd_SetUnitWork battle_event_cmd.o] -2 3 1
callc [btlevtcmd_SetUnitWork battle_event_cmd.o] -2 1 255
callc [piders_yarn_init unit_piders.o]
callsa [yarn_event unit_piders.o]

# end event (start idle event)
callc [btlevtcmd_StartWaitEvent battle_event_cmd.o] -2
return
end

If actors have an entry event, they all execute simultaneously immediately at the start of the battle’s “first act”, even before the First Strike occurs (if applicable). These include Mario and his partners walking into the battle scene, and the introductory cutscenes in most boss fights, but in theory normal enemies with unique entry animations (such as Piders and Arantulas) could utilize these as well. Notably, no actors that spawn later in a battle can have entry events, since they only ever run at the start of a battle.

Damage events

Generally, most actors just call the default “btldefaultevt_Damage” script on taking damage. This script will change the actor’s animation, and check whether any special sub-events should be executed based on the properties of the damaging hit. These might include events from the actor’s data table, or generic scripts for attacks with special on-hit effects such as Gale Force, knockback from Super Hammer, or “crushing” attacks like Flurrie’s Body Slam or the dragons’ stomp attack.

There are a ton of hit effects I don’t currently have documented, but relatively few enemies have unique gameplay-impacting effects that occur in their damage script (rather than their death script, or in their next phase / attack scripts); the few examples I can think of include:

  • Gold Fuzzy calling in the Fuzzy Horde for backup, if under 8 HP
  • The Fuzzy Horde losing members per hit, and running if enough damage is taken
  • Hooktail’s reactions to taking a hit with Attack FX R (but not the bargaining event after reducing her to 0 HP; this happens in her “death event”).
  • Hitting Rawk Hawk while on the ceiling knocking him to the floor
  • Lord Crump changing X-Naut formations at half health in his Chapter 5 fight
  • Hitting Cortez’s bone pile in phase 2 to make his head lower / rib cage open
  • Hitting Grodus’s staff to make his next attack have a chance to fail
  • Damaging Kammy causing her to fall off of her broom
  • Elemental attacks causing bomb enemies to immediately explode
  • Enemies with clones deleting them if the correct one is attacked
  • Lakitus dropping their held Spiny Egg

(Unison) Phase events

Phase events are generally used to set up changes in an actor’s state at the beginning of a turn, or between the player and enemy attacking phases.

Unison phase events in particular are most commonly used for all actors of a given type moving in formation, such as Piders moving between high and low positions, Yuxes spawning Mini-Yuxes, or Lakitus choosing to pull a Spiny Egg above their head. Here’s the Dark Puff unison phase event, for example:

# check if currently in turn phase 1 
callc [btlevtcmd_CheckPhase battle_event_cmd.o] LW(0) 0x4000001
if_int_eq LW(0) 0
  goto 99
endif

# check that actor isn't incapacitated, and isn't currently in a charged state
callc [btlevtcmd_CheckActStatus battle_event_cmd.o] -2 LW(0)
if_int_eq LW(0) 0
  goto 99
endif
callc [btlevtcmd_CheckPartsCounterAttribute battle_event_cmd.o] -2 1 1024 LW(0)
if_int_eq LW(0) 1
  goto 99
endif

# randomly choose to switch positions
callc [evt_sub_random evt_sub.o] 99 LW(0)
if_int_lt LW(0) 50
  callc [btlevtcmd_GetUnitWork battle_event_cmd.o] -2 0 LW(0)
  if_int_eq LW(0) 1
    callc [btlevtcmd_snd_se battle_event_cmd.o] -2 ["SFX_ENM_KUMO_MOVE4"] [F1194D80] 0 [F1194D80]
    callc [btlevtcmd_GetPos battle_event_cmd.o] -2 LW(0) LW(1) LW(2)
    setii LW(1) 40
    callc [btlevtcmd_DivePosition battle_event_cmd.o] -2 LW(0) LW(1) LW(2) 60 10 4 0 -1
    callc [btlevtcmd_SetHomePos battle_event_cmd.o] -2 LW(0) LW(1) LW(2)
    callc [btlevtcmd_OnPartsAttribute battle_event_cmd.o] -2 1 6291456
    callc [btlevtcmd_SetUnitWork battle_event_cmd.o] -2 0 0
  else
    callc [btlevtcmd_snd_se battle_event_cmd.o] -2 ["SFX_ENM_KUMO_MOVE5"] [F1194D80] 0 [F1194D80]
    callc [btlevtcmd_GetPos battle_event_cmd.o] -2 LW(0) LW(1) LW(2)
    setii LW(1) 10
    callc [btlevtcmd_DivePosition battle_event_cmd.o] -2 LW(0) LW(1) LW(2) 60 -10 4 0 -1
    callc [btlevtcmd_SetHomePos battle_event_cmd.o] -2 LW(0) LW(1) LW(2)
    callc [btlevtcmd_OffPartsAttribute battle_event_cmd.o] -2 1 6291456
    callc [btlevtcmd_SetUnitWork battle_event_cmd.o] -2 0 1
  endif
endif
...

Regular phase events are primarily used by bosses that get free actions between their ‘turns’, such as Lord Crump calling in the X-Naut platoon in the final phase of his chapter 5 fight:

# check if currently in turn phase 1
callc [btlevtcmd_CheckPhase battle_event_cmd.o] LW(0) 0x4000001
if_int_eq LW(0) 0
  goto 99
endif
...

# check that UW var 0 = 2 (i.e. in final AI phase of fight)
callc [btlevtcmd_GetUnitWork battle_event_cmd.o] -2 0 LW(0)
if_int_eq LW(0) 2
  # if so, call the X-Naut platoon back in
  callss [call_event unit_boss_kanbu3.o]
endif
...

or that have dialogue triggers, transformations or AI state changes upon reaching certain HP thresholds, such as Bonetail:

# check if currently in turn phase 3 (between player and enemy attack phases)
callc [btlevtcmd_CheckPhase battle_event_cmd.o] LW(0) 0x4000003
if_int_eq LW(0) 0
  goto 99
endif
...

# check UW var 0 (tracks Bonetail's AI phase)
callc [btlevtcmd_GetUnitWork battle_event_cmd.o] -2 0 LW(0)
switchi LW(0)
  case_int_eq 0
    # upon first reaching 1/2 health, set UW var 0 to 1
    callc [btlevtcmd_GetMaxHp battle_event_cmd.o] -2 LW(0)
    muli LW(0) 50
    divi LW(0) 100
    callc [btlevtcmd_GetHp battle_event_cmd.o] -2 LW(1)
    if_int_le LW(1) LW(0)
      callc [btlevtcmd_SetUnitWork battle_event_cmd.o] -2 0 1
    endif
  case_int_eq 1
    # upon first reaching 1/4 health, set UW var 0 to 2 and play dialogue cutscene
    callc [btlevtcmd_GetMaxHp battle_event_cmd.o] -2 LW(0)
    muli LW(0) 25
    divi LW(0) 100
    callc [btlevtcmd_GetHp battle_event_cmd.o] -2 LW(1)
    if_int_le LW(1) LW(0)
      callc [btlevtcmd_StatusWindowOnOff battle_event_cmd.o] 0
      callc [btlevtcmd_SetUnitWork battle_event_cmd.o] -2 0 2
      callc [evt_msg_print evt_msg.o] 2 ["tik_boss_15"] 0 -2
      callc [btlevtcmd_StatusWindowOnOff battle_event_cmd.o] 1
    endif
end_switch
...

The Shadow Queen makes particularly involved use of her true form’s phase event, checking in turn phase 1 whether her hands need reviving, in turn phase 3 for whether she wants to swap hand types, and during every turn phase in her invincible state for whether she’s received hits (in order to taunt the player).

Attack events

Finally, the attack event is where most of an enemy’s “AI” comes from; this is where they determine which attack or other action to take on their turn. This may be as simple as executing an attack directly for enemies with only one move, choosing randomly between a number of different attacks, or making different decisions based on their state (such as using a particular attack after a charge turn). Programming styles for both the attack choice and the actual attack execution vary dramatically; to keep this article from going wildly over my time budget I’ll spare most of the gory details, but I will go over a few simpler examples (and strongly suggest you check out the scripts yourself if you’re curious about anything else).

Examples

To start, Embers have relatively simple AI, randomly choosing between their three attacks:

# check whether to use item
callc [btlevtcmd_EnemyItemUseCheck battle_event_cmd.o] -2 LW(0)
if_int_ne LW(0) 0
  callss LW(0)
  callc [btlevtcmd_StartWaitEvent battle_event_cmd.o] -2
  return
endif

# do a random roll with the sum of the attacks' weights
setii LW(0) 50
addi LW(0) 30
addi LW(0) 20
subi LW(0) 1
callc [evt_sub_random evt_sub.o] LW(0) LW(1)

# based on the result (< 50, < 80 or >= 80), use the corresponding attack
setii LW(0) 50
if_int_lt LW(1) LW(0)
  setii LW(9) [weapon_bubble_attack unit_hermos.o]
  callss [normal_attack_event unit_hermos.o]
  goto 99
endif
addi LW(0) 30
if_int_lt LW(1) LW(0)
  setii LW(9) [weapon_bubble_fire_attack unit_hermos.o]
  callss [fire_attack_event unit_hermos.o]
  goto 99
endif
setii LW(9) [weapon_bubble_all_fire_attack unit_hermos.o]
callss [all_fire_attack_event unit_hermos.o]
goto 99
...

Dark Puffs have a bit more state to their AI, choosing to use their swoop attack or charge 50% of the time, then unleashing their lightning attack if charged:

# check whether to use item
callc [btlevtcmd_EnemyItemUseCheck battle_event_cmd.o] -2 LW(0)
if_int_ne LW(0) 0
  callss LW(0)
  callc [btlevtcmd_StartWaitEvent battle_event_cmd.o] -2
  return
endif

# check if has electric hazard, i.e. already charged
callc [btlevtcmd_CheckPartsCounterAttribute battle_event_cmd.o] -2 1 1024 LW(0)
if_int_eq LW(0) 1
  setii LW(9) [weapon_kurokumorn_thunder_attack unit_monochrome_kurokumorn.o]
  callss [thunder_event unit_monochrome_kurokumorn.o]
  goto 99
endif

# otherwise, 50% chance of attacking or charging
setii LW(0) 50
addi LW(0) 50
subi LW(0) 1
callc [evt_sub_random evt_sub.o] LW(0) LW(1)
setii LW(0) 50
if_int_lt LW(1) LW(0)
  setii LW(9) [weapon_kurokumorn_attack unit_monochrome_kurokumorn.o]
  callss [normal_attack_event unit_monochrome_kurokumorn.o]
  goto 99
endif
callss [charge_event unit_monochrome_kurokumorn.o]
goto 99

Flower Fuzzies are interesting, as they only require 2 FP to use their special attack, but they will heavily favor using their leech attack unless they have the full 3:

# check whether to use item
callc [btlevtcmd_EnemyItemUseCheck battle_event_cmd.o] -2 LW(0)
if_int_ne LW(0) 0
  callss LW(0)
  callc [btlevtcmd_StartWaitEvent battle_event_cmd.o] -2
  return
endif

callc [btlevtcmd_GetFp battle_event_cmd.o] -2 LW(0)
callc [btlevtcmd_GetMaxFp battle_event_cmd.o] -2 LW(1)
# if less than 2 FP, always use drain attack
if_int_lt LW(0) 2
  goto 10
endif
# if max FP, always use magic attack
if_int_ge LW(0) LW(1)
  goto 20
endif

# otherwise, weighted choice (5/6 of the time, use drain attack)
setii LW(0) 50
addi LW(0) 10
subi LW(0) 1
callc [evt_sub_random evt_sub.o] LW(0) LW(1)
if_int_lt LW(1) 50
10:
  callss [drain_attack_event unit_flower_chorobon.o]
  goto 99
endif
20:
callss [magic_attack_event unit_flower_chorobon.o]
goto 99

Finally, as an example of a boss that has differing attack patterns based on their HP (or unit variables tracking which dialogue triggers have been hit, in this case), here’s what Macho Grubba’s attack script looks like in its entirety:

# increment the number of attacks used this turn
callc [btlevtcmd_GetUnitWork battle_event_cmd.o] -2 0 LW(1)
addi LW(1) 1
callc [btlevtcmd_SetUnitWork battle_event_cmd.o] -2 0 LW(1)

# check whether Fast status is active, and reapply if so
callc [btlevtcmd_CheckStatus battle_event_cmd.o] -2 19 LW(0)
if_int_eq LW(0) 0
  setii LW(9) [weapon_gance_macho_speed unit_boss_macho_gance.o]
  callss [gance_macho_speed_attack_event unit_boss_macho_gance.o]
else
  # if LW(1) < 2; i.e. fewer than two text triggers, or in first phase of fight
  callc [btlevtcmd_GetUnitWork battle_event_cmd.o] -2 1 LW(2)
  if_int_lt LW(2) 2
    # if first attack this turn, choose which buff to apply
    if_int_le LW(1) 1
      callc [btlevtcmd_DrawLots battle_event_cmd.o] LW(0) 3 30 20 10
      switchi LW(0)
        case_int_eq 0
          setii LW(9) [weapon_gance_build_up unit_boss_macho_gance.o]
          callss [gance_build_up_attack_event unit_boss_macho_gance.o]
        case_int_eq 1
          setii LW(9) [weapon_gance_body unit_boss_macho_gance.o]
          callss [gance_body_attack_event unit_boss_macho_gance.o]
        case_int_eq 2
          setii LW(9) [weapon_gance_footwork unit_boss_macho_gance.o]
          callss [gance_footwork_attack_event unit_boss_macho_gance.o]
      end_switch
    else  # otherwise, use his body slam attack
      setii LW(9) [weapon_gance_attack unit_boss_macho_gance.o]
      callss [gance_attack_attack_event unit_boss_macho_gance.o]
    endif
  else  # second phase of fight
    # if first attack this turn, choose which buff to apply (incl. Charge)
    if_int_le LW(1) 1
      callc [btlevtcmd_DrawLots battle_event_cmd.o] LW(0) 4 25 20 10 10
      switchi LW(0)
        case_int_eq 0
          setii LW(9) [weapon_gance_build_up unit_boss_macho_gance.o]
          callss [gance_build_up_attack_event unit_boss_macho_gance.o]
        case_int_eq 1
          setii LW(9) [weapon_gance_body unit_boss_macho_gance.o]
          callss [gance_body_attack_event unit_boss_macho_gance.o]
        case_int_eq 2
          setii LW(9) [weapon_gance_footwork unit_boss_macho_gance.o]
          callss [gance_footwork_attack_event unit_boss_macho_gance.o]
        case_int_eq 3
          setii LW(9) [weapon_gance_posing unit_boss_macho_gance.o]
          callss [gance_posing_attack_event unit_boss_macho_gance.o]
      end_switch
    else  # otherwise, choose either his punch or backflip attack
      callc [btlevtcmd_DrawLots battle_event_cmd.o] LW(0) 2 10 10
      switchi LW(0)
        case_int_eq 0
          setii LW(9) [weapon_gance_rariat_attack unit_boss_macho_gance.o]
          callss [gance_rariat_attack_attack_event unit_boss_macho_gance.o]
        case_int_eq 1
          setii LW(9) [weapon_gance_body_attack unit_boss_macho_gance.o]
          callss [gance_body_attack_attack_event unit_boss_macho_gance.o]
      end_switch
    endif
  endif
endif
callc [btlevtcmd_StartWaitEvent battle_event_cmd.o] -2
return
end

Item Usage

As you could see in the former examples, most enemies have a check at or near the beginning of their script to see whether they should use their held item, if they have one. Enemies have some rudimentary AI for whether to use each type of item they can hold, with the items separated into the following categories:

  • Attack items – Enemies have a (20% * current turn count) chance of using these every turn. As an exception, if Koops is currently in the battle and incapacitated (either by sleep/stop/freeze status or being flipped), enemies will always use a held POW Block or Earth Quake. Presumably the idea was to keep him stunned, but the latter item doesn’t actually flip shell enemies.
  • Support status items – If an enemy holds one of these, they will use it if there is any target on its side (including itself) that doesn’t already have the status. For Power Punch specifically, there must be a target that isn’t already Huge and is currently able to act.
  • Attack status items – Similarly, the enemy is guaranteed to use these if either Mario or his partner is both able to act and not already afflicted by the status. Note that Ice Storm counts as an attack item, not a status attack item, so enemies are not guaranteed to use it turn 1.
  • HP / FP recovery items – If an enemy has one of these and any target has less than full HP or FP, respectively, they are guaranteed to use it. Enemies are not normally able to hold items that restore both HP and FP, but if they could, they would check for enemies with either missing HP or FP.
  • Status recovery items – If any target has Sleep, Stop, Dizzy, Poison, Confuse, Burn, Freeze, Tiny, Def-Down, Slow, or (oddly) Electric status, an enemy will use their held Tasty Tonic.

Notably, any non-restoration items not listed above (Point Swap, Spite Pouch, etc.) have none of the above functions assigned for their use, and as such could never be used by enemies, even if they were able to hold them.

Nearly all enemies are able to use items, including bosses that normally would never be able to hold them such as Blooper and Smorg (and their appendages, surprisingly); the only exceptions are:

  • Mini-Yuxes
  • Bulky Bob-ombs
  • Macho Grubba
  • Cortez (all forms, + weapons)
  • Grodus + Grodus Xes
  • Shadow Queen (both forms, + hands)
  • X-Fist + X-Punch
  • The X-Naut platoons in the Ch. 5 Lord Crump fight (which oddly can hold items)

Note that the heuristics above only determine whether an enemy will use their item, not on whom they will use it; that uses the same target selection functions as normal enemy attacks. Speaking of, let’s cover that now:

Target Selection

The script for each enemy attack almost always follows this general template:

# set the appropriate attack parameters
setii LW(9) [weapon unit_kuriboo.o]

# find and order all targets that the current attack can hit
callc [btlevtcmd_GetEnemyBelong battle_event_cmd.o] -2 LW(0)
callc [btlevtcmd_SamplingEnemy battle_event_cmd.o] -2 LW(0) LW(9)
# choose which target to hit first (only relevant for single-target attacks)
callc [btlevtcmd_ChoiceSamplingEnemy battle_event_cmd.o] LW(9) LW(3) LW(4)
# if no targets found, play confusion animation if Confused, or just end attack
if_int_eq LW(3) -1
  callc [btlevtcmd_CheckToken battle_event_cmd.o] -2 16 LW(0)
  if_int_ne LW(0) 0
    callss [subsetevt_confuse_flustered battle_event_subset.o]
    return
  endif
  goto 99
endif
...

The btlevtcmd_SamplingEnemy function picks out all valid targets for the attack based on the enemy’s alliance (as determined by btlevtcmd_GetEnemyBelong; if confused, the alliance is swapped). This involves looking at every part of every battle unit, and removing any that the attack’s targeting parameters disallow. After that, all remaining targets are sorted by X-position based on the attacking direction, and filtered down further by ‘frontmost only’ targeting, if necessary.

For instance, Goomba’s headbonk attack has the following targeting parameters:

0x01101260 AttackTargetClass_Flags
0x00000060 Cannot target neutral / system actors
0x00000200 Opposite alliance
0x00001000 Cannot target self
0x00100000 Only high-priority parts
0x01000000 Single-target

0x20001000 AttackTargetProperty_Flags
0x00001000 Jumplike attack range
0x20000000 Target the opposing direction ('front' = rightmost target)

Given this standard battle scene, the initial possible actors to target include the ‘system’ actor, Mario, Yoshi, the Goomba, and the Spiked Goomba, each of which only consist of 1 ‘part’. The “cannot target self”, “opposite alliance”, and “no neutral actors” flags filter this down to only Mario and Yoshi as possibilities (neither of them is out of range of Jump-like attacks), and since the opposing team’s direction is considered the front, Mario’s target is sorted before Yoshi’s.

For a more complicated example, let’s consider the first Dark Koopa in this layout, and assume that it’s afflicted by Confusion this turn:

Its attack’s targeting parameters are:

0x01101260 AttackTargetClass_Flags
0x01000000 Single-target
0x00000060 Cannot target neutral / system actors
0x00000200 Opposite alliance
0x00001000 Cannot target self
0x00100000 Only high-priority parts

0x21002000 AttackTargetProperty_Flags
0x00002000 Hammer-like attack range
0x01000000 Frontmost target only
0x20000000 Target the opposing direction ('front' = rightmost target)

Since the Koopa is confused, the “opposite alliance” flag gets swapped for keeping targets in the same alliance. This in combination with the other Class flags leaves the three other enemies as potential targets, and the Hammer-like distinction removes the Paratroopa as an option.

Since the original attack considers the “front” to mean right, and this directionality is not flipped when an actor is confused, the targets are sorted from right to left, and the “frontmost target” flag means that the rightmost Koopa will become the only valid target.

Once all the possible targets have been determined, for single-target attacks, the btlevtcmd_ChoiceSamplingEnemy function determines which of the possible targets will be attacked, either by strong preference, or random weighted chance. This function starts by giving each target a weight of 100, with the ‘frontmost’ receiving a weight of 110, then modifies the weights based on the attack’s target weighting parameters (you can read up on more details on those in my attack parameters article).

For a simple example, Goomba’s headbonk has the following flags:

0x80002004 AttackTargetWeighting_Flags
0x00000004 Prefer frontmost
0x00002000 (no known effect)
0x80000000 Choose target randomly

If Mario is in front and his partner is in the back, the “prefer frontmost” option multiplies Mario’s weight of 110 by 0.9, and the partner’s weight of 100 by 0.5, giving weights of 99 and 50. A weighted roll then determines which character is targeted, meaning that Mario gets attacked about two-thirds of the time.

For another example, most enemy healing moves have similar weighting parameters to these:

0x00001500 AttackTargetWeighting_Flags
0x00000100 Prefer less healthy
0x00000400 Prefer lower HP
0x00001000 Prefer in Peril

In this case, the Magikoopa and Goomba’s weights are multiplied as follows:

MagikoopaGoomba
Starting weight110100
Less Healthy (x 2.0 – current HP fraction)157150
Lower HP (x 1.5 – current HP/20)204217
In Peril (x1.5)204325

Since Magikoopa’s healing attack doesn’t do a random weighting check, it takes whichever one is the highest, in this case, the Goomba’s. In the event of a tie between multiple targets, whichever one is closer to the ‘front’ will be chosen.

In addition to the targeting weight flags, several items have extra checks in this function to try to ensure that they’re not wasted on targets that don’t need them:

  • If one of the above support status items is being used, targets that already have that status (or are unable to act, in the case of Power Punch) have their weight set to 1. The same is true for Ruin Powder, Mr. Softener and Mini Mr. Mini, even though they’re multi-target attacks.
  • If a Tasty Tonic is being used, targets that don’t have Sleep, Stop, Dizzy, Poison, Confuse, Burn, Freeze, Tiny, Def-Down or Slow status (not Electric this time!) will have their weight set to 1. As such, if a Tasty Tonic is used to attempt to ‘cure’ Electric status when no enemies have negative statuses, it will be equally likely to be used on any of the targets, since the item has the “random weighted” flag and all targets will have a weight of 1.
  • If the item being used restores FP (Gradual Syrup not included), each target’s weight is multiplied by 1.0 + 0.1 * (max FP – current FP) if they are missing FP, or set to 1 otherwise (unless the item also restores HP).

(Note that a target with a weight of 1 is still possible to be picked, but very unlikely.)

Once the final targets are determined, the script checks to see if the attack lands (as opposed to missing due to evasion, invisibility, or accuracy loss), and processes the hit if so, for each target in turn:

# check to see if attack should hit
callc [btlevtcmd_PreCheckDamage battle_event_cmd.o] -2 LW(3) LW(4) LW(9) 256 LW(5)
...

# if LW(5) = 1 (attack lands), process hit
callc [btlevtcmd_ResultACDefence battle_event_cmd.o] LW(3) LW(9)
callc [btlevtcmd_CheckDamage battle_event_cmd.o] -2 LW(3) LW(4) LW(9) 256 LW(5)

If you’re interested in further details on this part of the attack process, my video on the “Defensive Action Storage” glitch goes into more detail, with special focus on all the pitfalls that TTYD’s event programmers ran into when coding multi-target attacks with a single Action Command.

Confusion events

Confusion events are run in the place of the attack events on turns that the Confusion status procs, and are handled in a few different ways between different actor types.

For Mario and his partners, if they become confused, they choose one of the following actions at random:

  • Jump
  • Hammer
  • Partner base move
  • Defend
  • Switch partners (if possible)
  • Run away (if possible); this may or may not fail, based on where the invisible marker ends up.

The way this works under the hood is far more involved than I would have guessed; apparently the game essentially acts as if selecting options from the player’s standard battle menu, with an equal chance of making any valid choice at any time. As such, a confused Mario will select “Jump”, “Hammer”, and “Tactics” each 1/3 of the time, with the latter 1/3 being divided equally into the “Switch partners”, “Defend” and “Run away” options. (Likewise, partners have a 1/2 chance of attacking or using Tactics). If Mario’s partner is down, then he will only be able to choose from the Tactics menu.

The game in theory supports more actions when confused, but most other menu selections are disabled (and all attacks aside from default Jump, default Hammer, and each partner’s first move have the “Can use in Confusion” flag unset). In particular, if the ability to select “Items” were enabled, there’s already working code for player characters to randomly use any single-target item on the incorrect alliance.

As for enemies, most of them use their regular attack event as their confusion event, and will use any of their usual moves or held items (including multi-target ones) exactly as they normally would, but on targets from the opposite alliance from normal. If they attempt to use an attacking move that has no valid targets, they will do nothing instead.

Bosses (aside from Gus), Mini-Yuxes, and Bulky Bob-ombs are exceptions to the rule, and use a default confusion event that results in them always doing nothing when confused. (Bulky Bob-ombs’ fuses will continue to tick down during their phase events if already lit beforehand, however.)

Concluding Remarks

Hopefully this gives a well-rounded taste of how enemies’ scripts are used in battle; again, if you’re ever interested in looking at all of the game scripts and attack parameters, I suggest checking out my the tools on my ttyd-utils GitHub repository.

I don’t have any further plans for large-scale mechanics posts in the near future, but I’m sure I’ll have more topics I want to cover eventually. I’m always open to suggestions on what other battle mechanics to cover, or how to present information in a more digestible manner as well. Until then, I hope this site remains a useful reference, and you definitely haven’t seen the last of my TTYD mechanics-related content!

A Potpourri of Precarious Props: Paper Mario TTYD’s Stage Hazards

One of the most maligned, yet uniquely flavorful additions to Paper Mario: The Thousand-Year Door is the added presence of the battle arena. The occasional dropped props and stray sprays add that little bit of character to the stage, as well as a sometimes unwelcome extra element of unpredictability to the outcome of a fight. Unlike the audience, a surprising amount of whose mechanics can be calculated and planned for with a lot of game knowledge, any attacks with a chance of causing stage hazards can never have their effects predicted completely. That said, it’s always worth knowing exactly what you could be up against, so let’s do a deep dive on all the different types of stage hazards and their individual quirks!

Overview

Pretty much every attack performed in the battle (including using items) does a check to see whether any stage hazards should occur once it’s ended. The attack’s weapon parameters specify chances of each of the different types of hazards occurring; these vary between attacks, typically not exceeding 10% except for particularly destructive attacks such as Power Jump, Quake Hammer or Bob-ombast. Of note, nearly all enemy attacks don’t have any chance of causing stage hazards to occur.

The possible effects are as follows, and occur in this order:

  • Background props falling
  • Stage jets turning
  • Stage jets firing
  • Ceiling beam falling
  • Offscreen props (“objects”) falling

Let’s dive into each of them individually…

Background Props

Every battle scene is outfitted with a varying number of stage props, meant to invoke the look of the area it takes place in. These backgrounds broadly form a few layers, named (from foreground to background) “A1”, “A2”, and “B”. The amount of props fitting each of these layers varies from scene to scene; relatively few actually have all three.

A sample battle scene from the Petal Meadows region, showing which props belong to which layers.

To determine which of these background props fall after an attack, there are two different random checks performed. First, a weighted random roll is performed to determine which of the A layers to destroy, if either. In practice, all attacks have a 100 weight for nothing to be destroyed, some weight < 100 that is used for each of A1 and A2 individually, and a weight of 0 for both to be destroyed at once.

For example, Power Jump has a 25 weight for A1 and A2 individually, and 100 weight for nothing to fall, meaning that 25/150 = 1/6 of the time, A1 is destroyed, and another 1/6 of the time A2 is destroyed. If the background layer this random roll determined should be destroyed doesn’t exist or already fell as the result of a previous attack, nothing happens instead (and the weights aren’t changed).

If the A1 layer doesn’t exist for a given scene or has already fallen down, a second random check is done to see if the B layer should be destroyed, this time just checking if a single random value from 0-99 is less than a given threshold. (Again, Power Jump has a value of 25 for the B layer, leading to a 25% chance of this occurring). If the A2 layer still exists at this point, it falls down with the B layer.

As for how this affects combat, background props are fairly tame, with the A1 and B layers of props both causing a single point of damage upon falling (which can be negated by guarding or Superguarding). This damage may only affect either the player or enemy side of the field, depending on the layout of the props (for the scene above, A1 will only damage enemies, but B will damage everyone). The A2 layer is purely cosmetic, in any case, and usually consists of props that are short and low to the ground.

Ceiling Beam

Similarly to the background falling, the falling ceiling beam causes 1 damage to all actors, as well as grounding anything currently attached to the ceiling. This can be used to end Rawk Hawk’s ceiling phase prematurely (though all attacks available at that time have a very small chance of causing the ceiling to drop).

Notably, Spring Jump cannot be used successfully when the ceiling beam is present; Mario will slam into the ceiling before having a chance to reach his target. This has a whopping 50% chance of making the ceiling fall, though!

Stage Jets

The stage jets (“nozzles” internally) are added to the decor when Mario reaches B-List Star status (level 10), and are probably the most infamous stage hazard. Meant to evoke fog machines and flashy pyrotechnics on real-life concert stages, these function quite similarly, resulting in a fog that covers the stage, or if the jets are pointed towards the stage, a variety of damaging and/or status-inducing effects.

There are four types of stage jets: fog, ice, explosions and fire. These appear in varying proportion based on Mario’s current rank:

RankFogIceExplosionFire
B-List Star (Lv. 10-19)65%35%
A-List Star (Lv. 20-29)35%25%40%
Superstar (Lv. 30+)20%20%25%35%

The type of jet never changes within a single battle, and is determined either at the start of the battle (firing off before combat starts) in fights without a First Strike, or on the first attack in which they are randomly determined to fire otherwise.

After every attack, the jets do two independent random checks: one to toggle between all facing upward, and each facing the left or right side of the stage, and one to determine whether or not they should fire. For instance, performing a normal Hammer attack has a 6% to make the jets turn, and a 2% chance to make them fire.

If the jets are facing the stage when they fire, then attack parameters are constructed dynamically to determine who should be targeted and how strong the effects should be. This is done by taking a base set of parameters for each side with at least one jet facing it (which basically specifies nothing except for which targets to filter out; one for the player’s side that disallows enemies and system actors, and one for the enemies’ that disallows system actors, Mario / Shell Shield, and his partner), and mixing it with parameters for the individual jet types that determine the attack’s damage and damage function, its elemental type, and what statuses should be applied (with the damage and status turn count being multiplied by 1, 2, or 3 based on how many jets are facing that side) as follows:

Jet TypeDamage FunctionBase DamageElementStatus
FogFixed0NormalNone
IceNon-damagingIceFreeze, 1 turn
ExplosionFixed2ExplosionNone
FireFixed1FireBurn, 3 turns

Interestingly, the ice jets are completely non-damaging, meaning that they are incapable of dealing damage, even to enemies weak to the Ice element. By contrast, the fog jets’ attack, which normally does nothing, can cause damage due to P-Up, D-Down.

An especially odd quirk of stage jet attacks is that because of the way they are dynamically constructed and how barebones the base “player side” and “enemy side” attack parameters are, they do not include the “force target only high-priority parts” flag normally included on multi-target attacks. This means that any enemy that has multiple targetable parts tied to the same actor has all of them targeted simultaneously, usually resulting in multiple times the intended damage.

The affected parties include the dragons (head and foot), Grodus (both him and his staff; even though the staff doesn’t make Grodus take damage, both hits count towards the chance of his next attack failing), and both Magnus von Grapple bosses, who as mentioned in the previous article have separate hitboxes for their body and foot to make attacks land more naturally:

Worst of all, Cortez’s first two forms cause his head and and bone pile to both be hit at once, and after attacking his bone pile twice in the second phase, his head, bone pile, and the exposed gem in his chest (which takes an extra point of damage due to elemental weakness) can all take damage simultaneously for up to a whopping 17 damage at once!

Fog Jets

As their name suggests, fog jets’ main effect doesn’t come from their damage (or lack thereof, as the case usually is); their more notable effect is that when they fire, the stage becomes shrouded in fog for 2 turns, which causes most attacks to miss 50% of the time. Unlike the other types, this occurs regardless of whether they are facing the stage. (However, the “attack” part will only occur if they’re facing a side, unless that attack itself misses due to the fog!)

A few attacks, mostly the Special Moves, are able to skip the fog’s miss check, but generally you’re forced to wait the 2 turns out; however, there are a handful of actions that can dispel the fog prematurely:

  • Bobbery Appealing
  • Bobbery using Bomb (happens after the attack, so it can still miss)
  • Bobbery’s Bomb Squad bombs exploding (happens before the attack)
  • Bobbery’s Bob-ombast (happens before the attack)
  • Bobbery’s Hold Fast being triggered
  • Bob-ombs exploding (if attacking, the miss check happens before it hits)
  • Bulky Bob-ombs or Bob-ulks exploding (happens before the attack)
  • Flurrie’s Gale Force
  • Using an Ice Storm item

Of these, Bomb, Bob-ombast and Gale Force all have a chance of bringing the fog back immediately afterward, but if your aim is to clear the fog without that chance, appealing with Bobbery and using Ice Storm can’t cause any stage effects, so go wild!

Falling Objects

The final and most varied group of hazards. Each attack does a single random roll to see if an offscreen prop should fall, and if that chance succeeds, picks one of the eligible prop types for Mario’s current rank with equal probability. Here are the nine types of falling objects in action:

A deluge of decor and debris!

And here are their effects:

Prop TypeMinimum rankDamageStatus
BucketRising Star1Dizzy (3 turns, 50%)
Stage lightRising Star1Electric (3 turns, 25%)
BasinB-List Star1Dizzy (3 turns, 50%)
WaterB-List StarMultiple (clear, 100%)*
Small bug(s)**A-List StarConfuse (3 turns, 50%)
Large bugA-List Star1Confuse (3 turns, 50%)
ForkA-List Star2Sleep (0 turns, 100%)***
MeteorSuperstar3Dizzy (3 turns, 50%)
Bowser statueSuperstar5Confuse (3 turns, 100%)

* The water stage effect clears the following statuses: Sleep, Stop, Dizzy, Poison, Confuse, Electric, Burn, Freeze, Charge, and Payback. (Guarding it will stop all statuses from being cleared.)
** The small bugs come in two sub-varieties, either a single small bug or a swarm of them; they still only count as one type of object.
*** This effectively clears the Sleep status. Note that this does not guarantee it’s cleared if the target has < 100% Sleep vulnerability; if the vulnerability roll fails and the 50% chance of the target waking up from attack fails, the target might remain asleep.

The target of the falling objects is chosen like randomly targeted enemy attacks, choosing randomly from all non-system actors with a 10% bias to the leftmost character (i.e. whoever the player has in the back), except the meteor and Bowser statue, which always hit all characters, or all characters on a randomly chosen side, respectively. There is also a 10% chance of any of the single-target hazards to hit the audience instead, causing all the audience members in a small range around the impact point to leave.

Closing notes / miscellanea

This covers most of the important info on stage hazards, but a couple more notes:

  • Mischief-causing Shy Guy audience members will trigger either a falling object or the stage jets to fire with equal probability (assuming Mario is B-List or higher; otherwise it will always be a falling object). The side of the screen the Shy Guy runs off to has no impact on who the falling objects target.
  • Some types of stage hazards might be disabled during special occasions. Notably, falling objects are disallowed during the Crump prologue fight and all tutorial fights, and the ceiling from the Chapter 5 Crump fight is impossible to destroy (unlike the Rawk Hawk fight).
  • There’s an unused byte after the usual stage hazard rate parameters that takes on similar values to the others, which suggests there might have been another type of stage hazard that was cut from the game earlier in development. Even as early as the July 2004 demo, there isn’t any code that seems to reference the parameter directly, so it’s only speculative what it could have done.
  • The only enemy attacks that are able to cause stage hazards are the dragons’ stomp, which have a 10% chance of causing a falling object. If you feel like winning the lottery, try getting Hooktail’s stomp to self-inflict Electric status (which she has only a 10% susceptibility to)!

If you’re interested in looking at the rates for specific player attacks, you can find a spreadsheet of the hazard chances caused by player attacks in my stats Drive folder, or you can dump the attack parameters and event scripts for all attacks in the game using my ttyd-utils suite of scripts (look for calls to “btlevtcmd_WeaponAftereffect” in the event scripts to see which attacks actually use their parameters!)

Until next time, where I’ll cover the basics of enemy attack AI!

TTYD’s Attack Parameters: Becoming a Wizard of Weaponry

Paper Mario: The Thousand-Year Door pits Mario and his companions against a wealth of different enemies. In combat, both sides have access to a wide variety of different moves, with different attack patterns (single-target, multi-hit, spread…) and performing different functions, from direct damage to buffing allies with status effects. On the face of it, these moves have several pretty easily distinguishable features, such as their FP or SP cost, which status they inflict, or whether they pierce defense. However, there’s a lot of subtlety hidden past these surface-level attributes — What exact targets can the move reach? Does it make direct contact (i.e., can it be stopped by spikes or elemental hazards)? Do enemies prefer to use an attack on some targets more than others?

This article will be an overview of what parameters the game uses to define these properties of attacks, and more.

What is an “attack”, exactly?

There’s a lot of different ways any given action taken by a player or enemy can be classified and subdivided; here’s my attempt to briefly clarify my terminology for the components of these actions, and what the game internally refers to things as for context.

As described in the article on turn structure I wrote last year, both player characters and enemy characters generally perform their primary combat actions in their respective “active phase”. In the case of player, they choose their commands from a menu, whereas an enemy will perform an action based their AI (specifically, their “attack script”). Both the player and enemies (collectively, “actors”) may choose to do several sorts of actions that don’t really classify as “attacks”, for instance:

  • Restoring HP, FP, or SP (via items, or special enemy abilities like Magikoopas’ healing magic or Bonetail’s heals).
  • Changing between states or forms (e.g. the player Defending, a Koopa Troopa un-flipping itself, a Dark Boo rising into an aerial state).
  • Other specialized actions, such as fleeing from battle, spawning extra allies, etc.

These sorts of actions, and how enemies choose what actions to perform are largely out of the scope of this article (and the latter will definitely be covered at a later date).

We can consider any action where an actor targets one or more actors in the battle (including itself) with the intent to deal damage or apply status effects an “attack”. Generally, the execution of an attack proceeds as follows:

  • Find all the possible targets of an attack (this is done before the player is able to select a command; if there are no possible targets, that option will be greyed out).
  • Determine which targets will be affected (possibly by the player / enemy’s choice).
  • Start executing the event script associated with the specific attack (to handle movement, Action Commands, etc.)
  • Before hitting each affected target:
    • Check to see if the hit succeeds (Did the attacker miss due to invis / evasion / accuracy, etc.? Were they countered by a hazard or Superguard?)
    • If the attack did successfully connect, apply the appropriate damage and/or status.

The main data structure specific to each attack that determines its properties is called a “weapon” internally. To some degree this sort of terminology makes sense (one could imagine an actor holding a physical ‘weapon’ that has an inherent range, damage, and status…), but generally players will attribute those properties to the attack itself, so I might use the term “attack” to interchangeably mean the entire attacking action, as well the “weapon” (or weapons, e.g. the different hits of a Spin Jump or Tornado Jump) used as a part of it from now on. Notably, weapons can also be used for some non-attacking moves for determining targets, even though the rest of the parameters won’t apply.

Incidentally, the concept of “attacks” can be extended to non-combatant-initiated moves as well; e.g. Bomb Squad bombs’ explosion, falling stage objects (or jets, walls, ceilings…), and audience Boos’ invisibility-granting swoop.

Attack parameters

Now that we have a baseline for what counts as an attack, let’s take a look at the data that makes up a “weapon”. If you want to look at the raw definition of the weapon structure, as well as many other structures used in TTYD’s battle system, I suggest reading through this resource on my “ttyd-utils” GitHub repository (look for the “BattleWeapon” struct).

Here’s what the raw weapon data looks like for Vivian’s Shade Fist; I’ve broken it up into bytes and color-coded which bytes pertain to various types of information:

Let’s do a deep dive through each of these categories, and describe all the possible values they can take on.

Attack Script Pointer

A pointer to the event script that is used to execute the attack from beginning to end. This is only generally used by player attacks and items, since enemies’ behavior and attacks are all baked into a single “attack script”.

Damage functions & parameters

All weapons that deal damage have to specify a function that determines their base damage, which can take up to eight parameters. (Similarly, attacks that deal FP damage have a separate function & set of parameters for that). The following is a list of all the functions used:

  • Fixed damage – Deals the damage specified by the first parameter. This is used by pretty much all enemy and item attacks.
  • Attack level + AC success-based – Deals a different amount of damage based on the rank of the jump/hammer/partner, and whether or not the Action Command was performed successfully.
  • Jump/Hammer + Badge Stacking – Same as the above, but adds an additional N damage per copy of the move’s associated badge equipped.
  • Action Command-based – Deals base damage + additional damage based on the output value from an Action Command (that value’s usage varies based on the type of AC).
  • Partner rank level – Deals damage based on the partner’s rank only (used for Doopliss’s partners).
  • HP / FP halved – Deals 1/2 the target’s HP or FP (there are variants to round up or down for HP).
  • Tornado Jump tornadoes – Deals fixed base damage, plus an additional N per copy of Tornado Jump equipped.
  • Hooktail FX R scaling – Deals base damage, minus the number of hits taken where Attack FX R activated.
  • Special functions based on the internals of Earth Tremor, Art Attack and Supernova.
  • Null, i.e. no damage is dealt by this move.

Notably, attacks can have a non-null damage function but still deal 0 base damage; such attacks can deal damage if the weapon can be affected by badges or statuses (e.g. Flower Fuzzies’ FP draining attack with a Power Punch), and/or if the target has P-Up, D-Down badges equipped (e.g. the fog stage effect).

Status Effects

Determines which status effects the attack causes, and their success rate, strength and turn count when applicable. Shade Fist, for example, causes Burn with a 100% base rate for 2 turns. The base success rate is multiplied by the enemy’s vulnerability to the status to determine how often it works, in most cases.

Stage Effects

Determines the chances of the move causing stage hazards: background falling, stage jets turning and/or firing, the ceiling falling, and props falling. There’s an extra parameter that seems to have been intended for use with another type of stage hazard in the past, but no code seems to remain that references it.

Other basic attack info

Miscellaneous parameters that aren’t part of the specialized ‘flags’ sections:

  • Item type (for attack items)
  • Base accuracy (always 100%, but theoretically a move could be given a natural miss rate, lol)
  • Base FP / SP (in full 1.00 units) cost
  • Superguard-ability (can the attack be Superguarded, and does it cause the enemy to recoil?)
  • Stylish command SP strength (always 1 in the US version, but some attacks in the Japanese release have 2x or 3x Stylish SP; see this video for more info!)
  • BINGO card chance on success
  • Element (normal, fire, ice, explosion, or electric)
  • On-hit effects (Mostly visual effects like Love Slap spinning the enemy around, but also includes the knockback effects from Gulp and the Hammer spin moves).
  • Action Command difficulty (always 3 by default; can range from 0 to 6, which would normally be the equivalent of 3 Simplifiers or 3 Unsimplifiers)

Allowed Target types

A set of flags that if set, can enable / disable certain types of actors from being targeted:

  • Cannot target Mario (or Shell Shield, if he’s currently shielded)
  • Cannot target partners
  • Cannot target enemies
  • Cannot target “system” units (the “system” actor itself, or Bomb-Squad bombs; pretty much all attacks disallow this)
  • Cannot target opposite alliance
  • Cannot target own alliance (Most attacks use alliance-based restrictions rather than Mario/party/enemy ones; these restrictions are flipped if the attack is used when Confused).
  • Cannot target self
  • Cannot target same species of actor
  • Only target self
  • Only target Mario
  • Single-target / Multi-target
  • Cannot target anything (probably only set dynamically)

There are also two flags that narrow down which parts of enemies with multiple targets can be targeted. In some cases, the difference between targetable parts can be mechanically interesting (Grodus vs. his staff, Cortez’s bone pile / rib cage) or a matter of timing preference (the dragons’ nose vs. their foot), but some enemies, like the Magnus von Grapple bosses, have two functionally identical but different target points for aerial and grounded attacks, just so the point of impact looks more natural.

  • “Force target highest-priority part” – Will force the attack to target the main part of an enemy if within range, and a secondary one if not. This is generally used for picking the more natural hitbox for a certain range of move to target if there are multiple equivalent options, but this does also mean some attacks with otherwise unrestricted range, such as Shade Fist, don’t have the choice to target Grodus’ staff or Cortez’s ribcage. Of note, Fire Drive is the only multitarget move besides Bomb Squad to not have this option set, meaning that all reachable parts are hit at once (making it hit Grodus and his staff).
  • “Only target certain high-priority parts” – Used only by Bomb Squad bomb explosions; the details are kind of fiddly but in practice this is generally used to make sure only one target can be hit at once on the same enemy (though Cortez notably can be hit on his open ribcage and bone pile at the same time).

If neither of those flags is set, the attack can freely target anything that is allowed by the enemy’s class / part properties, and the “archetype” of attack being used, as described in the next section:

Allowed Target properties / Attack Archetypes

Flags that control the range of an attack, as well as what “archetype” an attack belongs to.

  • Archetypes:
    • “Jump-like” – Generally doesn’t restrict anything, aside from a couple of cases where you’re forced to target a higher hitbox rather than a functionally identical lower one (e.g. Magnus and Magnus 2.0), and the special case in Cortez phase 2 where his head is too high to reach.
    • “Hammer-like” – Generally, disallows hitting aerial targets. Used by Gulp, Bomb, Love Slap, most grounded enemy attacks, etc.
    • “Shell Toss-like” – Functionally identical to Hammer-like, but used by Koops’ and enemies’ shell attacks.
    • “Tattle-like” – Generally forces you to target a specific part of each enemy for Tattles.
    • (Note that attacks can belong to none of the above archetypes, in which case they don’t have any of their specific target restrictions, e.g. Quake Hammer, all Special Moves, …)
  • Other properties:
    • Cannot target ceiling (used by jumps, Koops’ attacks, etc.)
    • Cannot target floating (used by Quake Hammer, Magnus’ earthquake, etc.)
    • Cannot target grounded (used by Tornado Jump’s tornadoes)
    • Recoil-type attack – prevents self-targeting if knocked back by Gulp or the spin Hammers, since those attacks are considered to be done by the actor being flung.
    • Target same / opposite alliance direction – Determines which direction should be considered the “front”; for the player, the “same” direction would mean treating the rightmost target on the stage as the front, where “opposite” would mean treating the leftmost as the front. Generally, attacks against the opposing team use the “opposite” direction, but buffs use the “same” direction.
    • Can only target front targets – Using the above definition of “front”, prevents the attack from being able to reach enemies behind the frontmost grounded target. This does still allow for targeting aerial enemies in front of it (provided the attack can normally hit them), though. There’s also a barely-used feature where enemies sufficiently far in the background (-30 or more units on the Z-axis) count as being on a different plane; this is what allows attacks like Shell Toss to be able to target the Shadow Queen or her right hand, but is basically only used in that fight (enemies in standard fights span from -20 to +20 units from the origin on the Z-axis).

Random target weighting schemes

After narrowing down the valid targets using the parameters above, if the attack being used doesn’t have the means of selecting a target manually (such as Mini-Egg’s eggs or the vast majority of enemy attacks), each valid target is assigned a weight, and those values are used to either select a target randomly, or based on the highest weight.

By default, these weights are 110 for the “frontmost” target, and 100 for all others, but there are a number of schemes used to modify these weights:

  • Prefer Mario – Make Mario’s weight 50% higher.
  • Prefer Partner – Make Mario’s partner’s weight 50% higher.
  • Prefer Front – Multiply the weights by 0.5, 0.9, 1.3… from back to front. This is used pretty frequently on enemy attacks, essentially making the front player character about twice as likely (99 : 50) to be selected.
  • Prefer Back – Multiply the weights by 0.5, 0.9, 1.3… from front to back. This is only used by Cortez’s second attack in his first form, and Blooper’s right tentacle (which has separate attacks for hitting the front and back party member!)
  • Prefer Same Alliance – Make teammates’ weights 50% higher.
  • Prefer Opposite Alliance – Make opposing actors’ weights 50% higher.
  • Prefer Less Healthy – Multiplies weights by (2.0 – target’s current fraction of Max HP).
  • Greatly Prefer Less Healthy – Multiplies weights by (1.0 – target’s current fraction of Max HP).
  • Prefer Lower HP – Multiplies weights by (1.5 – target’s current HP / 20). Effectively makes weights negative if their HP is over 30; this would cause unintended behavior if there were any such moves with random target selection used in battles with enemies that have 30+ HP, but no such battles exist in the vanilla game. This is also why Kammy Koopa prioritizes healing Bowser over herself if both are at 30+ HP, even if Bowser is at full health.
  • Prefer Higher HP – Multiplies weights by (1.0 + target’s current HP / 20).
  • Prefer in Peril – Multiplies the weights of actors in Peril by 50%. Humorously, this occasionally makes Dull Bones the preferred targets for healing items even if they’re at “full health”.
  • Choose Randomly – Picks from the final weights randomly in a weighted fashion; otherwise, chooses the target with the highest weight (preferring targets closer to the front in the case of a tie).

Enemies may rarely use other means to determine targets; e.g. Kammy explicitly chooses who to target with her magic buffs in her attack script, independently of the weighting system. In addition, enemies have specialized logic for determining when and on whom they should use their held items; that will be covered in a future post.

Counter-attack resistance

These flags determine whether the attack is immune to certain contact hazards:

  • Top-Spiky
  • Front-Spiky
  • Pre-emptive Spiky – Spikes that activate when getting near the enemy; most notably Bristles, but X-Punch and all of Cortez’s weapons except the Hook also have this property.
  • Fiery
  • Icy
  • Electric
  • Poisonous
  • Explosive – Used for unlit Bob-ombs; only checked if the move has an element that will make them explode on contact.
  • Volatile Explosive – Used for lit Bob-ombs.
  • Payback / Return Postage
  • Hold Fast – Interestingly, shares the same values as the explosion-type counter immunity for all attacks, but not necessarily Payback immunity (for instance, most shell attacks get countered by Payback, but nothing else).

Other special properties

Finally, there are a handful of flag-based parameters that don’t fall under the previous categories.

  • Badge-mutable power – Can have its damage boosted by badges.
  • Status-mutable power – Can have its damage altered by status effects (includes Merlee’s +ATK boost, for attacks that happen on Mario’s turn).
  • Chargeable – Can be boosted by / expend the Charge status.
  • Cannot miss – Ignores evasion / invisibility / accuracy (e.g. Special Moves, most buffs).
  • Diminishing returns per hit (e.g. Power Bounce, Atomic Boo breath attack)
  • Diminishing returns per target (e.g. Fire Drive, Atomic Boo surprise attack)
  • Defense-piercing
  • Can break Freeze status – A dummied-out status mechanic, where some attacks would have a chance to end Freeze early.
  • Ignores status vulnerability – Makes statuses guaranteed to hit if the target is not immune to them (e.g. cooking items that heal but inflict guaranteed negative statuses).
  • Ignites if burned – Turns attacks fire-elemental if the attacker is Burned (not used).
  • Flips shelled enemies (e.g. Jump)
  • Flips Bomb-flippable enemies (e.g. Bomb against Clefts)
  • Grounds winged enemies
  • Usable when Confused
  • Unguardable – Cannot be guarded or Superguarded.

Non-Weapon Parameters

We’ve covered basically every known parameter that can be assigned to an weapon now, but there are of a handful of notable additional flags that are only handled in the attack’s script code (most of which are set dynamically) that bear mentioning:

  • “Lethal” – Surprisingly, a flag has to be passed explicitly for a hit to be able to knock out the target at 0 HP; this is turned off for the early hits of most multi-hit attacks so the death animation isn’t interrupted by another hit. This is why some multi-hit attacks either hit or miss the entire string of attacks, or are forced to land the last hit if any prior ones connect (e.g. Hammer Bros.). Notably, some attacks never have this set, and rely on a “ghost hit” after the attack ends to kill units that reached 0 HP (e.g. Rawk Hawk’s prop drop).
  • “Action Command succeeded” – Has to be passed into the damage-dealing routine to treat an AC as successful; the AC result is fetched by a separate function call earlier in the script.
  • “Suppress status application” – Disables status ailments; used for Shade Fist with a failed action command.
  • “Allow status application” – Generally, statuses can only be applied by lethal hits; this is used on Mini-Egg to allow any of the hits to apply Tiny status.
  • “Achilles’ heel weakness” – For dealing with Iron Clefts’ unique defense type. This is only ever applied to Gulp, but is only passed in through the event script rather than being an inherent property of the weapon; in theory any attack could have that flag set.

Concluding Remarks

This should hopefully give a decent overview on all the stuff that goes into specifying how every attack in the game behaves; this only scratches the surface of the complexity of how attacks are implemented, though, as every attack has dozens of lines of script code dedicated to selecting targets, moving characters around the screen, visual effects, and so forth.

I might do a deep dive on some particular aspects of the script side of things in the future, and I definitely intend to give an overview on particular things specific to enemy AI sooner than later. In the meantime, if you’d like to get a hands-on look at all the raw weapon data in the game, as well as what various attack scripts look like as a whole, my ttyd-utils GitHub repo has tools for exporting the all the weapon structures and scripts from the game data as CSV / text files.

Tidal Wave, and Breaking the Limits of Human Perception

So, Sushie’s Tidal Wave.

At first blush, this move may seem a pretty standard rounding-out of Sushie’s kit, being comparable in utility to Bombette’s Power/Mega Bomb, and identical to Parakarry’s Air Raid in cost and range (actually, her entire kit is basically equivalent to Parakarry’s aside from Water Block being a far more usable tool than Air Lift, but partner comparisons are a matter for another time). Its damage being dependent on correctly inputting a series of buttons isn’t too strange, either; several moves in The Thousand-Year Door have comparable Action Commands (Fiery Jinx being the closest, but also the likes of Dodgy Fog, Veil, or Showstopper).  However, although Tidal Wave does have a target level of performance required for a “successful” Action Command (six inputs nets a “Nice”), unlike its kin, it is not actually stopped at that threshold, instead allowing the player to input as many buttons correctly as they can in a fixed allotment of time.

This has interesting consequences; since the damage dealt is tied directly to the number of correct inputs, Tidal Wave has the potential to be by far the most damaging multi-target partner move (or even single-target, excluding Goombario attacking with a Charge, or a plain Multibonk on a sufficiently low-cap enemy), as well as the best bang-for-buck in terms of FP cost.

The question then arises, how tenable is getting this sort of result out of Tidal Wave, and are there any hard limits on what it can do?  To start, let’s look at how the move’s Action Command works in detail.

Tidal Wave’s Action Command – An Overview

Originally, I had planned on going off of my own and Rain‘s empirical testing for the mechanics of the move, and that would have been sufficient to get a decent understanding, but as it turns out, I was actually able to contribute a full decompilation of Tidal Wave’s Action Command update function to the papermar.io decomp project, furthering my understanding even better!  (As an aside, if you’re at all familiar with the original game and/or the C programming language, and are interested in a better future for the understanding of PM64’s code or the possibilities of modding the game, I strongly suggest joining their efforts!)  The following is a somewhat streamlined specification of how Tidal Wave’s update routine / inputs work.

At the simplest level, the attack consists of pressing the A, B, or C-Down buttons, based on a series of random button prompts that appear one at a time.  Incorrect presses will not end the attack prematurely, but will lock the player out from being able to proceed for a short while.  Each sequential pair of buttons is guaranteed to be distinct from each other; that is, the same button prompt will never appear twice back-to-back.

As for how the game checks for the player’s inputs, to start, the structure containing Paper Mario’s battle data holds among other things, a ring buffer that holds the last 64 frames’ worth of inputs (both newly pressed and held, but for Tidal Wave’s purposes we’re only concerned about the history of button presses).  It’s worth noting that for the purposes of this input buffer, as well as any graphical updates and a number of other processes, the NTSC versions of Paper Mario run at only ~30 frames per second, rather than the sequel’s ~60.  Most if not all Action Commands will check over the last handful of frames’ inputs at the moment an input is needed, rather than proactively tracking inputs starting at the “beginning” of an input window (several of TTYD’s work fairly similarly as well); for instance, the Jump action command checks for an A button press in the five frames before landing:

 

For Tidal Wave specifically, from the first frame a button prompt appears on-screen, the game checks the input history starting from the previous frame to look for a match; notably, the current frame’s input is never considered.  If you input the button successfully on a given frame, the next frame it will be accepted, and the game takes a frame afterward to play an animation of the button shrinking; on a the frame after that, the next button prompt will appear.

The extra frame of animation after a successful press has the side effect of a frame’s worth of inputs (specifically any inputs made on the frame the previous correct input was processed) being ignored completely; this doesn’t matter (yet), particularly if you’re only inputting buttons after reacting to the prompt, but is an interesting bit of trivia nonetheless.

Note that every frame, the game will continue increasing the window it looks back over until it actually detects a button press (up to a max of 15 frames).  That doesn’t matter in the case of a successful press, given inputs won’t magically be skipped on one frame only to be detected later on.  However, this increasing window does matter if you input an incorrect press; if a button press other than the prompted button (or any combination of multiple button presses) is detected within the lookback window, the game plays a buzzer sound and will not process inputs again until 10 frames later, at which point it will look over the previous 10 frames’ inputs.

In this example, the B button was pressed on frame 3 of the prompt and detected frame 4; this locked the attack from checking for inputs again until frame 14, where it looked at inputs from frames 4-13, and found that A was pressed on frame 7.  A single A press anywhere in that window would result in the same automatic success on frame 14, as would an A press anywhere in that window, followed any arbitrary combination of button presses during the rest of the window:

This buffer system can be convenient (e.g., for allowing a corrected input slightly before the lockout period actually ends), but consecutive mistakes can be costly!  If an incorrect button is pressed first in the 10-frame lockout window, then on the frame it ends, another 10-frame lockout will start immediately, and the first button pressed in those ten frames or afterward will be processed when it ends.  Notably, if the player were to buffer two or more button presses during a lockout window, only the first one will ever be considered.  For instance, if the player were to press B on frame 3 (resulting in a lockout starting frame 4), then realized their mistake and fat-fingered B, then A on frame 9 and 10, respectively, the B press on 9 would start another lockout window on frame 14, and the A press would be lost, meaning the player would have to press A again sometime on frame 14 or afterward (which would be detected on frame 24 at the earliest) to continue to the next prompt.

This basically covers everything about the move technically aside from its duration; the attack lasts for a total of 98 inputtable frames (including the look-back frame before the first button appears), or just under 3.3 seconds.  In theory, with tool-assisted frame-by-frame advancement to press a button on the first frame its prompt appears on-screen, the minimum time between presses is a mere 3 frames (one for the input to be processed, one for the animation of the button shrinking, and one for the next prompt to appear).  With added rewind / savestates to gain foreknowledge of what button would come next, this could be cut to 2 frames per button, since you wouldn’t have to wait for it to visually appear.  In either case, this would theoretically allow for dozens of presses; however, things aren’t that rosy in actuality.

If playing on console (and some emulated versions of the game), pressing 14 correct buttons causes the game to crash.  I don’t know the exact reason why this occurs, but I know that the Action Command data structure has space for 15 HUD element identifiers, the first of which Tidal Wave reserves for some specific use, and the rest of which are allotted one per button, so my guess is there’s some sort of buffer overrun happening when a fifteenth button icon is attempted to be spawned.  Funnily enough, the devs did foresee this potentially being an issue, and put a check in the code to stop the attack early when processing the 15th button; unfortunately, that check only gets reached after the fifteenth button icon would have already spawned, at which point it’s too late to fix the issue:

So sadly, the dreams of Sushie dealing nearly enough damage to one-shot the Anti Guys Unit at full health are crushed, but given the game was originally meant to be played by humans, who don’t generally perceive the game frame-by-frame (much less a frame in advance), how many buttons should one reasonably expect to be able to press in the first place?

The Limitations of Human Reaction

From what’s been discussed before, if going only by what’s already visible on screen, in addition to the 2 unavoidable frames between each button prompt, a human player is going to necessarily waste at bare minimum one frame per button prompt, as they wouldn’t know what to press before the button displayed on screen, and it takes an extra frame before the previous input can be read.  But that’s assuming instantaneous reaction time, which even in the best of setups is unreasonable.  From what I’ve heard from a variety of sources, an average human reaction time to any visual stimulus is somewhere in the ballpark of 200 to 250 milliseconds at best, which would add an additional 6-8 frames on top of that (using a low-latency 144Hz monitor with this test, I can personally pretty consistently hit the lower end of that range).  This is before compensating for additional factors like latency in one’s monitor or emulation setup, which could easily add another ~100ms (3 frames) or more on top.

All of this is also only considering reaction time to a single given stimulus, whereas Tidal Wave always has at least 2 possible choices for each button prompt.  A cursory search didn’t turn up any good sources or tools for determining how much added mental load comes from distinguishing multiple possible stimuli (and since the button choices are random, prediction will get you at best a 50% success rate per button), so I went ahead and tested how well I could perform the actual move.

Experiment 1: Pure Reaction

For this and future experiments, I did my tests on elDexter’s Black Pit mod (since I had it handy at the time, and it also includes a fix Rain and I came up with that ends the move after 13 successful inputs to avoid crashing) using an actual N64 and Everdrive on a CRT, which should have pretty much the minimum possible latency while maintaining accurate performance (i.e. no slowdown).  I also gave myself two warmup runs of the move before doing ten actual trials (this will be the case for future experiments as well).

Using pure reaction and no early guess inputs, my results were fairly consistent:

6, 6, 6, 6, 6, 6, 7, 5, 6, 6

The one run where I got only 5 had multiple input errors, and the one run I got a 7 had no premature presses but I suspect had lucky priming (i.e., I “expected” the button that actually appeared more often than not).  A couple other attempts were likely a few frames off of 7 inputs, but not quite there.  Given the attack lasts 98 inputtable frames and disregarding the 19 frames wasted due to the time between / before prompts, my reaction time must have averaged between 79 / 7 and 79 / 6 frames per button (about 11.3 ~ 13.1 frames, or 380 ~ 440 milliseconds).

So humans are disappointingly slow at this sort of thing, then, and it seems like even the thought of double-digit damage is well out of the question for guess-less reaction.  But intriguingly, my average reaction time is actually longer than the lockout period the player is punished with after an incorrect press (10 frames, or ~334 milliseconds).  This, plus the fact that all button prompts after the first one have only two possibilities, leads to a wealth of possible exploits!

Removing Reaction from the Equation – The Genesis of “Cycle-Mashing”

Assume that the player has just correctly input the C-down button for the first button in the attack.  There are then only two possible prompts that could come up next; A or B.  If a player reacted with comparable reaction time to me, their input for the second button would occur about 14-16 frames after the previous one.  But suppose instead they chose not to react, but to execute a predetermined response instead, pressing A 2 frames after the C-down input and B another 2 frames after that.  If the next button was A, it would be immediately received correctly, saving a whopping 12 to 14 frames over reacting normally; but as it turns out, even if the button was B, after the 10-frame lockout period ended from the A press, the B would be taken immediately, still coming out 2 to 4 frames earlier than a reaction!

Furthermore, this sort of approach can be chained!  Here’s the basic idea of the simplest setup that accomplishes this:

  • The player reacts to the first button normally (A, in this case).
  • Since the game doesn’t consider inputs made on the frame the correct input is processed, the player waits at least 2 frames (0.067 seconds) to input anything else, then presses one of the other two buttons.
  • After that, the player cycles through the three inputs in a consistent order, starting with the button not yet pressed, timing it so that every button is pressed 12 or more frames after the one two presses before it (guaranteeing that the first of the two possible buttons after a “wrong guess” lockout scenario doesn’t get eaten by the frame where input is ignored).

Experiment 2: “Slow” (4~5Hz) Cycle Mashing

The simplest possible variant of this line of approach is to react to the first button press, then cycle through the buttons in order (either B, A, C-down or B, C-down, A starting from whatever the first button is) at a rate of 6 frames per press or slower (5 Hz / button presses per second).  I’ve taken to calling this sort of approach to Tidal Wave using “Snow-Whirled strats”, after the Mario Party 6 minigame that requires a similar sort of input, but “cycle-mashing” is probably a more descriptive term.

If performed accurately at exactly 5 inputs per second, this guarantees that every prompt is successfully hit within one or two attempts, and allows the time between inputs to get as low as 12 frames in the worse case (2-4 frames faster than my average reaction time), and a mere 6 frames (saving 8-10 frames over reaction) in the better case!  Even if performed a fair bit slower (7.5 frames per press / 4 Hz) to reduce the risk of slight variance in speed causing a button press after a lockout to get ignored, the worst possible case is still comparable to human reaction, with a time save of 7.5 frames per better-case prompt.

To practice mashing between 4 or 5 buttons a second, one could imagine keeping time in eighth notes to a tune between 120 and 150 BPM.  Conveniently the standard PM64 battle theme falls snugly in that range (at right around 140 BPM!), but one could feel free to experiment around and see what works.   How did this fare in practice, then?

7, 9, 7, 8, 3, 6, 8, 10, 6, 9

A definite improvement on average!  Of note, the first “6” was actually the worst possible string of prompts I could have gotten given the direction I was mashing in; I cycled through C-down, B, A in that order, and the seven buttons I got were C-down, A, B, C-down, A, B, C-down.  So good to know that this holds up against reaction even in the true worst-case!

The one outlier “3” there was one where I totally failed to input a button or two, trapping me in a cycle of lockouts for most of the attack.  Therein lies the problem with any cycle-mashing exploit, actually; going off-script has pretty variable results depending on exactly what kind of luck you get afterward.  But if you can manage a steady 4-to-5 Hz cycle with no dropped inputs, these results prove you can definitely get Tidal Wave to at least equal Power Bomb / Mega Bomb in damage, and it certainly outstrips Air Raid’s utility.  But there are still more possibilities we can consider…

Experiment 3: “Lopsided” Cycle-Mashing

As a slight variant of the 4-5Hz mash, consider that the main stipulation to avoid eaten inputs is that every other press must be separated by 12 frames or more.  The natural way to accomplish that would be to press each individual button 6 frames apart, but strictly speaking there’s no functional difference in the worst-case between doing that, and alternating windows of 2, 10, 2, 10, … frames (1+11 wouldn’t work, as a “good” scenario would result in the second input in a short pair getting ignored):

Having to mash pairs of inputs — BA, CB, AC … — close together, rather than a consistent cycle, does add complexity, but could save the player up to 4 frames (or more, with a slower mashing speed) at the end of the attack if they happen to end the attack in the that particular part of the cycle.  In practice, here’s what I got for my results (mashing with close pairs at around 135bpm, or 2.25 per second):

9, 9, 8, 6, 9, 8, 8, 9, 8, 9

I happened to be surprisingly consistent during this test; I don’t know how much of that came down to the potential extra few frames, and how much came down to more average luck (or potentially added resilience to mis-inputs, as I know I definitely made more input errors this time).  Overall not too big an average difference, though; especially given this is also probably harder to input on a controller that doesn’t have C-down mapped to a dedicated button, I wouldn’t recommend this over the previous approach, but I thought I’d mention it here for reference.

Neither of these were actually my initial approach to breaking this move, though…

Experiment 4: “Fast” (10.7~12.5Hz) Cycle Mashing

This is closer to my original concept for a mashing strategy to beat reacting to the move on average.  Honestly, I didn’t really come up with the slower variants listed above until I started researching for this article; really, it just goes to show how much I underestimated just how slow reaction time is!  At any rate, the gist of the strategy is the same; react to the first button, then cycle, but rather than abusing the lockout window by pressing 2 buttons every 12+ frames, one can abuse the fact that the lockout window only buffers the first input pressed within it to fit in an extra cycle’s worth of buttons, pressing 5 buttons every 12+ frames, and cutting down the wasted time if you get a “good” button prompt!

This higher-speed approach is not without its downsides; in this case, rather than 10.7 Hz (~14 frames per 5 presses) being a practical target before the worst-case approaches what would already be possible with reaction (though that is still a consideration), it’s actually absolutely vital to mash at a sufficient rate to guarantee (or at least make it very likely) that exactly four buttons land in the lockout window in the case of a “bad” prompt.  Otherwise, you run the risk of starting the next prompt with two wrong buttons in a row, causing a double-lockout at best and ruining the rest of the attack at worst:

This is easier to avoid the closer to the 12.5 Hz speed you can reach, but mashing at a high speed also runs the risk occasionally of landing two presses less than 2 frames apart if your rate is too inconsistent, meaning a correct button could be followed up by another one on the next frame, getting ignored.  In practice, I think this sort of mistake happens a bit less often than errors related to going too slow when practiced up, but it’s kind of hard to tell.  Obviously, straight-up missing inputs can easily throw everything a bit out of whack as well, but how much it affects results depends on when exactly it happens (e.g. if it happens during the latter part of a lockout period, it might not make any difference at all!)

Despite all the shortcomings, this strategy has the potential to be explosive if you get even moderately lucky; whereas “worse-case” prompts will still take 12-14 frames between inputs, “better-case” ones will take less than 3 frames on average, saving huge amounts of time throughout the span of the attack in all but the worst cases!

Here’re the results I got on a set of ten trials:

9, 9, 10, 8, 7, 5, 5, 12, 8, 9

As the 5’s (which were definitely caused by at least one failed input) suggest, this is definitely a riskier strategy than the earlier ones, but is the first one with a fair chance of landing a sweet double-digit damage number across the field!  (Although with that chance comes the risk of a crash after 13 presses if you’re not careful; oh well…)

If this hasn’t scared you away yet, you could finally try:

Experiment 5: “Reactionless” Fast Cycle-Mashing

Same idea as before, but now you don’t even wait for the first button to react, instead starting a cycle-mash as soon as (or even before) the attack starts.  This was actually the first mashing method I ever came up with (and I recorded a sample of myself executing it on console, with video proof of ability to hit 13s and crashes here).  On average, it slightly outperforms the previous method when simulated with perfect inputs, especially towards the faster end of the mashing speed range.

The killer in practice, though, is that in addition to all the previous drawbacks, there’s the possibility that the first button is neither of the first two buttons pressed, incurring at bare minimum a two-lockout (20 frame) penalty over the best-case 2-4 frame “instant” first successful press, if not more depending on your exact speed and consistency.  If you’re lucky, though, a successful first press will save a solid 10+ frames over reacting, massively increasing the likelihood of a 10+ damage attack.

My results for this were disappointingly tame (though surprisingly more consistent) compared to some previous recordings and off-stream play sessions, alas:

7, 7, 9, 9, 7, 10, 8, 6, 6, 7

Likely, this is both due to unluckiness with the relative inconsistency of the start of the attack, and due to the fact that it’s kind of hard to pinpoint exactly how fast 10.7-12.5 Hz is while keeping an even tempo.

Conclusions / Parting Words

All in all, Tidal Wave is a really unique move and fun to mess around with for a variety of reasons.  If there’s any takeaway from this article it’s that I strongly suggest you try out at least the slow cycle-mash; it should be pretty doable on any controller (provided you don’t have a C-stick that likes to input left and right randomly when pressing down, as those do count as “wrong” inputs!) and isn’t likely to perform any worse than performing the move normally, especially if you have a higher-latency setup than mine.  I feel the mechanics of the input buffer still leave some untapped potential for even more better-than-reaction strategies, as well.  I didn’t even really try out stuff like purely random mashing (mostly due to it not benefiting from my cycle-mashing strats’ abuse of the fact that most prompts only have two possibilities), or any strategies involving both predetermined input sequences and further reactions.

Let me know if any of these strategies give you markedly better results on Tidal Wave than before, or if you’ve found any other strategies that get consistent results (preferably with videos and/or theorycraft explanations, in which case I might make addendums to this post in the future!)

Sorry that I’ve been a while in getting to the next big TTYD post, but Tidal Wave’s been in the back of my mind as a topic for years now, and I’ve been distracted by both getting a major v2 update out to my TTYD Infinite Pit mod, as well as playing through elDexter’s previously mentioned (and excellent) Black Pit mod, contributing to the PM64 decompilation, and other such things.  I imagine I’ll get back to it some time this year, but I can’t predict my interest levels in my side projects, so you’ll have to bear with me in the meantime!

Playing to the Crowd: TTYD’s Audience System In-Depth

At long last, perhaps the most overdue writeup of all Paper Mario: The Thousand-Year Door’s combat systems; I’ve been researching TTYD’s battle audience system on-and-off for the past several years, and here’s the most complete look I’ve ever been able to give on it.

Introduction: The Audience’s Duality – Crowd of Individuals or Mass Hivemind?

Let’s start with a fundamental question; what exactly is the battle audience composed of, mechanically?  As it turns out, the game’s exposed view of it paints a pretty decent picture:

On the one hand, you have a colorful cast of individual audience members, each with their own seat and picked from a handful of different species, forming a crowd with varying composition (usually a relatively few distinct types at a time, as shown here, but potentially a potpourri of different Mushroom Kingdom denizens).

And when getting into details on how Star Power regeneration, thrown items, or area-of-effect events work, the specifics of who’s who do matter. But deep down, the audience secretly wants to be something much simpler; a simple decimal number, ranging from zero to whatever the occupancy of the auditorium Mario’s rank gets him booked permits. And it’s this numeric side of things that offers the simplest place to start gaining a full comprehension of the system; so let’s begin there, shall we?

Audience as Mass

There are a few different numbers one needs to be cognizant of that affect the trajectory of the audience’s size, one of which is fixed and the other two freely varying amid and between fights.

The game’s desired base target amount of audience, which will be referred to as the base, is a constant value based on your level, and doesn’t impact directly how much audience you start and leave a fight with (though it will play a heavy role into how quickly you gain or lose audience, as will be detailed later).  Specifically, this base value is equal to (3 x Mario’s level) + 5, up to a max of 200.0.  As such, your stage’s maximum capacity (ranging from 50 at levels 1-9 to 200 at 30+) far outstrips where the game “expects” your audience level to be until you reach ridiculously high levels (only finally meeting up at a whopping level 65).

The actual size of your audience at any time is a sum of two values: your “permanent” audience target value (referred to henceforth as the “target” audience value), and a “temporary” value on top of that (referred to as “bonus” audience) which is generally 0, but can be positive or negative depending on specific circumstances.  The “target” audience value is what’s saved between fights, which leads to a reasonable amount of consistency across multiple fights if you’re generally doing well or poorly at keeping the audience entertained.  By contrast, the “bonus” audience is used typically for exceptional cases (such as BINGOs, stage hazards or the packed house you start with for most boss fights) that shouldn’t reflect on your general performance, and as such won’t stick between fights.

At any point in the fight, the individual members of the audience will aim to fill a number of seats dictated by the sum of the “target” and “bonus” values; if something happens that shifts this total, the game will gradually have members fill in or vacate seats accordingly until the visible audience and invisible target values align again.  Now that the numerical stage is set, let’s look at the individual types of audience that make up the crowd…

Meet the Cast

PicDescription / notesItems (Weight)
Toads are one of your best assets in the audience, providing as much SP for attacks as three regular audience members, and occasionally throwing a number of helpful items!Coin (10)
Heart (10)
Flower (10)
Mushroom (50)
Super Shroom (10)
Ultra Shroom (1)
Life Shroom (5)
Honey Syrup (10)
Fire Flower (10)
Thunder Rage (5)
Shooting Star (5)
Goombas are the simplest audience members; they don’t do anything special, only occasionally throwing rocks or cans.Rock (20)
Can (20)
Koopa Troopas are generally pretty laid-back, occasionally throwing either helpful or harmful items.  If the fight goes on too long, they may get bored and hide in their shells, preventing them from giving you any Star Power for that time.Coin (10)
Heart (10)
Flower (10)
Courage Shell (10)
POW Block (10)
Rock (10)
Can (10)
Shy Guys are quite the tricksters, offering the widest array of possible item throws.  In addition, their special event may have them rush onto the stage, triggering certain stage hazards.  I guess they felt like getting a piece of the action somehow, given they don’t appear as regular enemies.Ice Storm (10)
Earth Quake (10)
Volt Shroom (10)
Sleepy Sheep (10)
Dizzy Dial (10)
Ruin Powder (10)
Power Punch (10)
Stopwatch (10)
Mini Mr. Mini (10)
Mr. Softener (10)
Point Swap (10)
Fright Mask (10)
Mystery (10)
HP Drain (10)
Rock (30)
Can (30)
Dull Bones, perhaps unsurprisingly, serve to suck all the life out of the party.  They only throw harmful objects, and worse than that, don’t provide any SP when attacking, only Appealing!Bone (10)
Rock (10)
Can (10)
X-Nauts won’t settle for less than perfection; if they see you waste a turn attacking an enemy without harming them, or get countered by an enemy on contact, they’ll pile the hurt on you with a flurry of thrown rocks!Rock (10)
Can (10)
Punis can offer a number of helpful items, especially sweet syrups, and will swarm the audience if you use Stylish moves!  However, they’re quite jittery, and will all run off at once if they feel threatened by loud noises.Coin (10)
Heart (10)
Flower (10)
Dried Shroom (30)
Honey Syrup (20)
Maple Syrup (5)
Jammin’ Jelly (1)
Tasty Tonic (10)
Slow Shroom (10)
Gradual Syrup (10)
Boos offer a couple of the more exotic items such as Spite Pouches and (naturally) Boo’s Sheets.  They may also attempt to turn any one of the combatants invisible for a turn!Repel Cape (10)
Boo’s Sheet (20)
Spite Pouch (10)
Rock (10)
Can (10)
Dayzees are quite the spotlight hogs; they don’t offer anything special, but have a chance of putting the entire audience to sleep, robbing you of precious Star Power for the duration!Nothing
Bulky Bob-ombs take up the space of two audience members, putting a damper on your SP recovery; in addition, if the battle drags on, they can ignite their fuses and blow away a large chunk of the audience!Nothing
Piranha Plants act casual for the most part, but may very rarely prey on unfortunate adjacent audience members.Nothing
Hammer Bros. are largely the same as any other audience member, but if you fail a Hammer attack while they’re watching, they’ll throw their Hammer at you to show you how it’s done!Hammer (10)
Rarely, the one and only Luigi may show up to cheer on his bro!  If the battle goes on long enough, he may try lending support by tossing one of his items (or a rock, if he’s feeling especially vindictive?)Coin (10)
Heart (10)
Flower (10)
Mushroom (10)
Super Shroom (10)
Ultra Shroom (10)
Honey Syrup (10)
Maple Syrup (10)
Jammin’ Jelly (10)
Shooting Star (10)
Rock (10)

Now that we’re familiarized with the audience types and their collective numeric underpinning, let’s look at how the audience gets filled out at the start of a bout.

Part 1: Getting the Battle Started – Audience Initialization

First off, it’s worth mentioning that as long as you don’t have any Star Powers obtained, the audience and BINGO slots will be disabled, rendering the entire initialization (and the rest of this article) moot.  Assuming that’s not the case…

Picking a Target Value

First off, the fight has its target value copied from the previously saved target value, and adjusted by a random amount.  Specifically, that amount is determined by picking two random numbers in the range [0, 10), and adding the following quantity to the target:

(randVal1 + randVal2 – 13) * 0.01 * (“target” value – “base” value)

This serves to fluctuate the starting audience amount slightly between fights, especially when it’s far from the expected base value.  If the resulting value is smaller than 0 or greater than the stage’s capacity, it’s clamped to that range.

At this point, if a fight should have a maxed audience (generally the case for most boss battles, notably excluding your first encounter with Doopliss, Lord Crump in Chapter 5, and Bonetail), your “bonus” audience value is set to the stage’s capacity minus your current “target” value, making their combined target equal to the max capacity.

Determining Composition

The rest of the setup has to do with picking the member types the audience is generally composed of.  For most “boss” fights (all but Red Bones and Hooktail), this composition is fixed, as follows:

  • Magnus von Grapple – Only Punis and X-Nauts (initially filling the left and right sides of the arena, respectively)
  • Grodus – Only X-Nauts
  • Grubba, Doopliss’ final battle in Ch. 4, Cortez, Smorg, Magnus 2.0, all other Ch. 8 bosses – Mix of all types

For all other fights, the following process is performed to select the types that should appear and their relative frequency; each individual battle has its own table of base weights per “type” of audience determining which types can appear, and how often they should appear if their type is one of the types selected for the composition. (Note: Luigi doesn’t count as a “type” of audience and is handled separately.)  Here are some examples:

BattleAudience Weights
Goomba (10), Toad (5), Shy Guy (5)
Toad, Goomba, Koopa, Shy Guy, Dull Bones, X-Naut, Puni, Piranha Plant, Dayzee (All 4)
All Types (3)

As a rule of thumb, the types of audience available in a battle are generally introduced one at a time as you progress through the game (This isn’t a perfect predictor, especially for Pit battles, many of which have a chance of anything showing up).  Generally, the weights are also higher for audience types related to the enemies in the battle, like Goombas in the first battle above; this doesn’t impact how frequently that audience type will be selected to show up at all in the battle, but does mean that it will typically make up a larger proportion if it is selected.

Given this set of weights as a starting point, the game does the following to pick which types should actually appear every time you start a battle, as well as their relative frequency:

  • Pick the number of different types (N) the audience should contain, based on the following weights (As one might have experienced in-game, generally battles are composed of only 1-3 types of audience members.):
# of Types123456789101112
Weight204020532111115
  • Order a list of the twelve audience types randomly, and select the first N types (as determined in the previous step) in the shuffled array, skipping ones that can’t appear in the particular battle (e.g. Boos in the Ch.1 or Ch.4 examples above).  If there are N or fewer types available to choose from for this battle, then all of those types are included.
  • Multiply each selected type’s base weight for the battle by a random number from 1 to 10.
  • Check to see if Luigi should appear in the starting audience (which he will do 5% of the time).

Allotting Seats

The audience is then filled up to the target amount, roughly matching the composition determined above.  For instance, if the composition was Goombas with weight 6 and Koopas with weight 2, a starting target audience value of 80 should produce an audience of roughly 60 Goombas and 20 Koopas.  These weights are used to determine the type of new members entering throughout the rest of the battle (e.g. a new member in the aforementioned scenario would be a Goomba roughly 75% of the time).

Of note, Bulky Bob-ombs’ weights determine the relative number of individual members at the start of a battle, not the amount of space they take up; for example, if a battle composition has Dayzees with weight 8 and Bulky Bob-ombs with a weight of 3, a target audience value of 140 would produce an audience of roughly 80 Dayzees and 30 Bulky Bob-ombs (since they take up 60 seats).

Now that we’ve filled in the house, let’s take a look at all the various functions the audience performs throughout the course of a battle.

Part 2: Audience Participation – Events Overview

Once in the heat of battle, the audience’s main passive function is to provide the player with Star Power to power Mario’s Special Moves.  The details of calculating how much SP is gained from attacking or Appealing is already covered in detail by this previous article, so I won’t belabor them here.

Beyond that, there are two additional mechanisms where the audience has an impact on battle: throwing items during the player attack phase, and various audience events occurring after the enemy attack phase.  (For a refresher on where exactly these phases fit into the turn structure, see my previous article on the topic.)

Item Throws

Before each turn begins, the game determines a maximum number of random items the audience can attempt to throw during the following turn — this has an 80% chance of being 0, a 10% chance of being 1, and a 5% chance each of being 2 or 3.

During the player attack phase, while the player is idling or making menu selections, the game checks once every frame whether to spawn a random item if the max has not yet been met for that turn.  For the first item on a given turn, this has a ~1/1800 chance of succeeding (meaning the item will spawn after ~30 seconds on average); for the second it has a ~1/6000 chance (spawning after ~100 seconds on average), and for the third it has a ~1/16000 chance (spawning after ~4.5 minutes on average).  Note that these random audience throws will only happen one at a time, and they will not occur while any audience members are executing a scripted item throw based on an end-of-turn event (as described in the next section).

If the check is successful, the game randomly shuffles the audience members’ IDs and checks each until finding one that’s able to spawn an item.  Reasons a member might not be able to spawn one include being in certain states (e.g. entering/exiting the battle, asleep, etc.), being on the extreme left/right sides of the stage, or being a type of audience member that doesn’t have any items in its drop table.  If such an audience member is successfully found, it will pick a random item from its drop table (based on their corresponding weights) and hold it above its head for a few seconds.  If the player does not attack them during that time, it will then throw it at one of the player characters at random.

Post-Enemy-Attack Events

All other audience events are handled by a single list, which will have possible events placed in it under various circumstances, as such:

DescriptionCircumstance
Hammer Bro throws hammerMissing a Hammer attack’s action command.
X-Nauts throw a flurry of rocksLanding an attack that does nothing or receives contact damage. 
Single X-Naut throws a rockThe battle drags on too long.*
Luigi throws a random itemRandom (end of turn)**
Boo turns an actor invisibleRandom (end of turn)**
Dayzee puts audience to sleep for 3 turnsRandom (end of turn)**
Bulky Bob-omb’s fuse ignites, and explodes 5 turns laterRandom (end of turn)**
Shy Guy causes a prop to drop or stage jets to fireRandom (end of turn)**
Piranha Plant eats an adjacent audience memberRandom (end of turn)**
Koopa Troopas retreat into shells for 5 turnsRandom (end of turn)**, only if the battle drags on too long.*

* The battle is considered to have “dragged on” if the turn count reaches 2x the sum of the starting enemies’ levels divided by Mario’s level, or 5 turns; whichever is higher.  The X-Naut rock throw event is placed in the list on the turn this count is reached.
** At the very end of every turn, there is a chance of all of these events being placed in the audience event list at once; this chance is equal to 3% x the number of turns since the events were last queued.  The Koopa event is included only if the “dragged on” turn count has been reached.

After the enemy alliance’s attack phase, any Bulky Bob-ombs’ lit fuse timers decrement if applicable.  If no Bulky Bob-ombs explode, and there are any events in the above list, the list is shuffled, then each event is checked until finding one with eligible audience members available to execute it.  After the event ends, or if none are eligible, the remaining queued events are cleared.  Finally, the turn counts for shelled Koopas and sleeping audience decrement (meaning those events actually last a turn shorter than advertised).

A few details about specific audience events:

  • Boos are not picky about which audience members they attempt to turn transparent; they choose between all actors (including normally-untargetable Bomb Squad bombs) with equal chance.
  • Shy Guys have an equal chance of triggering a falling object-type stage hazard or the stage jets / fog (unless Mario is a Rising Star, in which case it will always be a falling object).  The side of the stage it runs to doesn’t make any difference in how likely each actor is to be targeted.
  • Thrown harmful items have an attack power of their base ATK 1 + the number of items thrown, up to a maximum of 3 ATK; the can, rock, and bone each have a base ATK of 1, and the hammer has a power of 2.

Part 3: Ebb and Flow – Audience Gain/Loss

Finally, coming back around to the audience’s numeric representation, let’s take a look at how various events in battle cause the “target” and “bonus” audience values to change.

Fixed vs. Flexible Added Audience

Audience value changes can be influenced in two ways:

  • Fixed value changes, which are typically part of events that are out of the player’s control.
  • Flexible value changes, which generally are meant to reflect the player’s performance.

Fixed value changes always increase or decrease only the “bonus” value by the full change amount (clamping it such that the “target” + “bonus” values sum to a valid amount of audience for the stage, if necessary), and as such, don’t have a lingering effect on the audience size in future battles.  Flexible value changes are handled in a much more complex way:

  • First, if the “bonus” value is non-zero and has the opposite sign of the value to add, the added value is used to cancel it out.
  • If there is additional flexible value left to add/subtract, it is broken up into units of ±1.0 (plus one last unit composed of the remaining fractional part, if necessary).
  • For each of these units, perform the following steps:
    • Calculate the following quantity:

((“target” audience / “base” audience) 1.0) / 0.25

    • Round it down to the nearest integer; this is essentially a measure of how far ahead / behind the expected “base” audience value you are (going ±1 away from 0 for every 25% difference).
    • If this quantity and the value to add have the same sign, divide the unit by the absolute value of that quantity + 1.
    • Add the unit (or fraction thereof) to the “target” value, clamping it to the range of valid audience capacity, if necessary.

All this complexity serves a couple of purposes: first, it prioritizes cancelling out unusual circumstances over changing your “permanent” audience value, making (e.g.) the jump from a battle with a BINGO boost to one without it less jarring.  Secondly, it ensures that you don’t continue gaining audience at a constant rate even if you’re far above what the game considers a “reasonable” target for your level (and likewise, makes it harder to lose audience if you’re far below it).

As an example exercise, imagine Mario is level 15 (and as such has a “base” audience of 50), has a “target” of 74.0, and a “bonus” value of -2.5, and the player is slated to gain 7.5 flexible audience.  The following calculations occur:

  • The game first tries to cancel out as much as of the -2.5 bonus audience as it can; in this case, it can cancel it entirely, leaving 5.0 remaining flexible audience to gain, which it splits into 5 units of 1.0.
  • Calculating ((74.0 / 50.0) 1.0) / 0.25 = 1.92, rounded down to +1; as such, the first unit of +1.0 is divided by 1+1 = 2, granting you a “target” of 74.5 and 4.0 remaining flexible audience.
  • Similarly, ((74.5 / 50.0) 1.0) / 0.25 = 1.96, rounded down to +1, granting you 75.0 audience and 3.0 remaining.
  • Since ((75.0 / 50.0) 1.0) / 0.25 = 2.00, rounded down to +2, the next unit is divided by 2+1 = 3, granting you an additional 0.333… audience; this is true for the remaining 2.0 points as well, granting you a final total of 76.0 “target” audience (and 0.0 “bonus”).

Audience Gain / Loss Scenarios

Here’s a comprehensive list of all the actions that can result in gaining or losing audience value in the middle of a fight: (Amounts marked as “x base” are in terms of the base audience value for Mario’s current level.)

DescriptionAmountType
Getting a First Strike+0.02 x baseFlexible
Getting First-struck0.05 x baseFlexible
Landing / receiving an attack(See section below)Flexible
Receiving contact damage0.10 x baseFlexible
Appealing+0.05 x baseFlexible
Receiving a hit that puts Mario into Danger+0.05 x baseFlexible
Receiving a hit that puts Mario into Peril+0.15 x baseFlexible
Receiving a hit that KOs Mario’s partner0.25 x baseFlexible
Attacking an audience member holding a helpful item0.15 x baseFlexible
Having a damaging background layer fall+0.05 x baseFlexible
Having a falling object land on stage+0.05 x baseFlexible
Having a falling object land in the audienceProximity-basedFlexible
Running away from battle0.10 x baseFlexible
Failing to run away from battle0.20 x baseFlexible
At the end of each turn (if the battle drags on)-0.05 x baseFlexible
Winning a battle (if the front enemy yields Star Points)+0.15 x baseFlexible
Winning a battle exceptionally quicklyVaries*Flexible
Getting a Mushroom / Flower / Star BINGO+Half of max capacityFixed
Getting a Shine BINGOMax capacityFixed
Getting a Poison BINGOLose all audienceFixed
Losing audience to enemy attacks (Hooktail, Cortez, Shadow Queen)VariesFixed
Executing at least one Stylish command+10 PuniesFixed
Losing Punies to loud noisesAll PuniesFixed
Losing audience to a Bulky Bob-omb explosionProximity-basedFlexible
Losing audience to a Piranha PlantNo changeFlexible

* For “winning a battle quickly”, calculate the following value (rounded down), and if the current turn count is less than it, use a multiplier of the difference x 0.05:

(2 * sum enemy levels) / (3 * (Mario’s level + 1))

Attack-Based Audience Gain

Landing and receiving attacks has a varying effect on the audience, based not only on the performance of the individual attack, but also the player’s general performance in battle (each battle tracks counters of successive “crowd-pleasing” and “crowd-displeasing” actions).  The audience value multiplier induced by an attack is always “flexible”, and is calculated as such (starting from 0.00):

  • For player attacks:
    • If an Action Command was performed successfully:
      • Increment the “crowd-pleasing” streak (to a max of 2), and reset the “displeasing” streak
      • Add 0.01 * the “pleasing” streak * (0.5 + 0.25 * Action Command level) to the multiplier, where the “Action Command level” = 0 for 2xSimplifier-Nice, 1 = 1xSimplifier-Nice, 2 for Nice, 3 for Good, etc.
    • If an Action Command was performed unsuccessfully and did not defeat the target enemy:
      • Increment the “crowd-displeasing” streak (to a max of 5), and reset the “pleasing” streak
      • Subtract 0.05 from the multiplier.
    • If the attack did nothing (i.e. dealt no damage/status, or secondary effects like flipping a shelled enemy):
      • Subtract 0.05 from the multiplier.
    • If one or more Stylish commands were executed:
      • Add 0.02 * the Stylish SP multiplier for the attack (always 1) * the number of Stylish commands (to a max of 5) to the multiplier.
      • Separately, add 10 Punies to the audience (fixed) if Punies were included in the audience’s composition.
  • For enemy attacks:
    • If a guard was performed successfully:
      • Increment the “crowd-pleasing” streak (to a max of 2), and reset the “displeasing” streak
      • Add 0.01 * the “pleasing” streak to the multiplier.
    • If a guard was performed unsuccessfully:
      • Reset the “crowd-pleasing” streak.

Here’s an example scenario that walks through examples of gaining audience from attacks, using the Red Bones battle in Ch. 1, with Mario having only a Power Smash equipped and a base-rank Koops as his partner:

ActionSuccess StreakAudience Gain (×Base)
T1. Mario performs a successful Hammer attack, defeating the front Dull Bones.+1+0.01
T1. Koops performs a successful Shell Toss with 2 Stylish commands, defeating the second Dull Bones.+2 (Stylishes: 2)+0.06
T1. Mario guards the Red Bones’ attack successfully.+2+0.02
T1. Koops misses guarding the first Dull Bones’ attack.00
T1. Koops Superguards the back Dull Bones’ attack.+1+0.01
T2. Mario hammers Red Bones, failing the Action Command (and thus dealing no damage), but executing one Stylish.1 (Stylishes: 1)0.08
T2. Koops Defends.-10
T2. All guards are unsuccessful except the last.+1+0.01
T3. Mario uses Power Smash, executing the AC and hitting all 4 Stylishes.+2 (Stylishes: 4)+0.10
T3. Koops Defends.+20
T3. Mario successfully guards all three attacks.+2+0.02 x3
T4. Mario uses Power Smash without executing the AC, which defeats Red Bones.00
T4. Koops uses Power Shell, executing the AC and one Stylish command, defeating the remaining Dull Bones.+1 (Stylishes: 1)+0.03

Concluding Remarks

This article was a heck of a long time in the making, and I realize covers a lot of ground; if anything audience-related seems to be missing or insufficiently explained, please let me know and I’ll consider making changes to it or making follow-up posts in the future.  Huge thanks go out to Koop and Kappy of the “Glitz Pit” Paper Mario challenge running Discord server for helping proofread this and the previous article, as well as providing suggestions on how to better illustrate stuff.

I would have liked to include more info on stage hazards in this post as well, but it’s long enough already that I feel it would probably be better suited to a separate look later.  In the meantime, thanks for reading!

Whose “Turn”? The In-Depth Specs of TTYD Combat’s Turn-Based Structure

Well, after a long hiatus (a non-trivial portion spent on general reverse-engineering Paper Mario: TTYD, a few SMF videos on unused content / specific trivia, as well as my two gameplay mods, the Shufflizer and the Infinite Pit), I’ve finally got more in-depth TTYD battle mechanics to share.  Let’s start off with one of the most fundamental and under-explored bits of the combat system; what exactly goes into the “turns” of The Thousand-Year Door’s “turn-based” structure?

Overview

At the 10,000-foot level, a battle consists of this basic structure:

  • The “First Act”, i.e. anything that happens before the first turn.
  • Main combat – a series of “turns”, each consisting of various phases where the actors (generally Mario, his partner, and enemies) may take turns using moves (or “attacks”, used more or less interchangeably for the rest of this article).
  • Once a move, or some other battle event, results in one side meeting its win condition (either Mario falling without a Life Shroom, or all the actors on the enemy side being defeated), the battle goes through its end sequence.

That’s basically it; the first act and ending aren’t particularly interesting by comparison to the main “turn” sequence, so I’ll wait to touch on their specifics later.  For now, let’s dive a little deeper into what a turn consists of.

What is a “Turn”?

From a practical experience (casual or veteran), one generally might consider a turn in TTYD’s battle system to have a few distinct parts: the player’s characters move, the enemies move, and then some stuff happens between turns (and occasionally enemies might do something in reaction to a move).  In reality, it’s a fair bit more generically structured than that; every turn is broken down into a fixed number of phases, with a select few things occurring outside of them at the start / end of turns:

  • Turn structure:
    • Start-of-turn stuff
    • Phases (1-5)
    • End-of-turn stuff

Well, then what is a “Phase”?

Now we’re getting to the real meat of the structure.  Each of the five phases looks like this:

  • Phase structure:
    • Start-of-phase stuff
    • “Passive phase” – All actors execute “phase events”, which are generally used for scripted threshold-based form / behavior changes in boss battles, or passive things that happen at the start of a new turn (such as Mini-Yuxes spawning or Puffs changing position).  In the majority of cases, these don’t do anything outside of specific phases / circumstances.
    • “Active phase” – Actors execute “attack events” depending on their unit type, which allow them to perform moves (attacks).
    • End-of-phase stuff

All actors run their “phase events” in each of the five phases, and “attack events” in only one phase (Mario and his partner attack during Phase 2, and enemies attack during Phase 4).  The priority in which “phase events” and “attack events” are executed differs; both schemes will be discussed later on.

Putting together these roadmaps, we get this slightly more detailed overview of a fight’s structure:

  • First Act
  • Turn
    • Start-of-turn
    • Phase 1Start, passive phase, end
    • Phase 2Start, passive phase, player attack phase, end
    • Phase 3Start, passive phase, end
    • Phase 4Start, passive phase, enemy attack phase, end
    • Phase 5Start, passive phase, end
    • End-of-turn
  • Ending sequence (triggered by one team meeting its win condition)

Now with a full sketch of what turns and phases consist of, we can go over the entire fight structure in detail in chronological order.

End-to-End Guide

First Act (“Turn 0”)

  • All actors execute their “entry events”, if they have them (this includes the player characters walking in, and boss introduction cutscenes).
  • If a character performed a First Strike outside of battle, that attack plays out before anything else.
  • If Mario has Lucky Start equipped, a status will be picked at random between HP-Regen, FP-Regen, Dodgy and Electric and applied to him for 3 turns.
  • If there was no First Strike at the start of battle and Mario is a B-List star or higher, the stage jets will be initialized to one of the four types (fog, ice, explosion, or fire jets), and fired if anything other than fog is chosen.  If there was a First Strike, this will not occur until an attack or audience member attempts to trigger their effects; presumably this was done so the first attack doesn’t have a chance of turning the jet nozzles towards the stage, making what was meant to be a cosmetic “start of battle” effect into an immediate hazard.

That’s all the pre-battle-proper stuff, now into the turn sequence:

Start-of-turn

  • On the 2nd and subsequent turns, if Merlee’s curse is active, her turn timer counts down; if it reaches zero, one of the four curse types is chosen and stored, then applied at the first available opportunity (stored across turns or multiple battles, if necessary).
  • Actors have their move count reset, generally to 1.  If they have the Fast status active, it will be set to 2, and if they have the Slow status active, it will be set to 0 or 1, based on the number of turns they have been active since they received the status. (These move counts will be recalculated if an actor is switched in/out, or is inflicted by / loses either status mid-turn).
  • Actors have their move priority determined based on their unit type.  This will always be 0 in practice for all but a few actors (Grodus has a priority of “1” to ensure he attacks before his “X” satellites, and Shadow Queen’s hands have higher priority than her body in her demon form), but there is unused functionality for each type of actor to have different a base priority and variance (essentially acting as a “Speed” stat w/a range).
  • If fog is active, its turn count ticks down; it will be dispelled on the second turn after it spawned.
  • After this, statuses / status-like effects are processed in the following order:
    • Poison damage
    • Burn damage
    • HP + FP-Regen ticks
    • Happy Heart and Flower ticks (for turn 2+ only)
  • Followed by their turn counts being reduced in the following order*:
    • Sleep, Stop, Dizzy, Confuse, Electric, Dodgy, Burn, Freeze, Huge, Tiny, Poison, Attack-up, Attack-down, Defense-up, Defense-down, Allergic, HP-Regen, FP-Regen, Invisible, Fast, Slow, Payback, Hold Fast, Disabled Command(s)
  • After this, the five main turn phases occur.

    * Note: Since this happens even on Turn 1, you only get the Electric / Dodgy effects from Lucky Start for 2 turns compared to HP/FP-Regen’s 3.

Start-of-phase

The primary purpose of the start of the phase is to determine the order in which “phase events” and “attack events” will occur.  In both cases, this is determined mostly by X-position on the battlefield, but the phase and attack event (move) queues handle it differently.

For phase events, an actor’s priority is determined by the following formula (with smaller numbers going first):

Priority = abs(X position) + (1000 if X position ≥ 0, otherwise 0).

In essence, this means that actors will first be processed from the center of the stage leftward (to -1000.0 units, which is over two screens’ width offscreen), then the center of the stage rightward.

Since enemies never spawn on the left half of the screen (generally, the valid range of enemy positions is 10.0 to 170.0 on the X-axis), this generally means that Mario and his partner will be processed first (with the character closer to the center going first), then enemies, from left to right.  Since the player characters’ phase events never do anything, you can basically just treat phase events as always occurring left-to-right (barring a specific move that’ll be touched on later, at any rate).

For attack events, the priority calculation is simpler, using the move priority calculated at the start of the turn, then breaking ties by the absolute value of the actors’ X position.  In theory, this would mean that attackers’ turns could alternate between sides of the screen, but in practice since enemies are always on one side and player characters on the other, and they attack during different phases, this will never occur.

Once these queues are populated, if this is the 4th phase, Merlee’s Defense curse will activate if available, and will last through the “passive” and “active” phases.

Passive / Active Phases (Phase 1-5)

  • First, all actors execute their “unison phase event” simultaneously if they have one; these are rare and usually only have any effect in Phase 1, e.g. Puffs or Piders changing position.
  • All actors activate their normal “phase events”, in priority order.
  • All appropriate actors (players during phase 2, enemies during phase 4) activate their “attack events” to move in priority order.  Each actor gets the number of moves determined at the start of the turn (or if they were switched in/out or received/lost Fast/Slow status prior in the turn).  In addition, actors inflicted with Rally Wink status get to perform an additional move.  If Merlee has an ATK spell queued, it will activate the next time Mario uses a jump or hammer attack, and deactivate after all events resulting from that attack end (this includes Bulky Bob-omb explosions set off by Fire Drive!)  Notably, audience item throw events will only occur during the player’s attack phase.

End-of-phase

Pretty much the rest of the events from here on out have to do with the battle audience.  There’s way too much depth there to dive into everything here in detail, so that’ll have to wait for a future article (hopefully less than three years from now).

  • At the end of phase 2, any audience members holding an item will cancel their item throw event.
  • At the end of phase 4:
    • The audience picks a new limit for the number of random item throws for the following turn, from 0-3 (this is also done when initializing the audience at the start of a fight before the “first act” starts).
    • Bulky Bob-omb audience members’ fuse timers decrement, and they explode upon hitting 0.  If none are present or explode on a given turn and there are any possible audience phase events queued (again, more on this in a later deep dive!), one of them is chosen at random and the rest are discarded; if it’s an item-throw event it will happen on the following turn, otherwise it occurs right now.
    • Sleeping audience members and Koopa audience members in their shells have their “inactive” turn counts decrement.
    • If the crowd is in an excited state from a BINGO, the turn count for that effect decrements by 1.

End-of-turn

  • Audience members leave if the battle has lasted too long (5 turns minimum, potentially longer if fighting higher-leveled enemies).
  • A list of audience phase events has a chance to all be queued (to be randomly selected at the end of the next turn’s 4th phase).  This chance starts at 0% at the start of a fight, and increases by 3% every turn until it occurs (after which it gets reset to 0%).  This is what causes all non-item-throw audience events, such as Bulky Bob-ombs’ fuse getting lit, or Dayzees putting the audience to sleep.

End-of-battle

Practically any individual step in the battle that can result in an actor becoming defeated will perform a check to see if the battle should end.  The end-of-battle sequence is fairly nondescript, as pretty much nothing impacts gameplay, with a couple of exceptions:

  • Merlee’s EXP curse, if available, activates right before receiving the EXP gained from enemies.
  • Grubba / Jolene’s battle conditions are checked at the very end of battle, after the level-up sequence if applicable.  This doesn’t have any bearing on conditions that were used in the actual game, but there are some unused conditions (notably “Mario finishing under/over HP threshold”) that might result in unexpected outcomes; I actually ended up changing where the conditions are checked in Infinite Pit to sidestep this issue.

That covers the whole overview of the general battle structure, but now it’s time to get into some of the unexpected ramifications of how the systems combine together.

Edge Cases & Addenda

Damage Events + the “Reaction Queue”

When one actor’s “phase event” or “attack event” damages or inflicts a status on another actor, this will cause them to start their “damage event” concurrently.  This will interrupt any other events the damaged actor is currently running, and may result in that actor being defeated, otherwise it will generally return them to their idle state after a short animation.

Actors that cause exploding chain-reactions (Bulky Bob-ombs, Bob-ulks, and Bomb Squad bombs) use a separate mechanism called the “reaction queue”.  Each entry of this array holds an actor id + another integer value, the former determining which actor is reacting, and the latter determines what kind of reaction event to look up in the actor’s data table.  Whenever one of these bomb-type actors is hit by a damaging move that can cause them to explode, their actor id and respective data table value are added to the back of the queue (unless they’re already there, in which case nothing happens).

Once the main phase/attack event and its resulting damage events have ended, the game checks to see if the reaction queue has any entries.  If so, the game checks first to see if either team has met their win condition, ending the battle if so; otherwise, the first actor in the queue’s reaction event is run, then that entry is removed from the queue, shifting all the remaining entries up (if necessary).  This process repeats until all reactions are removed from the queue, and only then can the next phase/attack event occur (or whatever the next step of the battle flow should be).  Note that the game will check for win conditions before every reaction event is executed, meaning the battle might end before all the Bomb Squad bombs in a chain have exploded.

Spawning New Actors

Plenty of things can cause new actors to be introduced midway through a fight (form changes, enemies calling for backup or respawning limbs / helper actors), which might raise the question of when they first get to attack.  Ignoring player partner switching (which has its own set of mechanics that I haven’t really looked into), there are three supported options for handling the move queue when spawning new actors, which are to insert the enemy at the first available spot, the last available spot, or not at all (which is what’s always done in practice).

Recall, however, that the move queue order is only determined at the start of the phase where the actors in question get to attack.  As such, enemies spawned during phase 4 (e.g. Green Fuzzies splitting or Koopatrols calling for backup) won’t get to move, but actors spawned during another phase (e.g. Mario splitting Embers with Fire Drive in phase 2, or Crump summoning the third kind of X-Naut platoons in phase 1) will get to move when their attack phase comes.

One small quirk is that actors spawned in the middle of a turn won’t have their move priority set for that turn, instead defaulting to 0.  In most cases this doesn’t matter since most actor types have a move priority of 0 anyway and ties are broken by position, but in the specific case of the Shadow Queen’s hands this does make a difference.  Her hands have a base priority of 100 (Left + Right hands) or 90 (Dead Hands) compared to the body’s 80; normally they would have a higher priority than SQ herself and as such would move first, but if they respawn or are switched by SQ, they will attack after her instead!

Just… Bomb Squad.

Bobbery’s Bomb Squad move is, in short, one big manifestation of the quirks of all the aforementioned systems working in concert.  As an overview of how the move works, Bobbery spawns three bombs that explode 2 turns later.  Specifically, they’re created with a turn countdown of 2, and their phase event decrements that timer by 1 during the first passive phase, immediately calling their explosion event if it ticks to 0.

The combination of the unintuitive priority of phase events, the fact that Bomb Squad bombs can be placed basically anywhere on the player’s and enemies’ sides of the battlefield, and the fact that their explosions can cause chain reactions makes predicting the exact sequence of events incredibly hard to predict.

For instance, compare these two subtly differently positioned sets of bombs (all set to explode on the same turn):

In the first case, the middle bomb’s X position is -2.0, barely left of center, so its phase event has the highest priority and it will explode first.  In the second, the middle bomb’s X position is +2.0, barely right of center, so its phase event’s priority will have 1000 added to it, making it higher than the left one, and thus it will explode second.

Things get even more complicated when you consider chain reactions:

The middle one will explode first, since it’s left of and closest to the center, but which chain reaction occurs first?  Well, it turns out the left one explodes before the right, but that’s only because the Bomb Squad explosion attack determines its targets left-to-right, and that’s the order they go into the reaction queue.

How about this setup?

The bomb slightly left-of-center will go first again, and will hit the ones on either side of it, but none of the others.  Since the explosion’s targets are processed left-to-right, the one on its left will explode first, and that bomb will itself set a chain reaction off with the far left bomb.  However, since the bomb to the first one’s right was already queued, that one will explode before the far left one.  Clear as mud, I’m sure?  But it gets worse…

No, seriously, Bomb Squad is bizarre.

Since Bomb Squad’s detonation is based on a phase event, what happens when you combine it with other actors with meaningful phase events?  The sky’s the limit; for instance, Grodus and Yuxes respawning their satellites is also something that happens in their phase event during Phase 1.

In the case of Grodus, that means that placing your bombs carefully can result in you knocking out his Xes either before or after he respawns them, potentially leaving him with fewer than he started with by the time your attacking phase starts (or even none, if you place them all barely to his right!)  This sort of behavior is well-known and abused in some of the harder TTYD challenges, notably Impossible Mode.

Perhaps most famous, though, is how Bomb Squad interacts with the Shadow Queen, specifically when she taunts you three times while in her invincible form in order to progress to the mid-battle cutscene.  In a casual playthrough, this would normally happen on three separate turns, but in fact, she checks during every passive phase whether she was hit by anything intended to deal damage or status since the last time she taunted.  As such, you can end this part of the fight in a single turn if you have Bomb Squad bombs on her left and right sides set to explode the turn she assumes her invincible form:

  • Phase 1:
    • Left bomb(s) explode
    • Shadow Queen reacts once
    • Right bomb(s) explode
  • Phase 2:
    • Shadow Queen reacts again, since she was hit since her last phase event
    • Mario or his partner attacks during their active phase
  • Phase 3:
    • Shadow Queen reacts a third time, ending the fight before she gets an attack phase!

Funnily enough, this isn’t even the only way to cut this part of the fight short; if you’re lucky (or a TAS) and a Boo or Shy Guy from the audience attempts to hit the Shadow Queen as the post-phase 4 audience event, she’ll react to that as an attempted attack in Phase 5, cutting the fight short by a turn.

Concluding Remarks

Hopefully this gives you a bit of a taste of what TTYD’s general combat structure looks like under the hood!  I’m hoping to follow this up with more posts in the not-too-distant future doing deep dives on more specific parts of the battle system (including a long-overdue look at the stage hazard + audience systems, and one on all the different parameters that go into making attacks distinct).

Damage Calculus 101 – Attack, Defense, and Elemental Effects in TTYD

Following my article on evasion badges and misconceptions about how they stack, here’s an in-depth article explaining the Paper Mario: TTYD damage calculation process and all its subtleties.  Normally I’d cover PM64’s equivalent mechanics at least in passing, but Floogal’s GameFAQs guide on Paper Mario stats and attacks is comprehensive and accurate on that matter already, so I’ll not waste words treading already-paved ground.

That said, here’s a list of stuff that will be (mostly) out of the scope of this investigation, unless I flesh out the post after the fact:

  • Details about the base attack power for every move with variable damage (any player moves, stackable move badges, etc.)
  • Details about various defensive and elemental-effect states of every enemy (e.g. Buzzies having different defenses when flipped than when upright).
  • In general, interactions other than simple damage calculation; e.g. flipping shelled enemies, exploding bomb enemies, etc.

For the special point of FP-damage calculation, there’s not much to be said:

  • Poison BINGOs erase half the party’s FP rounded up; this cannot be changed in any way.
  • Flower Fuzzies deal a 0 HP-damage hit and 3 FP-damage hit simultaneously if the party has at least 1 FP, or a 3 HP-damage hit alone if they have none.  In either case, the FP lost is a constant 3 (or 2 if blocked), and the HP damage is dealt with like any normal HP-reducing attack.
  • Point Swaps do not follow damage calculation rules, simply swapping the stats in question (while abiding by the caps of the respective stats, if necessary).

All that out of the way, let’s get into some basic definitions going forward:

Technical Specifications & Mumbo-Jumbo

  • Attacker – The entity responsible for dealing the damage. For stage hazards, the “attacker” is the stage itself.
  • Attack – The move, action, stage effect, etc. responsible for dealing the damage.  Has its own base attack power (“ATK”), as well as a number of “properties” determining what parts of the damage calculation process apply.  Of note, each Attack has three properties determining how their ATK can be changed independent of the target’s defenses — “badge-mutability”, “status-mutability”, and “chargeability”.  Most attacks have all of these properties or none; of particular note, Yoshi’s Mini-Egg is not “chargeable”, but does have the other two properties.  Additionally, what are generally thought of as single moves may consist of multiple attacks with different properties; e.g. Tornado Jump / Gulp / Super Hammer’s initial hit (which is susceptible to changing ATK), and successive hit(s) (which are not).
  • Element – The class of attack being used, which determines which of the target’s set of defensive parameters (Defenses / Elemental Effects) to use.  The different elemental types are Neutral (“non-elemental” / “null-element”), Fire, Ice, Explosion, and Electric.
  • Defender / Target – The entity taking the damage.
  • Defense – The base defensive power (“DEF”) used to reduce damage dealt; the defender has a separate Defense value for each Element.
  • Elemental Effect – A special effect the defender has for each Element that applies at the end of the damage calculation process.  The elemental effects that can change the output damage are Elemental Weakness, Elemental Immunity, Elemental Healing, and “Iron Cleft Achilles’ Heel” (immunity to all attacks except Gulp); most of the time there is no such special effect for a given attack element and defender.

The properties of any Attack, as well as any entity’s Defense powers and Elemental Effects may change in any number of ways based on their state outside of the damage calculation process; some of the more salient ways will be brought up in the middle of the damage calculation discussion.

Now, let’s get into the meat of things!

Step 1: Sanity Checks & Elemental Transmutations

A few basic checks happen before any damage calculation occurs:

  • If the Attack has the “ignite” property and the Defender has the Burn status, the attack is treated as Fire-elemental for the rest of the process on that particular target, regardless of what its element would have been otherwise.  Unlike the rest of the damage calculation process, I confess I am not aware of any attacks (player or enemy) that work this way, so I’d be curious to know if any readers can help out!
  • If the Defender is immune to all attacks (e.g. Doopliss before discovering his name, or Shadow Queen after Phase 1), 0 damage is dealt and calculation stops.
  • If the Attacker has any All or Nothing badges equipped, the Attack is “badge-mutable”, and the Attacker missed the Action Command for the attack, 0 damage is dealt and calculation stops.

Step 2: ATK Calculation

That out of the way, the attack power is calculated first in the following procedure:

  • Start with the Attack’s base ATK.  This can be calculated in a number of ways; it can be constant (most enemy attacks and items), influenced by the player’s Action Commands, equipped badges, and/or partner/equipment ranks, etc.  Of note, Jumpman/Hammerman’s extra power on jump/hammer attacks and Hooktail’s attacks being weakened by Attack FX R are factored in at this stage, as is the calculation for Poison Shroom / Poison BINGO’s half-damage-rounded up.
  • If Merlee’s ATK curse activated on this entity’s turn and the Attack is “status-mutable”, increase power by 3.  Note that this does not depend on who the Attacker is, but only whether the Attack’s power can be influenced by statuses!  As such, if Mario sets off a Bulky Bob-omb or Bob-Ulk with a Merlee-boosted Fire-elemental attack, their explosions’ power increases by 3 as well!
  • If the Attack is “badge-mutable”:
    • Add 1 power per the Attacker’s equipped All or Nothing, Power Plus, and P-Up, D-Down badges.
    • If the Attacker’s HP is sufficiently low, add 2 power per Power Rush and 5 power per Mega Rush equipped.  The former requires 5 HP or less to activate on player characters and 1 HP on enemies, and the latter activates only at 1 HP.
    • If the Defender has the “weak to Ice Power” property (which is separate from elemental Defenses/Effects), add 1 per Ice Power equipped by the Attacker.
  • If the Attack is “chargeable”:
    • Factor in (and expend) the Attacker’s Charge status.
  • If the Attack is “status-mutable”:
    • Factor in the Attacker’s Huge and Attack+ status, if applicable.
  • If the Attack is “badge-mutable”:
    • Subtract 1 power per the Attacker’s equipped P-Down, D-UpHP Drain, and FP Drain badges.
  • If the Attack is “status-mutable”:
    • Factor in the Attacker’s Tiny and Attack- status, if applicable.

If the final attack power is negative, set it to 0.

Step 3: DEF Calculation

If the Defender has the “Elemental Healing” effect for the Attack’s element or the Attack is piercing, this whole step is skipped altogether.

  • Start with the Defender’s base elemental DEF for the Attack’s element.  This can change based on the enemy’s state; for instance, flipping shelled enemies generally drops all defenses to 0.  Of particular note, Grodus normally has 1 DEF to all elements, but gains an additional 1 DEF to null-elemental attacks per living Grodus X.
  • Add 1 defense power per the Defender’s equipped Defend Plus badges.
  • If a successful guard command was performed, add 1 defense power per equipped Damage Dodge.
  • If the “Defend” command was used this turn, add 1 defense.
  • Factor in the Defender’s Defend+ and Defend- (Soft) status.
  • Increase defense to 0 if currently negative.
  • If Merlee’s DEF curse activated this turn and the Defender is Mario, add 3 defense.
  • If Defender is weak to Attack FX R, decrease defense by 1 per hit previously taken with the sound effect.

The final defense power is again brought to 0 if currently negative, and subtracted from the previously-calculated attack power.

The resulting ATK – DEF value is not yet brought up to 0 if negative.

Step 4: “Non-Pierceable Defense”, etc.

Further alterations to the previously calculated ATK – DEF damage (or just ATK, for defense-piercing / healing attacks).

  • Add 1 damage per P-Up, D-Down worn by the Defender.
  • If the current damage is greater than 1:
    • If the attack has repeated-hit diminishing returns (e.g. Power Bounce), reduce damage by 1 per previous hit, to a minimum of 1.
    • If the attack has successive-hit diminishing returns (e.g. Fire Drive), reduce damage by 1 per previous target hit, to a minimum of 1.
  • If a successful guard command was performed, subtract 1.
  • If the Attack is Fire-elemental, reduce damage by 1 per Defender’s Ice Power badges equipped.
  • Subtract 1 per P-Down, D-Up worn by the Defender.
  • Multiply damage by the number of Double Pain badges worn by the Defender + 1.
  • If the Defender’s HP is sufficiently low (5 or below for player characters, 1 for enemies), divide the damage by the number of Last Stand badges equipped + 1, rounding up to the nearest integer.

At this point, if the absolute damage dealt is negative, it is brought to 0.

Step 5: Elemental Effects

The aforementioned elemental effect (if any) for the Attack’s element is applied here:

  • Elemental Weakness – Final damage is increased by 1.
  • Elemental Immunity – Damage is nullified.
  • Elemental Healing – Defender’s HP is increased rather than decreased.
  • Iron Cleft Weakness – Only Gulp deals damage; otherwise, damage is nullified.

This covers the entire damage calculation process from beginning to end; hopefully this addresses any misconceptions or ambiguities around the matter!

(Insert Clever Title) – Exploring & Tweaking PM:TTYD’s Systems Imbalance

As the Glitz Pit Discord debuts its “Glitz Pit Ranking Board”, a place for the masses to evaluate Paper Mario and its sequel’s badges, partners, and Star Powers, I want to expound on my opinions on the matter, continuing off my TTYD badge tier list from earlier this year.

Rather than continuing to list my opinions on various cross-sections of the game’s mechanics individually, I thought I’d come up with a somewhat off-the-cuff series of suggestions of how the various mechanical systems in The Thousand Year Door might be tweaked, retaining the current variety of options, but with a more thoughtful application of systems imbalance (see Extra Credits‘ excellent videos on perfect imbalance and marginal mechanics for why some degree of “imbalance” is not only inevitable but desirable), aiming particularly toward challenge runners.  I’ll approach this for the most part by taking a look at some of the least balanced aspects in the original TTYD mechanics, and making minor adjustments to bring options on all sides to (better) viability.  (As a side note, I might intersperse more in-depth analysis at a later date, but I think the reasoning stated now should be sufficient to get an idea of my thoughts on what in the vanilla game is and is not well-balanced.)

With that out of the way, let’s start off with the big one.

Imbalance Point 1: “Super-multihit” (3+ hit) attacks

Lots of math to follow in this section in particular.

Ask any seasoned Paper Mario veteran what the most broken (non-Special) move in TTYD is, and the vast majority’ll probably say Power Bounce / Multibonk.  Despite the damage dealt dropping by 1 on each subsequent hit, with sufficient base ATK, you’re raising your damage dealt by 1 per hit for each additional ATK point you add — far more than with any other attacks on a single enemy, Jumps and Hammers alike.  Yoshi’s Stampede takes this to an even more ridiculous extreme, raising your damage dealt by 1 per hit per enemy for each additional ATK point.

Let’s look at various formulas that could be used instead, seeing how they compare in damage, expressed in as a difference from a normal Jump-like attack (2*ATK + N) or as a multiple of ATK, for some specific numbers for ATK and hits:

Method 1a: Fixed Damage (e.g. 8, 8, 8, 8, 8…)

Jump + N@ 3 ATK@ 5 ATK@ 10 ATK
4 hits+6+10+20
6 hits+12+20+40
8 hits+18+30+60
N * ATK@ 3 ATK@ 5 ATK@ 10 ATK
4 hits4.004.004.00
6 hits6.006.006.00
8 hits8.008.008.00

Obviously this scheme scales way too much with high ATK, so it’s no surprise this wasn’t used for most multi-hit attacks (except Mini-Egg, which I’ll address separately later).

Method 1b: Linear Descending (e.g. 8, 7, 6, 5, 4…)

Jump + N@ 3 ATK@ 5 ATK@ 10 ATK
4 hits+1+4+14
6 hits+3+6+25
8 hits+5+8+32
N * ATK@ 3 ATK@ 5 ATK@ 10 ATK
4 hits2.332.803.40
6 hits3.003.204.50
8 hits3.673.605.20

Definitely an improvement for ATK up to 5 (which is fairly reasonable, as all supermulti-hit attacks have a base ATK no more than 3), but gets way out of hand if you go all-out on attack power.

Method 1c: Geometric Series (50% rounded up, e.g. 8, 4, 2, 1, 1…)

Jump + N@ 3 ATK@ 5 ATK@ 10 ATK
4 hits+1+0+0
6 hits+3+2+2
8 hits+5+4+4
N * ATK@ 3 ATK@ 5 ATK@ 10 ATK
4 hits2.332.002.00
6 hits3.002.402.20
8 hits3.672.802.40

The ol’ Pro Mode school of nerfing.  In theory, you could use geometric series to bind the total ATK multiplier to whatever you want, but any multiplier other than 50% would be pretty hard for the player to calculate in advance.  Problem is, a geometric series with a factor of 1/2 results in a sum of exactly 2x (barring rounding / the trailing 1-1-1’s), which makes Power Bounce a fairly pointless upgrade over a standard Jump, especially if your ATK has a lot of factors of 2.

Method 1d: Half, Quarter-Repeating Damage (e.g. 9, 5, 3, 3, 3…)

Jump + N@ 3 ATK@ 5 ATK@ 10 ATK
4 hits+1+2+1
6 hits+3+6+7
8 hits+5+10+13
N * ATK@ 3 ATK@ 5 ATK@ 10 ATK
4 hits2.332.402.10
6 hits3.003.202.70
8 hits3.674.003.30

Similar to the way SMRPG’s Super Jump works, I believe.  The second hit does half the initial hit’s damage, and subsequent hits do a quarter of the initial hit’s damage, both rounded up.  In theory, this should bound the damage dealt in eight hits to around 3x the base ATK, but having to choose a rounding direction (which I chose up, to not have to make an edge case for low ATK) means that some ATK values have slightly higher multipliers.  Pretty solid overall, but let’s look at one more alternative:

Method 1e: Linear Descending x2 (e.g. 8, 6, 4, 2, 1…)

Jump + N@ 3 ATK@ 5 ATK@ 10 ATK
4 hits+0+0+8
6 hits+2+2+11
8 hits+4+4+13
N * ATK@ 3 ATK@ 5 ATK@ 10 ATK
4 hits2.002.002.80
6 hits2.672.403.10
8 hits3.332.803.30

Surprisingly (to me, at least), this scheme actually ends up being pretty good, probably the best overall.  You have to get into double digit ATK before you start easily hitting substantially more than 3x your ATK, and it never goes below 2x your ATK for four or more hits (and is equal to 2x at 2-5 ATK).  Either this or the previous scheme would probably be my choice to better balance these sorts of attacks.

Imbalance Point 2: Jump vs. Hammer attacks

Definitely a subject on which many opinions are held, but I don’t think the situation is that unsalvageable.  In theory, Jump and Hammer are balanced such that a casual player uses Jumps for specific defense-less or aerial enemies, and Hammer for everything else due to its less strict timing and blunt damage.  However, when considering the full palette of options the player has, the ease at which extra ATK power can pave over the slight difference in base power, and the hazards that might be faced, it’s not really a surprise that Jumping is supreme for a variety of uses (particularly in single-target situations), and can be made viable in nearly any situation.

Rather than trying to address the situation by removing or otherwise neuter Jump’s multiple hits leading to multiply-increased damage w/increased ATK, I’d approach balancing them for expert use by letting raw single-target damage remain Jump’s niche by-and-large, while bolstering Hammer’s debilitating status effects, elemental power, and spread damage affinity.

The main problem to be addressed, at any rate, is not the attack power differential, but the supreme targeting advantage Jump has over Hammer.  As a tangent, let me first stress that Ice Power and Spike Shield are not the source of the problem.  Ice Power only affects one family of enemies offensively, Embers, that Hammer could only slowly tackle one at a time, while partner moves like Power Shell or Special Moves are far more effective at tearing through them.  Likewise, Spike Shield only affects a handful of enemies fought after its appearance post-Chapter 4; of those, Koopatrols, Moon Clefts, Frost Piranhas, Dark Bristles, and Spunias are still effectively dealt with by Quake Hammer or Fire Drive, and Spiky Parabuzzies would have taken forever to take down with Hammer Throw (compared to Lip Lock or specials), leaving only Poison Pokeys and possibly Piranha Plants specifically switching to be weaker to Jump than to Hammer.

Rather, the real problem with Hammer’s targeting is that you’re stuck with attacking enemies in order, rather than picking and choosing to dish out exact damage to them, or just taking out troublesome enemies in the back; furthermore, its would-be-decent status moves (particularly Head Rattle) are rendered useless by only targeting the front.

Therefore, I propose reworking the Hammer Throw into a new passive-effect badge, Hammer Bro, which makes all single-target Hammer attacks able to target any enemy.  Furthermore, the multi-target attacks would hit all enemies regardless of position (with Fire Drive having the appearance of Blazehammer from the recent Paper Mario games, and Quake Hammer the appearance of Earth Tremor).

With that major change, let’s look at balancing the individual Jump and Hammer moves to align with their new function:

  • Power Jump / Smash – Don’t really need to change.  Decent enough as starter / basic power-increasing badges.
  • Multibounce – Increasing the FP (and maybe BP) cost couldn’t hurt, otherwise it’s fine.
  • Power Bounce – Granted the nerf to PB mechanics above, pretty much fine; maybe increase the FP cost to 4.
  • Sleep, Shrink, Soft Stomp – Pretty much fine; Jump having one debilitating status isn’t unreasonable, and the others play well with its new niche.
  • Tornado Jump – Rather than doing fixed damage to all aerial enemies after hitting, change it to have a (perhaps slightly reduced) chance of inflicting Dizzy to all enemies with no damage after the initial hit.  Gives it a niche without stealing Hammer’s thunder. Speaking of…
  • Zaphammer (new) – Replacing the Hammer Throw slot, this would be a single-target hammer attack that inflicts Paralysis for 3 turns (see the section below on status effects) for 3 FP; stacking badges adds 2 to the turn count.
  • Vital Smash (new) – An upgrade to Piercing Blow, since Quake Hammer and Power Smash cover a lot of the same ground as the vanilla one. This move would be a single-target hammer attack that pierces defense, but can have its attack increased by up to 3, leeching the extra damage from Mario’s HP.  The FP cost could be 4 or 5, and additional badges would increase the extra damage (and HP lost) by 2.
  • Ice Smash, Head Rattle – Increase the former’s turn count to 3; otherwise, they’re fine, and made a good deal more useful with the potential ability to choose a target.
  • Quake Hammer – Fine as it is; if the damage were better or the FP cost lower it’d easily be too powerful when stacked (for reference, see any of PM64’s Quake badges), and as it stands it’s already a go-to option for a number of enemies.
  • Fire Drive – Fine as it is, but could be interesting if stacking it increased the base damage and the burn damage by 1, rather than just the base damage by 2.

One final thing; on the general note of FP cost for stacked move badges, I think the current method of linear FP increase for status moves, exponential for the rest is decently balanced; it’s unfortunate that it makes most unusable after using two (maybe three) badges, but the most obvious alternative of stacking linearly would lead to an FP vs. boss HP arms race for cheaply stackable badges like Power Jump.  (It’s possible that something like Super Paper Mario‘s score progression — 1x, 2x, 4x, 6x, 9x… might be slightly more balanced, but that would be more complex and ultimately not change much in practical use.)

What absolutely should be added in any case is a way to select moves at any power up to the maximum for the number of badges stacked; for example, if wearing three Power Smash badges, one should be able to choose between a +2 ATK / 2 FP, +4 ATK / 4 FP, or +6 ATK / 8 FP, like one already can for Double and Triple Dip.  Would make stacking two move badges a lot more palatable in the general case to a lot of players, I imagine.

These two changes address the majority of ‘unfair’ imbalances in TTYD’s systems, but why not go on and take a look at possible ways to tweak other aspects of the battle system.

Differentiating Status Effects

One of the lesser-appreciated improvements from Paper Mario to TTYD‘s battle system was how much more varied the status effects became.  The Sleep, Freeze, and Stop statuses, all functionally identical in PM64, are at least somewhat distinct in TTYD.  That being said, there’s definitely room for more distinctions; here are my ideas with how to tweak some statuses to improve their viability or make them a bit more unique.  First off, some common statuses that I wouldn’t change at all, for reference:

  • Dizzy – 50% miss rate on attacks.
  • Confuse – 50% chance of performing a random action (or doing nothing).
  • Sleep – Unable to move or defend, 50% chance of waking up when hit.
  • Stop – Unable to move or defend.

As for statuses I’d like to see fleshed out a bit more:

  • Allergic – Unable to gain new statuses; fine as is, but needs to be used more!
  • Fast – Take 2 moves every turn; ditto.
  • Freeze – Unable to move or defend; status ends if hit by fire attacks and does 1 damage upon ending.  This status could stand both to be less debilitating / get more use and to be more distinguished from Sleep and Stop, so I’d additionally like to see it halve damage dealt, similar to Super Smash Bros.
  • Burn / Poison – Currently identical, deals 1 damage at the end of each turn.  The functionality’s already there for Poison to deal more than one damage every turn, and it’d be cool to see both do that, particularly in later chapters.
  • Paralyze – Would like to see the Slow status reworked as this, making the user skip their offensive and defensive actions on odd turns (similar to “Even Turn” runs).  Could be interesting to try to strategize around Para-locking a single enemy, too.
  • Cursed – A variation on / replacement for Counter/Payback; rather than applying only to damaging contact moves, this would deal half the total damage dealt back to the attacker after the attack completes, whether or not it was a direct attack.

Finally, there’s an inherent imbalance between ATK-related and DEF-related statuses; for the former, Huge/Tiny, ATK-Up(/Down, which is unused), and Charge all modify ATK power separately, whereas DEF only has DEF-Up/Down.  This could easily be left as is, but some possible changes that might make the stats more in line would be:

  • Remove “Huge” status (at least on the player’s side, where the imbalance is biggest), replacing its effects with ATK-Up.
  • Remove DEF-Down status, and add a new pair of statuses that operate separately from DEF-Up (“Hard”/”Soft”).  To make things more interesting, these could modify the damage dealt directly, affecting piercing attacks as well (perhaps with an exception made for Special Attacks), and essentially allowing “negative” DEF.
  • Introduce “Hard”/”Soft”, and still make use of ATK-Down and DEF-Down.

Partner Changes

Having experimented around with a number of various partner strategies over the course of the Glitz Pit Community Challenges, I can really appreciate how well the main partners in TTYD were balanced.  By and large, the main problems lie in the brokenness of super-multihit moves, and the latter two partners having a fairly uninteresting move apiece in exchange for relying on overall higher stats.

Before we get to them, though, let’s address the elephant in the room: I really don’t think Ms. Mowz is all that bad, at least for the role she plays in game — an optional partner whose only real purpose is badge farming.  In my opinion, comparing her combat viability to the other partners is somewhat missing the point.  Nonetheless, she could stand the most work in terms of living up to her potential as a purely “marginal mechanic”-based character.

First of all, let’s go really out on a limb and give her the unique distinction of not having upgrades.  Instead, she has a fixed 20 HP, and four moves from the get-go; they’ll be mostly instruments to fit her ‘rogue’ archetype and personality, somewhat like Duster’s “thief tools” in MOTHER 3.

  • Love Slap (Base) – 5 damage piercing attack; not too horrible for a base move if you don’t feel like switching and/or all you need is a front-targeting attack.
  • Kiss Thief (2 FP) – Steals an item/badge an enemy is holding, or any badge from their random drop table (with increased chances compared to the vanilla game), not just their held item table.  Ideally you should be able to get any badge you want in well under an hour of farming.
  • Quick Exit (3 FP) – A move that guarantees a run away from a standard battle, provided you complete a reasonable Action Command.
  • Infatuate (4 FP) – Causes the Confuse status to all enemies; outright stealing this one from Vivian, since I’ve got another idea in its place, and it fits Mowz about as well.

With her out of the way, let’s go over the other partners, which have comparably few changes:

Goombella: Pretty much no changes, perhaps upping Multibonk and Rally Wink’s FP cost slightly.

Koops: Probably the most well-rounded and best-balanced partner in the vanilla game; great spread damage moves, and he can tank individual hits well but has low HP and a severe weakness if you get greedy. No changes really necessary.

Flurrie: Definitely underappreciated by me beforehand, but actually fairly well-balanced.  Only definite change would be making Gale Force’s action command slightly easier to fill, and making it enemies defeated with it yield 0 Star Points, akin to Fright Masks and all similar moves in PM64.

Yoshi: Even with the super-multihit attacks better balanced, Mini-Egg is still a fairly overpowered move, potentially dealing heavy damage and having a ludicrously high chance to inflict Shrink status on a single target.  It should either only hit each enemy once, or do no damage regardless of ATK and target at random.

Vivian: To fit her magic abilities, her Ultra-Rank move could be replaced with a move that inflicts the new “Cursed” status on Mario.

Bobbery: Fairly clearly the weakest of the six main partners in the vanilla game, except at a casual level.  To fit his background as a character, I think it’d be interesting to play up the “strategic” aspect of his moveset and his bulk; here’s a sample of how I could envision that working:

  • Bomb (Base) – Same as vanilla; 4/5/6 damage to front.
  • Bomb Squad (4 FP) – Increased FP cost, bombs still a fixed 3 damage, but the blast range increases with Super Rank, and a fourth bomb is added for Ultra Rank.
  • Bob-ombast (Super, 9 FP) – Does 7/8 damage to all enemies on the field.
  • Big Bang / Detonate (Ultra) – “Big Bang” (6 FP) spawns a bomb that does up to 10 damage (unaffected by ATK; can be controlled by an Action Command similar to Sushie’s Squirt) to all characters on the field when set off.  After use, “Detonate” (0 FP) becomes available in its place, and must be used to set off the bomb (damaging him, and Mario if he’s vulnerable, in the process).

Miscellaneous Addenda

A random assortment of balance-y things not mentioned elsewhere.  I’ll leave out badges like Pity Flower that have obvious but uninteresting means of improvement, but here are some of the more particular ideas:

  • Get rid of fog, or make ‘blocking’ it remove its imposed miss rate on the player’s attacks.  All other stage effects can be worked around much more easily, and add a bit of unpredictability.  That being said, badges that increase/decrease Star Power gained while making the stage effects more/less likely to activate might be interesting.
  • Rather than having an “Ice Power” badge to increase ATK and DEF against fire and protect against Burn, it would be cool to have an “Element Shield” badge (and partner variant) to reduce elemental damage taken by 1, and nullify element-based statuses (Burn, Freeze, and Paralysis).  Alternatively, an EarthBound-style “Ice Power” / “Fire Power” / “Earth Power” trio to counter ice, fire, and electricity respectively could be cool (and would make sense for enemies of their respective type to hold), but in practice Mario and his partners don’t use enough non-fire elemental attacks to make separate badges per element balanced in TTYD.  In a future game with similar mechanics, perhaps?
  • Similarly, wrapping up immunity to touching spikes, fire, elemental charge, and whatnot in a single “Hazmat Shield” badge (and partner variant) would be a more succinct way of enabling Jump or other contact attacks to freely target anything, akin to the new “Hammer Bro” badge for Hammer.
  • The Charge badge, despite not being all that broken considering other ways ATK can be raised (especially if one of the super-multihit changes were to be implemented), should really cost 2 FP, to minimize its “first-order optimality“.
  • Lastly, and perhaps most controversial, I hate how polarizing Quick Change is as an option in TTYD.  A cost of 7 BP is far too much to be generally useful in enemy battles; as tempting as that one quick switch would be, you’re missing out on any number of options with that BP cost if you use it — Heart + Flower Finder, Power Plus + FP Drain, nearly enough for two Flower Savers (P), the difference between Jumpman and Power Plus + Fire Drive to keep your options open, et cetera.  Conversely, it’s undeniably one of the most broken tactics in the game if your aim is to abuse Peril and/or ATK-buffed partners without having to have them face any oncoming enemy attacks.  To bridge the gap between these two polar opposite scenarios, I’d love to see the badge altered to be a comparably reasonable 3-4 BP, but have it cost a few FP to perform a quick switch.  This would make it far easier to slot into any badge setup, while simultaneously making it far more interesting to make sure every switch is optimal / necessary.

This sums up my thoughts on how I’d approach tweaking the TTYD combat systems’ balance to expand the range of a veteran player’s options; perhaps I might try to implement a subset of them into a balance mod of the game in the (let’s say very-distant) future.  In the meantime, hopefully this is a starting inspiration for others to think critically about the balance in the Paper Mario (and other) games, or maybe even to implement in the many PM fan engines in development.

Placing Pins and Tiering Trinkets: A TTYD Badge Tier List

Truly 2017 was a banner year for Paper Mario challenge runs, with the Glitz Pit Discord server surging in popularity and several players popping into the scene.  Discussion of strategies, loadouts, and mechanics of the Paper Mario series has abounded, but the badges, arguably the series’ combat’s defining trait, have always been a particular focal point.  Some badges are loved by all, some ridiculed by all but a few dedicated apologists, and many fall everywhere in-between.

Since stacking badges is what this blog was built on, I’d like to do something a little different here, and exposit my current thoughts on the matter at length, giving my personal ranking of every badge in Paper Mario: TTYD and some justification as to their placements.

To start, I won’t be considering these badges (the “FX-Esque Tier”) in my tier list:

  • The Attack FX badges and W Emblem / L Emblem are merely cosmetic and cost nothing to equip, so they’re obviously a matter of taste (even if W Emblem alone is the clearly supreme stylistic option).
  • Seeing as TTYD gives you many options to optimize strategies to minimize or maximize focus on HP, FP, SP, items, etc.;  HP and FP Plus are an invaluable convenience for adjusting your stats as you see fit, without needing to ever level up anything but Badge Points.  However, as they’re functionally equivalent to level-ups in HP or FP at any given time, they’re not really possible to rank alongside the majority of badges with unique effects.
  • Timing Tutor is useful for building mastery of Stylish Action Commands for a nominal BP cost, and on the other hand, freely skippable if you are well suited to perform them.  An excellently designed badge for beginners with no use (but no downside, other than slightly clogging Charlieton’s inventory) to experts.
  • Double Pain is good for adding extra challenge, and rarely (but occasionally) for manipulating Mario’s HP value.  No major positives, but it’s free BP-wise and is really only meant to be an extra challenge.
  • Finally, Slow Go is obviously meant as a joke, nothing more.  Only shame is that it’s not hidden somewhere needlessly cryptic like its predecessor in Paper Mario.

As for the rest of the badges, I initially grouped them roughly into four categories – well above average, above average, below average, and well below average usefulness.  I then tweaked their scores slightly, adding more granularity, and comparing badges with similar niches against each other.  Eventually, I ended up with a fairly balanced seven-tiered setup – Tiers F, E, D, C, B, A, and S.

Coincidentally, the higher and lower tiers ended up being clearly delineated by the middle tier (Tier C).  Most of the ones in that tier are decently generally usable badges with modestly useful effects, whereas ones above it (S/A/B) are much more frequently usable and/or heavily useful, and ones below it (D/E/F) are only usable in special cases (and often less useful even in those cases).

Of note, I generally didn’t consider stacking more badges than are naturally obtainable in the game (assuming only one of each available badge – and no Power Rushes – are bought from Pianta Parlor).

Without further ado, here are the tiers from bottom to top (badges in each tier ordered alphabetically):

F TIER

Generally badges I’d never dream of using seriously in a battle.

  • Bump Attack is really placed this low largely out of spite; it’s undeniably of some use by the time you get it, but that’s really a symptom of going through the Pit leaving you unfortunately overleveled.  Furthermore, it makes a very unsatisfying reward while in the Pit, especially considering the difficulty jump between the floors 61-79 and floors 81-99.  Arguably, First Attack is just as usable anyway for much less BP (and badge setup churn), and is available from the shop about as early as it’d be usable.
  • Chill Out is useful for dodging a very few enemies’ First Strikes (basically just Z-Yuxes and maybe Chain Chomps / Moon Clefts), and being in Dazzle’s shop with many useful badges as alternatives doesn’t do it any favors.
  • Head Rattle is a big missed opportunity. Confusion is a very fun status, but it only targeting the frontmost grounded enemy limits its use considerably.  Not only are you taking out most of that enemy’s potential weaponization in dealing damage to it, but you’re then unable to use a number of moves afterward (including all Hammer moves save for Hammer Throw) without doing further damage to it.
  • HP Drain and HP Drain P are massively nerfed from the former’s Paper Mario incarnation; dropping attack power by 1 in exchange for at most 1 HP restoration per turn is virtually never worth it when there’s so many other ways to mitigate damage.
  • Peekaboo is a waste of both BP and Star Pieces.  Experienced players should have enemy HP values memorized and keep track of them, whereas inexperienced players already have access to Goombella’s Tattle for the exact same information.  Knowing Koops’ Shell Shield and Doopliss’s partners’ HP is the only unique benefit it provides, and that is questionably useful at best.
  • Pity Flower is not the worst badge in concept, but unless you’re sponging a good deal of low-damage hits on Mario specifically, the 1 FP you’ll regain 30% of the time is not worth the HP you lose.  If the FP restoration was guaranteed, or the amount restored was tied to the damage taken, it could see a bit more use, but otherwise it’s filler for Pre-Hooktail Pit Bonetail setups at best.
  • Return Postage is of minimal use for much the same reason, on top of being a somewhat lackluster reward for defeating the Pit.  At least it’s highly salable (not that that is likely to be a concern after a Pit run anyway).
  • Simplifier‘s hit to Star Power regeneration far outweighs its use for easier Action Commands in general.  It is useful for scouting in the Pit of 100 Trials as it makes the run-away meter much easier to fill.  It’s also debatably useful for getting an extra bounce or two out of Power Bounce, but rarely does the difference between 8 and 9 hits equal night and day (and if you have good timing you’ll end up capping at the same point on bosses anyway).
  • Tornado Jump‘s tornadoes do fixed damage (depending on the number of badges equipped), and doesn’t do enough ancillary damage to aerial enemies (which are rare in the first place) to be worth it over a battle item, or Fiery Jinx, or Earth Tremor, or what-have-you.  It is useful for clearing out Mini-*-Yuxes or Grodus Xes, but that’s about it.

    E TIER

Badges I find occasionally worth considering (or consistently in specific cases, but with relatively small effect).

  • All of the P badges (Defend Plus P, Feeling Fine P, Happy Heart P, HP Plus P, P-Down D-Up P) are in this tier for pretty much the same reason; partners are generally tanky enough on the whole that it’s not worth the BP to make them safer. Not really a lot to say beyond that.
  • Hammer Throw is outclassed in nearly every situation it could be potentially useful.  Swoopers are just as easily hit with Earth Tremor or Quake Hammer, as well as some partner attacks.  Spiky Parabuzzies have far too much DEF for it to be viable.  For virtually everything else, a standard Jump or Hammer will suffice.  It can theoretically have a niche against airborne Ruff or Ice Puffs, but I’ve yet to be in a situation where there wasn’t some reasonably inexpensive alternative.
  • Lucky Start‘s effects are too short-lived, underwhelming and unpredictable to be worth the BP it costs.  It can be used to farm HP/FP by repeatedly running away if you really hate your “A” button (and Sweet Treat).  It’s particularly unusable if planning to use Danger strats, given the chance of getting the HP-Regen status.
  • Refund doesn’t yield all that much salvage since it rounds 75% of the item cost down rather than up (as in Paper Mario).  Nonetheless it can be a decent fill-out badge if you have a spare BP and a packed inventory.
  • Soft Stomp is reasonably useful (though not 100% reliable) on some very late-game bosses, but certainly not indispensable.

D TIER

Mostly badges that fairly typically get use, but aren’t all that useful, or are very useful in a very limited set of use cases.

  • Charge and Charge P pretty much never see use outside of boss battles, and quickly fall on the massive-overkill side if they are used flippantly, essentially adding 2 damage per hit per charge in the turn their charge is expended for negligible FP (and you’ll have plenty of multi-hit options from early in the game).  Arguably these could be placed in a higher tier on those grounds, but they’re really nearly wholly unnecessary considering the existence of power / Danger badges, Power Punch, and Power Lift.
  • Damage Dodge P is generally a bit more useful than the rest of the defensive partner badges, since it’s cheap to equip, available early, and combining it with the Defend command offers a lot of control over partner HP values.  It won’t do any good against some late-game bosses due to piercing attacks, though.
  • First Attack isn’t quite as convenient as Spin Attack from Paper Mario, but it isn’t as inconvenient to get or equip as Bump Attack, and its effect is appreciated when backtracking through previous chapters’ areas, especially in completionist playthroughs.
  • Hammerman‘s extra point of power comes at the expense of Mario’s generally more versatile and powerful Jump moveset.  Could be more useful depending on your preference of partner strategy and HP/FP consumption.
  • Ice Power is completely invaluable against Lava Bubbles, useful against Grodus and Bowser in Chapter 8, and completely pointless otherwise.
  • Ice Smash‘s status ailment can be devastating if it works, but the Frozen status doesn’t last too long without two copies, and there aren’t a lot of targets that it can hit and work reliably on that can’t be dealt with more easily in other ways. Clock Out is generally a far better choice for reliability, or Sleepy Stomp / Sheep for turn count.
  • Money Money is too expensive and appears too late in the game to be as useful as it should be, but it can be useful for farming extra Pianta badges or recipe ingredients for a completionist playthrough nonetheless.
  • Pretty Lucky P can be useful for mitigating partner health loss in the long term, or bolstering their evasion rate in Danger, but isn’t generally as useful as Heart Finder for the former purpose.  Can be helpful or actively harmful if it activates against moves that hit the front and back player-controlled actors in sequence if they’re in front, as Mario will be forced to perform the last defensive action taken (including a miss) even if it would be undesirable.
  • Shrink Stomp can be fairly useful on the handful of bosses it works on, and perhaps particularly tough enemies, depending on the player’s preference. However, Mini-Egg has the same chance of working and gives you multiple attempts, so it’s almost always a better option.
  • Super Appeal P can help make the most of an unspent or otherwise-unspendable partner turn, but only one copy appears naturally, and by the time you have it, the extra 0.25 SP units restored aren’t of much consequence.
  • Unsimplifier is sometimes effective in boosting SP restoration, but makes a handful of moves, as well as Superguarding, a much less viable option due to the increased difficulty of their Action Commands.

C TIER

Also the middle tier, and now we’re definitely in the realm of generally useful badges.

  • Defend Plus is a solid, obvious, but slightly BP-expensive way to mitigate damage. Particularly useful against fast multi-hit attacks like Magnus 2.0’s audience launcher and the like, and particularly useless against some very late-game bosses with mostly piercing attacks.
  • Double Dip and Double Dip P are incredibly versatile tools, particularly for efficiently strategizing boss battles. Their FP cost (especially with Triple Dip) is fairly high, but that can be mostly mitigated by using at least one FP restoration item.  Late-game this can remove the need for Charge badges entirely, and earlier in the game it allows setup with Power Punch, Point Swap, Trial Stew, etc. in combination with recipe items to hit pretty much any stat breakdown you want.  Their biggest drawback is being located fairly late in the Pit and in the main story.
  • Happy Heart is a decent filler badge for picking up occasional extra health in long battles (for instance, in Pre-Hooktail Pit), particularly if you prioritize heavier-hitting in-battle badges to the Finder badges.  Their effect is negligible in comparison to a Slow Shroom if you can afford the inventory space (and detour to the Deepdown Depot), though.
  • P-Down D-Up is the only defensive badge (alongside its partner variant) to work against piercing attacks – including all stage effects and enemy items – which can be a game-changer against a number of enemies if you can afford the loss of attack power (or the badges to offset it).
  • Piercing Blow is invaluable for Pre-Hooktail Pit runs against anything highly defensive and immune to fire (particularly Chain Chomps and Moon Clefts), or as a low-FP alternative even if Fire Drive does work.  It is generally overshadowed by Earth Tremor, Quake Hammer, or various item / partner attacks, and is equivalent to or worse than Power Smash for enemies with 2 or less defense.
  • Power Jump and Power Smash are the go-to very-early game options for dealing a lot of damage in a single blow, and remain effective for that purpose during the entire game if you have the FP to spare for a double- or triple-stacked version of the move.  They fall behind the upgraded boots’ Jump moves quickly on low-DEF enemies, though.
  • Spike Shield makes Spiky Parabuzzies tremendously easier to deal with, as well as allowing you to use Jump’s often superior firepower (and Jumpman) against lower-defense spiky foes.  It also makes Bristles approachable, though Quake Hammer is plenty effective at neutering them on its own.  Plus, there are spiky enemies it’s not terribly effective at dealing with (notably Clefts).
  • Super Appeal is nice for quickly regenerating Star Power, particularly early in the game or when stacked.  It’s particularly nice for dealing with Dull Bones audience against Bonetail, as it guarantees a 1.00 SP fill-up in no more than two Mario Appeals (and often one Mario and one partner Appeal).
  • Zap Tap completely blocks leeching attacks, and is a good failsafe in Pre-Hooktail Pit, particularly for direct attackers that would be otherwise impossible to kill if you’re inconsistent at Superguarding them.  It also has an edge-case use in allowing you to use contact attacks on enemies with the Electric status (not charged Puffs, though).

B TIER

Getting into the upper tiers. These badges are generally fairly potent and usable a sizable amount of the time.

  • Close Call P is a great, very inexpensive safety net for Danger/Peril partner strats, activating nearly a third of the time (or over half the time with both copies).  It’s not the best way of ensuring their safety, though.
  • Damage Dodge is another inexpensive defensive boost if you’re not opting to Superguard everything to oblivion, and a fantastic tool for targeting specific HP amounts with Mario.  Naturally, still it’s of no use against piercing attacks.
  • Feeling Fine is far more useful on Mario than his partner, removing the need to worry about nearly all potent status effects (Freeze being the notable exception), and freeing you to go for Superguards on nearly anything.  It’s only available very late in the game, but it’d be most particularly useful on late-game bosses anyway.
  • Flower Finder‘s 1-3 guaranteed FP drops per battle are fantastic at maintaining high FP across multiple field battles.
  • Heart Finder is useful for the same reason, and is unique (as opposed to Happy Heart / Lucky Start) in being able to restore HP to Mario and his partner at once.  Being able to choose when and whether to pick up each individual drop also means being able to target specific HP values for Mario or specific partners, so you can keep partners in Danger or Peril as desired. Furthermore, it can uniquely (aside from items) bring 0-HP partners back to life in a Peril (or Danger) state.
  • Item Hog is useful for the fairly substantial increased chance of held and random items dropping, but perhaps better for the ~5% chance of a Dried Shroom dropping from a battle with no enemy held items, allowing for resuscitating a 0-HP partner to Peril.
  • Last Stand P is useful for targeting partner Peril, and more generally for allowing partners an additional attack or two after reaching Danger status.  Unlike Paper Mario‘s Last Stand, it (and the Mario variant) takes effect last in damage calculation and rounds up, so it won’t outright prevent damage unless none would have been taken before it factors in.
  • Mega Rush is obviously incredibly potent in dealing damage, but it’s relatively risky to attempt maintaining it through enemy attacking turns.  It’s at its best if you can manipulate Mario’s HP and use it to finish out a boss battle.
  • Lucky Day isn’t quite as cost-efficient as Pretty Lucky (and nowhere near as much as Close Call if in Danger), but without farming extra evasion badges it’s still a decent evasion boost.  Where it obviously shines is in Pre-Hooktail Pit runs, substantially lowering the average damage taken on floors 91-99 and against Bonetail.
  • Multibounce is useful for grounding multiple winged enemies in a single turn, or dealing modest damage to all enemies in a set for minimal cost (or more than modest, with sufficiently increased attack power).  Also likely the go-to cheese badge for unambitious Danger Mario “strategists”.
  • Quake Hammer, despite a none-too-flattering fixed damage and FP cost compared to Paper Mario‘s array of similar badges, is nonetheless especially effective against a set of high-DEF enemies, particularly if they’re flippable and/or immune to fire (Beetles, Bristles, Clefts, Chomps, Koopatrols).  It can still be decently potent in general with sufficiently increased attack power, but there are likely better options.
  • Sleepy Stomp is unparalleled for taking a single enemy out of commission for an extended period of time.   It’s available very early in the game, and particularly indispensable for Pre-Hooktail Pit runs.  Typically loses out to Clock Out for general utility later in the game.

A TIER

These are generally incredibly potent at their best or very solid general choices.

  • FP Drain is an incredibly underrated badge.  For a single BP and at the cost of a single point of attack power, it effectively acts as a Flower Saver that works on any of Mario’s attacks that deal damage, even 0- or 1-FP moves, so long as you can foot that extra point in advance.  The lost attack power is very easily recuperated in late-game, given the many cheap attack power-raising options that exist.
  • Happy Flower is similar in appeal to Happy Heart, without the potential to screw up HP targeting if you’re planning to employ Danger / Peril strats.  Again, Gradual Syrup blows its inflow out of the water if you can afford to carry one (or two, if you have both Mario and his partner both use one).
  • Last Stand is great as a last gasp to survive an additional attack or two, similarly to Last Stand P, though again not nearly as potent as Paper Mario‘s equivalent.
  • P-Up D-Down is the cheapest way to get extra attack power without cutting off strategic attacking options (Jump / Hammer moves or intentional missed Action Commands), at the expense of taking an additional point of damage from everything, including piercing attacks.  Naturally, that downside can be mitigated with extra defensive setup, evasion, exploiting enemy AI, or Superguarding, or even be exploited to reach Danger/Peril earlier.
  • Power Plus and Power Plus P are the most BP-hungry and blunt way to raise your attacking power, but are nonetheless effective and generally not too expensive to be worth considering.
  • Power Rush P is doubtlessly useful, but is really the “poor man’s” Mega Rush P, as keeping partners in Danger is barely easier than keeping them in Peril for substantially lower gain.  The extra damage on top of Mega Rush P can be useful in theory, but is often unnecessary, especially with the existence of non-badge sources of increased attack power.
  • Pretty Lucky is a fairly useful badge for filler (particularly with two equipped), or in conjunction with stronger evasion badges.  It often isn’t advantageous in cases where you need to deal damage to direct attackers with counterattacks or Zap Tap, as Sweet Treat should often be sufficient on its own to mitigate the lost health from failed Superguards if your partner Appeals.
  • Quick Change‘s primary function is to preserve a partner’s status (be that Peril health, or Charge / other positive status effects) indefinitely by switching to another partner before the enemies’ attacking turns.  Aside from that, there aren’t many compelling use cases for it, and it has a steep BP and Star Piece cost to boot.  It’s not all that necessary for partner Peril strats in Pre-Hooktail runs either, unless you have extra restrictions (such as a speedrun or low-Mario health run).

And finally,

S TIER

The best of the best; unmatched in utility and/or viability.

  • All or Nothing is a cheaper Power Plus with virtually no downside; you lose only the ability to strategically omit Action Commands (or the damage from the last, unsuccessful jump in a Power Bounce).  Obviously it is not a good choice if you’re not solid on Mario’s Action Commands in general, but most of them are fairly straightforward and easy to land, even with Unsimplifiers equipped.  Its only flaw is its only being obtainable terribly late in the game.
  • Close Call is a cheap and effective safety net when Mario is in Danger, particularly when stacked in duplicate (~55.1% misses), or in duplicate with the other evasion badges (upward of 70% misses).  Adding Last Stand(s) to the mix can allow near impenetrablility of Mario’s defenses in Danger, for a measly handful of BP.  Both natural copies are available very early in the game, and they can be farmed (albeit not terribly effectively) basically at the start of the game as well, if you want to truly overkill your evasion.
  • Fire Drive is nearly always a viable attacking option for non-aerial enemies, and is absolutely indispensable (daresay, the linchpin) in Pre-Hooktail Pit runs.  In addition to doing massive damage early-game, it can inflict the burn status on pretty much anything that isn’t immune to fire attacks, dealing ancillary damage and completely confounding lingering Dark / Elite Wizzerds.  Stacking both copies is virtually never a good idea, by comparison; the boost in attack power is negligible for the whopping 10 FP and 3 extra BP cost.
  • Flower Saver is the single most generally useful badge in the game, for my money; it is available incredibly early in the game via Dazzle, and there is virtually no time (especially after obtaining Spin Jump) that bringing Mario’s 2-FP moves to 1-FP is not useful.  The second badge can be useful as well, bringing Quake Hammer and Power Bounce to 1 FP and Fire Drive to a modest 3.  Combined with FP Drain and/or Gradual Syrup(s), nearly all of Mario’s moveset, natural and badge alike, can become virtually free.
  • Flower Saver P isn’t quite as mind-blowingly useful as the Mario variant, but it brings down the cost of several key moves (notably Power Shell, and all of Goombella’s and Yoshi’s moves) substantially, especially if worn in duplicate.
  • Jumpman‘s extra point of power comes at the cost of his defense-piercing, harder-hitting, and multi-target hammer moveset, but given most Jump moves have at least 2 hits, it raises damage dealt by at least 2 points for a negligible BP cost.  Star Powers and partner attacks can fill the void of multi-target and piercing attacks, and additional power-increasing badges (or Power Jump) fill the more-damaging niche of the Hammer reasonably well.
  • Mega Rush P makes Pre-Hooktail Pit runs considerably less daunting (though it is by no means essential).  Using it with Heart Finder works wonders at maintaining partner Peril across multiple field battles, whereas Quick Change often makes it near-impossible to lose the status within a single battle.  In conjunction with Goombella’s Multibonk or most of Yoshi’s attacking moves, it is arguably the most broken badge in the game.
  • P-Up D-Down P, in particular if stacked via Elite X-Naut farming, is essentially equivalent to having permanent Danger / Peril partner strats.  Even a single copy paired with Power Plus(es) P turns partners into destructive powerhouses, at a relatively nominal cost to defense for an Ultra-Ranked partner.
  • Power Bounce can, as expected, take advantage of Mario’s slightly wider array of attack-power raising options than partners to blast through pretty much any foe.  It’s also (arguably more sportingly) useful for tackling annoying enemies in Pre-Hooktail Runs as soon as possible, often in conjunction (for high-HP enemies) or parallel (for multiple moderate-HP enemies) with Goombella’s Multibonk.
  • Power Rush is a cheap and a safe option (compared to Mega Rush) to maintain raised damage output in repetitive field battles, as well as an easier and safer damage boost than Mega Rush to target from initially max HP in a boss battle.  Obviously stacking multiple copies from the Pianta Parlor, and/or using it in conjunction with perma-5 HP Mario, makes it the most boringly broken badge in the game, but it doesn’t deserve all the stigma it gets for that if it’s used creatively.

With that, this is my complete Paper Mario: TTYD badge tier list as it currently stands, in a single image for brevity:

Feel free to discuss your opinions on the matter (and no doubt lambast my disservice to Quick Change such-and-such badge) in the Glitz Pit Discord server or my own personal Discord server, Club Jdaster64; I’m generally around both frequently, and there’s plenty of Paper Mario series discussion to go around.  If you’re interested in this sort of qualitative discussion of Paper Mario mechanics in addition to my usual technical fare, Kappy (organizer of the Glitz Pit and Paper Mario wizard) has a blog for this sort of stuff that you can check out here.

Of course, if you’d like my take specifically on more stuff like this, feel free to shout out suggestions for similar topics in the comments here, or on my Discord server.  Might be worth pooling together some of the top challenge runners’ minds to form a “Paper Mario Back Room” badge tier list in the future, or something; who knows.