Super Smash Bros. (the VetriTheRetri decompilation, VetriTheRetri/ssb-decomp-re)

In the US version of Super Smash Bros., ftParamGetCommonKnockback computes a hit's knockback as $(((0.1d+0.05dh)\cdot 1.4w+18)\cdot 0.01g+b)\cdot 0.01r$ 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. ssb64/knockback

About: Super Smash Bros. Knockback

{
 "percent": 0.1,
 "percentTimesDamage": 0.05,
 "weight": 1.4,
 "add": 18,
 "scalePer": 0.01,
 "ratioPer": 0.01,
 "setKnockbackAt": 10,
 "cap": 2500,
 "crouch": 0.6666667
}

Weapon and item hits pass their staled damage as h; fighter hits pass the hitbox's own damage. Throws and some specials call the same routine with other arguments (for example percent_damage, damage, damage in ftcommonthrown2.c). The handicap table is dFTCommonDataHandicapTable in src/ft/ftcommondata.c; its row for handicap 8 is 1.0 and 1.0. A per-fighter weight value is ROM data (src/relocData, which the atlas doesn't fetch). The same routine ends with the random knockback of ssb64/random-knockback.

Cited by: Damage percent, Knockback, Super Smash Bros.

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. ssb64/random-knockback

About: Super Smash Bros. Knockback

{
 "range": 200,
 "bootsOver": 21,
 "imemWord": 6103
}

The statement says only what the code does. Why the game checks that word, and what a copy of the game would have to be for the check to fail, isn't stated in the code; the flag's neighbours in lbdef.h (LBBACKUP_ERROR_HALFSTICKRANGE, LBBACKUP_ERROR_1PGAMEMARIO) are other penalties of the same kind. The ground-hazard copy of the routine (ftParamGetGroundHazardKnockback, US only) has the same ending.

Cited by: Super Smash Bros.

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). ssb64/hitstun

About: Super Smash Bros. Hitstun

{
 "divisor": 1.875,
 "minimum": 1
}

53 is 100 / 1.875 = 53.33, truncated by the store to an s32. Whether a status's update runs once per displayed frame isn't read here, so the count isn't stated in seconds. The same count picks the damage animation's level, against thresholds of 12, 24, and 32 (FTCOMMON_DAMAGE_LEVEL_HITSTUN_* in src/ft/ftcommon.h). Wall bounces (ftcommonwalldamage.c) and Donkey Kong's held throw victim (ftdonkeythrowfdamage.c) set the count the same way.

Cited by: Hitstun, Super Smash Bros.

In the US version of Super Smash Bros., ftParamUpdateDamage adds the damage a fighter takes to its percent_damage and caps it at 999. ftMainProcParams calls it with damage_queue, to which ftMainCheckGetUpdateDamage adds each hit's damage, but only inside a branch taken when the fighter's damage_knockback isn't 0, tested before knockback resistance is subtracted; there, queued damage from hits that gave no knockback isn't added. While the fighter has damage resistance (is_damage_resist), a hit's damage goes against damage_resist first, and only what passes it reaches the queue. ssb64/damage-percent

About: Super Smash Bros. Damage percent

Value: 999 %

The same routine records the total for the results screen and may make a held item drop when the fighter is knocked back. A grabbed fighter takes half damage, rounded up, and every fighter's damage is multiplied by its damage_mul (ftParamGetCapturedDamage). The knockback formula reads the percent before this hit is added, plus the queue (ssb64/knockback).

Cited by: Damage percent, Super Smash Bros.

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. ssb64/ring-out

About: Super Smash Bros. Blast zone

{
 "upFallChance": 0.1666667,
 "limitPushback": 500
}

The bounds are per-stage data (gMPCollisionGroundData), so their values aren't read here. stock_count runs out at −1, by the decompilers' comment in fttypes.h, and ftCommonDeadCheckRebirth puts a fighter with −1 stocks to sleep rather than respawning it. The 1P Game also takes a stock for each fall.

Cited by: Blast zone, Super Smash Bros.

In the US version of Super Smash Bros., a fighter's shield_health starts at 55. In ftMainProcParams, while the fighter isn't shielding and is below 55, it regains 1 each time a 10-count wait runs out; then the damage of the hits its shield took is subtracted, each hit's damage plus its shield_damage, and at 0 or below the health is set to 30, whatever else that update does. The shield break (ftCommonShieldBreakFlyCommonSetStatus) is called only in the branch taken when the fighter has no knockback to apply (damage_knockback is 0) and its shield_damage isn't 0. While the shield is up, ftCommonGuardUpdateShieldVars takes 1 off every 16 counts (FTCOMMON_GUARD_DECAY_INT). ssb64/shield

About: Super Smash Bros. Blocking

{
 "start": 55,
 "afterBreak": 30,
 "regenEvery": 10,
 "decayEvery": 16
}

Both the start value and the reset test for Yoshi and give the same number either way, so every fighter gets 55 and 30. The shield's drawn size scales with shield_health / 55 (FTCOMMON_GUARD_SIZE_HEALTH_DIV). Weapon and item hits add their staled damage.

Cited by: Blocking, Super Smash Bros.

In the US version of Super Smash Bros., when a fighter in an air attack lands, ftCommonAttackAirProcMap enters the move's air-landing status only when the motion's flag1 is nonzero and more than 10 counts have passed since Z was last pressed (tics_since_last_z: set to 0 on a Z press, counted up each update, and set to its maximum when the air attack starts, so a press before the attack doesn't count); otherwise it skips that status and enters Wait if the fighter's vertical speed is above −20, or the plain Landing status if not. Reading flag1 as the move's switch for landing lag is the atlas's. ssb64/z-cancel

About: Super Smash Bros. Landing lag

{
 "windowCounts": 10,
 "waitIfVelYAbove": -20
}

flag1 is also given a percent (F_PCT_TO_DEC) when the move has no air-landing animation, and an air attack's setup clears it (ftcommonattackair.c L190); what sets it nonzero is in the move scripts, not read here.

Cited by: Landing lag