Series
Super Smash Bros.
5 games, 1999–2018.
Games
Interactive: timeline (needs JavaScript)
The series by yearMechanics
A marked cell changed from the game before. “Uses” means the game has the mechanic, with no variant recorded yet.
Every claim, by mechanic and game
| Concept | Super Smash Bros.
1999 | Super Smash Bros. Melee
2001 |
|---|
| Blast zone | - In the US version of Super Smash Bros.,
ftCommonDeadCheckInterruptCommon, called from ftMainProcPhysicsMap, checks the fighter's position against the stage's bounds in the order map_bound_bottom, map_bound_right, map_bound_left, map_bound_top, and crossing one starts a Dead status. Below the bottom or past a side, the status calls ftCommonDeadUpdateScore as it starts; above the top, it's DeadUpFall if a random number is below 1/6 and DeadUpStar otherwise, and both call it from their update routines. That routine adds a KO to the score of the player recorded in damage_player, or counts a self-destruct when there is none, and under the stock rule takes one stock. The check skips the boss and fighters flagged is_ignore_dead. A fighter flagged is_limit_map_bounds, ghost or not, is moved 500 units back inside the bound it crossed and its air velocity set to 0. Otherwise ghosts are skipped, and enemy teams in the 1P Game have their own team bounds. Code
| |
| Blocking | | - In the NTSC 1.02 version of Super Smash Bros. Melee, a fighter's
shield_health is a float that starts at x260_startShieldHealth. Each time Fighter_procCollResolve runs for a fighter that isn't asleep (is_sleeping), a fighter whose unnamed flag x221A_b7 is clear regains c_27C, up to the start value. That flag is set when the guard statuses switch on the shield's collision (ftColl_8007B1B8), and the atlas reads it as "shield up". While it's set, the fighter instead loses c_284 × s × (1 − (l·(c_2E0 − c_2DC) + c_2DC)) + c_288, where s is x19A0_shieldDamageTaken, each shield hit's damage plus its unnamed x34 (a fighter's hit counts only while the flag x221C_b2, set on entering ftCo_MS_GuardReflect, is clear), and l is lightshield_amount. Below 0, the health is set to x280_unkShieldHealth, and on the hit path the shield break (ftCo_80098B20, which enters ftCo_MS_ShieldBreakFly) starts only in the branch taken when the fighter has no knockback to apply (kb_applied is 0), the unnamed x18a0 is 0, and a shield hit is recorded (x19A4). While the fighter holds the shield, the animation routines of ftCo_MS_GuardOn and ftCo_MS_Guard call ftCo_800925A4, which, while x221B_b0 is set, sets l from the analog trigger past its deadzone, (trigger − deadzone) / (1 − deadzone), keeping the old value when that's negative, and takes c_278 × (l·(c_2F0 − c_2EC) + c_2EC) off the health; below 0 it sets the health to 0 and starts the shield break. Every c is a field of p_ftCommonData, from the disc file PlCo.dat, so the numbers aren't in the code. Where Super Smash Bros. counts whole points from a fixed 55 and resets to 30, with no say for how hard the button is pressed (ssb64/shield), Melee's wear while held and its damage from hits both depend on l. Code
|
| Damage percent | | |
| Hitstun | - In the US version of Super Smash Bros.,
ftCommonDamageInitDamageVars sets a hit fighter's hitstun_tics, a whole-number count, to its knockback divided by 1.875 (ftParamGetHitStun), and to 1 if that comes to 0. The damage statuses' common update routines take 1 off the count each time they run. Until it reaches 0, their common interrupt routines don't run the standing, falling, or hammer interrupt checks (ftCommonWaitProcInterrupt, ftCommonFallProcInterrupt, and the hammer's), so the fighter can't act, and an airborne fighter gets friction in place of the usual drift and fast-fall. At 0, the status ends once its animation has run out. A knockback of 100 gives 53 counts (computed). Code
| - In the NTSC 1.02 version of Super Smash Bros. Melee,
ftCo_8008DCE0, the routine that puts a hit fighter into a Damage status, sets the unnamed count mv.co.damage.x0 to the knockback (kb_applied) times p_ftCommonData->x154, a value from the disc file PlCo.dat, truncated to a whole number, and to 1 if that comes to 0. It also sets the flag x221C_b6, which ftLib_IsInHitstun returns. Where Super Smash Bros. divides the knockback by 1.875 (ssb64/hitstun), Melee multiplies it by a value the code doesn't hold. The animation routines of the Damage statuses (75 to 86) and the DamageFly statuses (87 to 90) take 1 off the count while it's above 0 (ftCo_8008F744) and clear the flag once it's 0 or below; the status ends when its animation has run out with the flag clear. While the flag is set, their interrupt routines run only doIasa, as the decompilers name it, in place of the wait, fall, or hammer checks, so the fighter can't act, with one exception: after a hit whose angle ftColl_8007AC68 accepts (between unk_kb_angle_min and unk_kb_angle_max), once an unnamed countdown from c_7F0 runs out, an airborne fighter moving down can leave through an air up special (ftCo_800D69C4) or an air jump (ftCo_800CB8E0), which the atlas reads as the meteor cancel. A jump pressed in hitstun otherwise only records the count left. While the flag is set an airborne fighter gets gravity and aerial_friction (ft_80084EEC) in place of fast-fall and drift (ft_80084DB0). A change of motion state clears the flag unless the new state is entered with Ft_MF_SkipHitStun. The DamageFlyRoll status's own routines aren't read here. Code
|
| Knockback | - In the US version of Super Smash Bros.,
ftParamGetCommonKnockback computes a hit's knockback as times an attacker and a defender factor from a handicap table. Here d is the target's damage percent plus damage_queue, the damage queued against it, which ftMainProcParams adds to the percent and then clears; h is the hit's damage; w is the target's weight attribute, which the decompilers comment "Or, rather, \"knockback multiplier\""; g and b are the hit's knockback_scale and knockback_base; and r is the battle's damage_ratio. A hit with a nonzero knockback_weight k puts 1 + 0.5k in place of the d term, the value that term takes at d = 10 and h = k (computed), so that launch doesn't grow with the percent. The result is capped at 2500. Of the hits a fighter takes together, ftMainProcessHitCollisionStatsMain keeps the largest knockback, and ftMainProcParams multiplies it by 2/3 while the fighter is crouching (nFTCommonStatusSquat or nFTCommonStatusSquatWait) and subtracts the larger of two knockback-resistance values, down to 0. Code - In the US version of Super Smash Bros., when a saved error flag the decompilers name
LBBACKUP_ERROR_RANDOMKNOCKBACK is set, ftParamGetCommonKnockback replaces every knockback it computes with a random value below 200. The VS mode menu sets that flag when the save's boot count is above 21 and gSYMainImemOK is false, which syMainSetImemStatus sets when the word it reads at the start of the RSP's instruction memory (SP_IMEM_START) isn't 6103. Code
| - In the NTSC 1.02 version of Super Smash Bros. Melee,
ftColl_80079AB0 computes a hit's knockback as capped at c_108. Every c is an unnamed field of p_ftCommonData, which Fighter_LoadCommonData loads from the disc file PlCo.dat, so the constants aren't in the code. Here d is the target's x1830_percent plus x1838_percentTemp, or, while the unnamed flag x2225_b7 is set, c_6D4 (c_6D8 if stamina_dead) plus x1838_percentTemp; n is the hit capsule's unk_count; w is the target's weight attribute times c_F4; g and b are the capsule's unnamed x24 and x2C; r is gm_8016B248(), the match rules' x30, which the VS setup in gm_1601.c sets to 0.1 × the rules' damage_ratio; and A and D are Player_GetAttackRatio for the attacker and Player_GetDefenseRatio for the target. A capsule whose unnamed x28 (k) isn't 0 uses c_118·c_110 + c_114·c_118·k in place of the percent term. The terms sit where Super Smash Bros.'s 0.1, 0.05, 1.4, 18, and its set-knockback 10 and cap 2500 do (ssb64/knockback), and the atlas reads g as the growth and b as the base by that position. Where Super Smash Bros. multiplies by its weight attribute, Melee's weight term equals c_F8 / (1 + w) (computed), so the weight divides. Of the hits a fighter logs in one update, ftColl_8007A06C keeps the largest knockback and writes it to kb_applied; ftCo_Damage_CalcKnockback then multiplies it by kb_squat_mul in ftCo_MS_Squat or ftCo_MS_SquatWait, by kb_ice_mul in ftCo_MS_DamageIce, and by kb_smashcharge_mul while a smash attack charges, rescales it with ftCo_CalcYScaledKnockback when the fighter's vertical scale isn't 1, subtracts the larger of armor0 and armor1 (plus metal_armor for a metal fighter), and raises it to kb_min if it falls below. Code
|
| Landing lag | | - In the NTSC 1.02 version of Super Smash Bros. Melee, an aerial attack (statuses
ftCo_MS_AttackAirN to ftCo_MS_AttackAirLw) that touches down calls ftCo_LandingAir_EnterWithLag from its collision routine ftCo_AttackAir_Coll, through ft_80082C74, which calls it when the unnamed ft_80081D0C returns true. If the move's command script has set cmd_vars[0], which entering the aerial clears, the fighter enters that aerial's LandingAir status with the fighter's landing-lag attribute for it (landingairn_lag and the four like it), and the animation plays at a rate of (ftAnim_8006F484 + 0.1) / lag, where ftAnim_8006F484 returns the animation's end frame. If the unnamed count x67F is below c_E4 at that moment, the lag is first divided by c_E8, truncated to a whole number, and raised to 1 if that's 0; c_E4 and c_E8 are p_ftCommonData fields from PlCo.dat, so the window and divisor aren't in the code. Fighter_procInput sets x67F to 0 on an update where the HSD_PAD_LR bit is newly pressed and otherwise adds 1, up to 255. That bit is on while L or R is held, while the analog trigger is past its deadzone, or while Z is held unless gm_GetDbPauseFlag(0) is true, and it's off while the unnamed gm_8016B0FC is true. Without cmd_vars[0], the fighter takes the basic landing (ftCo_Landing_Enter_Basic). Super Smash Bros. reads the same moment differently (ftCommonAttackAirProcMap): when the aerial's flag1 is clear or Z was pressed no more than 10 counts before (tics_since_last_z ≤ 10), it skips the aerial's landing lag outright, landing in Wait if the air speed is above −20 and in Landing otherwise, where Melee divides the lag. Code
|