Super Smash Bros.

On this page

Related
Mechanics
References
Sources

The atlas reads Super Smash Bros. through VetriTheRetri’s decompilation, C that builds the US and Japanese ROMs. Names and comments quoted here are theirs, and the claims cite the code the US build compiles. Nothing has been measured in the game yet.

Each hit adds its damage to a damage percent that tops out at 999%^1,1, and the knockback of the next hit grows with it, with the hit’s damage, and with the target’s weight attribute². The time a fighter can’t act is the knockback divided by 1.875^3,3. A fighter is knocked out by crossing one of the stage’s bounds, and under the stock rule that costs a stock⁴. The shield holds 55 points⁵ and breaks when they run out⁵.

Once the save has counted more than 21 boots, the VS mode menu checks a word in the console’s RSP memory, and if it isn’t 6103 it sets a saved flag that turns every knockback into a random value below 200⁶.

Mechanics

Mechanic	Kind	How
Knockback	Percent-scaled	the launch grows with the target's percent and the hit's damage, scaled by the target's weight and the move's growth and base, capped at 2500
Damage percent	Capped	each hit adds its damage to the percent, up to 999
Hitstun	From knockback	the knockback divided by 1.875, as a whole count of at least 1
Blast zone	Stage bounds	crossing any of the stage's four bounds knocks a fighter out, crediting the KO to the last attacker and, under the stock rule, taking a stock; the boss and some flagged fighters are exempt
Blocking	Guard meter	a shield of 55 points wears down while held and when hit, and breaks at 0, coming back at 30
Landing lag	Press skips it	Z within 10 counts before an air attack lands skips its air-landing status

Every claim about this game, by concept (7)

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 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`).	Code
Damage percent	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.	Code
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
Knockback	In the US version of Super Smash Bros., `ftParamGetCommonKnockback` computes a hit's knockback as $(((0.1 d + 0.05 d h) \cdot 1.4 w + 18) \cdot 0.01 g + b) \cdot 0.01 r$ 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
Knockback	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
Landing lag	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.	Code

References

^ a bIn 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.CodeVetriTheRetri/ssb-decomp-rerevised
How we know
```
1527void ftParamUpdateDamage(FTStruct *fp, s32 damage)
⋮
1529    fp->percent_damage += damage;
⋮
1533    if (fp->percent_damage > 999)
⋮
1535        fp->percent_damage = 999;
```
src/ft/ftparam.c lines 1527–1536 at 572a747 · upstream ↗
```
3856    if (fp->damage_knockback != 0.0F)
⋮
3872        fp->damage_knockback -= knockback_resist;
⋮
3878        ftParamUpdateDamage(fp, fp->damage_queue);
```
src/ft/ftmain.c lines 3856–3878 at 572a747 · upstream ↗
```
2119sb32 ftMainCheckGetUpdateDamage(FTStruct *fp, s32 *damage)
⋮
2121    if (fp->is_damage_resist)
⋮
2123        fp->damage_resist -= *damage;
⋮
2125        if (fp->damage_resist <= 0)
⋮
2127            fp->is_damage_resist = FALSE;
⋮
2129            *damage = -fp->damage_resist;
⋮
2132    if (!(fp->is_damage_resist))
⋮
2134        fp->damage_queue += *damage;
```
src/ft/ftmain.c lines 2119–2134 at 572a747 · upstream ↗
```
1000    s32 percent_damage;                 // Fighter's damage
```
src/ft/fttypes.h line 1000 at 572a747 · upstream ↗
Checked against the evidence by its author, an AI model, 2026-10-22.
Revised after a check by a second AI model, 2026-10-22.
In the claim ledger

^In the US version of Super Smash Bros., ftParamGetCommonKnockback computes a hit's knockback as

(((0.1 d + 0.05 d h) \cdot 1.4 w + 18) \cdot 0.01 g + b) \cdot 0.01 r

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.CodeVetriTheRetri/ssb-decomp-re

How we know

1451f32 ftParamGetCommonKnockback(s32 percent_damage, s32 recent_damage, s32 hit_damage, s32 knockback_weight, s32 knockback_scale, s32 knockback_base, f32 weight, s32 attack_handicap, s32 defend_handicap)
⋮
1455    if (knockback_weight != 0)
⋮
1457        knockback = ( ( ( ( ( ( 1 + ( 10.0F * knockback_weight * 0.05F ) ) * weight * 1.4F ) + 18.0F ) * ( knockback_scale * 0.01F ) ) + knockback_base ) * ( gSCManagerBattleState->damage_ratio * 0.01F ) * dFTCommonDataHandicapTable[attack_handicap - 1][0] ) * dFTCommonDataHandicapTable[defend_handicap - 1][1];
⋮
1459    else 
⋮
1461        f32 damage_add = percent_damage + recent_damage;
⋮
1463        knockback = ( ( ( ( ( ( ( damage_add * 0.1F ) + ( damage_add * hit_damage * 0.05F ) ) * weight * 1.4F ) + 18.0F ) * ( knockback_scale * 0.01F ) ) + knockback_base ) * ( gSCManagerBattleState->damage_ratio * 0.01F ) * dFTCommonDataHandicapTable[attack_handicap - 1][0] ) * dFTCommonDataHandicapTable[defend_handicap - 1][1];
⋮
1465    if (knockback >= 2500.0F)
⋮
1467        knockback = 2500.0F;

src/ft/ftparam.c lines 1451–1468 at 572a747 · upstream ↗

2699            knockback_temp = ftParamGetCommonKnockback
⋮
2701                this_fp->percent_damage, 
2702                this_fp->damage_queue, ft_attack_coll->damage, 
2703                ft_attack_coll->knockback_weight, 
2704                ft_attack_coll->knockback_scale, 
2705                ft_attack_coll->knockback_base, 
2706                attr->weight, 
2707                attacker_fp->handicap, 
2708                this_fp->handicap

src/ft/ftmain.c lines 2699–2709 at 572a747 · upstream ↗

2672    FTAttributes *attr = this_fp->attr;

src/ft/ftmain.c line 2672 at 572a747 · upstream ↗

898    f32 weight;                                     // Or, rather, "knockback multiplier"

src/ft/fttypes.h line 898 at 572a747 · upstream ↗

2845        if (knockback < knockback_temp)
⋮
2847            knockback = knockback_temp;

src/ft/ftmain.c lines 2845–2847 at 572a747 · upstream ↗

2990    this_fp->damage_knockback = knockback;

src/ft/ftmain.c line 2990 at 572a747 · upstream ↗

3856    if (fp->damage_knockback != 0.0F)
⋮
3858        if ((fp->status_id == nFTCommonStatusSquat) || (fp->status_id == nFTCommonStatusSquatWait))
⋮
3860            fp->damage_knockback *= (2.0F / 3.0F);
⋮
3866        if (fp->knockback_resist_status < fp->knockback_resist_passive)
⋮
3868            knockback_resist = fp->knockback_resist_passive;
⋮
3870        else knockback_resist = fp->knockback_resist_status;
⋮
3872        fp->damage_knockback -= knockback_resist;
⋮
3874        if (fp->damage_knockback <= 0)
⋮
3876            fp->damage_knockback = 0;
⋮
3878        ftParamUpdateDamage(fp, fp->damage_queue);

src/ft/ftmain.c lines 3856–3878 at 572a747 · upstream ↗

3816void ftMainProcParams(GObj *fighter_gobj)

src/ft/ftmain.c line 3816 at 572a747 · upstream ↗

4007    fp->damage_queue = 0;

src/ft/ftmain.c line 4007 at 572a747 · upstream ↗

Checked against the evidence by its author, an AI model, 2026-10-22.

Checked by a second AI model, 2026-10-22.

In the claim ledger

^ a bIn 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).CodeVetriTheRetri/ssb-decomp-re

How we know

1505f32 ftParamGetHitStun(f32 knockback)
⋮
1507    return knockback / 1.875F;

src/ft/ftparam.c lines 1505–1508 at 572a747 · upstream ↗

482    f32 hitstun_tics = ftParamGetHitStun(knockback);
⋮
491    this_fp->status_vars.common.damage.hitstun_tics = hitstun_tics;
⋮
493    if (this_fp->status_vars.common.damage.hitstun_tics == 0)
⋮
495        this_fp->status_vars.common.damage.hitstun_tics = 1;

src/ft/ftcommon/ftcommondamage.c lines 482–496 at 572a747 · upstream ↗

468typedef struct ftCommonDamageStatusVars
⋮
470	s32 hitstun_tics;

src/ft/ftcommon.h lines 468–470 at 572a747 · upstream ↗

662void ftCommonDamageGotoDamageStatus(GObj *fighter_gobj)
⋮
674    else ftCommonDamageInitDamageVars(fighter_gobj, -1, fp->damage_queue, fp->damage_knockback, fp->damage_angle, fp->damage_lr, fp->damage_index, fp->damage_element, fp->damage_player_num, FALSE, FALSE, TRUE);

src/ft/ftcommon/ftcommondamage.c lines 662–674 at 572a747 · upstream ↗

85void ftCommonDamageDecHitStunSetPublic(GObj *fighter_gobj)
⋮
89    if (fp->status_vars.common.damage.hitstun_tics != 0)
⋮
91        fp->status_vars.common.damage.hitstun_tics--;
⋮
101void ftCommonDamageCommonProcUpdate(GObj *fighter_gobj)
⋮
105    ftCommonDamageDecHitStunSetPublic(fighter_gobj);
⋮
107    if ((fighter_gobj->anim_frame <= 0.0F) && (fp->status_vars.common.damage.hitstun_tics == 0))
⋮
109        mpCommonSetFighterWaitOrFall(fighter_gobj);
⋮
114void ftCommonDamageAirCommonProcUpdate(GObj *fighter_gobj)
⋮
119    ftCommonDamageDecHitStunSetPublic(fighter_gobj);
⋮
121    if ((fighter_gobj->anim_frame <= 0.0F) && (fp->status_vars.common.damage.hitstun_tics == 0))
⋮
123        ftCommonDamageFallSetStatusFromDamage(fighter_gobj);

src/ft/ftcommon/ftcommondamage.c lines 85–123 at 572a747 · upstream ↗

166void ftCommonDamageCommonProcInterrupt(GObj *fighter_gobj)
⋮
170    if (fp->status_vars.common.damage.hitstun_tics == 0)
⋮
172        fp->is_hitstun = FALSE;
⋮
176            if (ftHammerCheckHoldHammer(fighter_gobj) != FALSE)
⋮
178                ftCommonHammerFallProcInterrupt(fighter_gobj);
⋮
180            else ftCommonFallProcInterrupt(fighter_gobj);
⋮
182        else if (ftHammerCheckHoldHammer(fighter_gobj) != FALSE)
⋮
184            ftHammerProcInterrupt(fighter_gobj);
⋮
186        else ftCommonWaitProcInterrupt(fighter_gobj);
⋮
191void ftCommonDamageAirCommonProcInterrupt(GObj *fighter_gobj)
⋮
195    if (fp->status_vars.common.damage.hitstun_tics == 0)
⋮
197        fp->is_hitstun = FALSE;
⋮

src/ft/ftcommon/ftcommondamage.c lines 166–199 at 572a747 · upstream ↗

214void ftCommonDamageCommonProcPhysics(GObj *fighter_gobj)
⋮
218    if (fp->ga == nMPKineticsAir)
⋮
220        if (fp->status_vars.common.damage.hitstun_tics == 0)
⋮
222            ftPhysicsApplyAirVelDriftFastFall(fighter_gobj);
⋮
224        else ftPhysicsApplyAirVelFriction(fighter_gobj);

src/ft/ftcommon/ftcommondamage.c lines 214–224 at 572a747 · upstream ↗

Checked against the evidence by its author, an AI model, 2026-10-22.

Checked by a second AI model, 2026-10-22.

In the claim ledger

^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.CodeVetriTheRetri/ssb-decomp-rerevised

How we know

1739void ftMainProcPhysicsMap(GObj *fighter_gobj)

src/ft/ftmain.c line 1739 at 572a747 · upstream ↗

1815    ftCommonDeadCheckInterruptCommon(fighter_gobj);

src/ft/ftmain.c line 1815 at 572a747 · upstream ↗

533sb32 ftCommonDeadCheckInterruptCommon(GObj *fighter_gobj)
⋮
538    if (fp->fkind == nFTKindBoss)
⋮
540        return FALSE;
⋮
542    if (fp->is_ignore_dead)
⋮
544        return FALSE;
⋮
546    if (fp->is_limit_map_bounds)
⋮
548        if (pos->y < gMPCollisionGroundData->map_bound_bottom)
⋮
550            pos->y = gMPCollisionGroundData->map_bound_bottom + 500.0F;
⋮
552            fp->physics.vel_air.x = 0.0F;
553            fp->physics.vel_air.y = 0.0F;
554            fp->physics.vel_air.z = 0.0F;

src/ft/ftcommon/ftcommondead.c lines 533–554 at 572a747 · upstream ↗

580        return FALSE;
⋮
582    else if (!(fp->is_ghost))
⋮
584        if ((gSCManagerBattleState->game_type == nSCBattleGameType1PGame) && (gSCManagerBattleState->players[fp->player].is_spgame_enemy != FALSE))
⋮
586            if (pos->y < gMPCollisionGroundData->map_bound_team_bottom)

src/ft/ftcommon/ftcommondead.c lines 580–586 at 572a747 · upstream ↗

617        else if (pos->y < gMPCollisionGroundData->map_bound_bottom)
⋮
619            ftCommonDeadDownSetStatus(fighter_gobj);
⋮
621            return TRUE;
⋮
623        else if (pos->x > gMPCollisionGroundData->map_bound_right)
⋮
625            ftCommonDeadRightSetStatus(fighter_gobj);
⋮
627            return TRUE;
⋮
629        else if (pos->x < gMPCollisionGroundData->map_bound_left)
⋮
631            ftCommonDeadLeftSetStatus(fighter_gobj);
⋮
633            return TRUE;
⋮
635        else if (pos->y > gMPCollisionGroundData->map_bound_top)
⋮
637            if (syUtilsRandFloat() < (1.0F / 6.0F))
⋮
639                ftCommonDeadUpFallSetStatus(fighter_gobj);
⋮

src/ft/ftcommon/ftcommondead.c lines 617–643 at 572a747 · upstream ↗

167void ftCommonDeadInitStatusVars(GObj *fighter_gobj)
⋮
181    ftCommonDeadUpdateScore(fp);

src/ft/ftcommon/ftcommondead.c lines 166–181 at 572a747 · upstream ↗

194void ftCommonDeadDownSetStatus(GObj *fighter_gobj)
⋮
203    ftCommonDeadInitStatusVars(fighter_gobj);

src/ft/ftcommon/ftcommondead.c lines 194–203 at 572a747 · upstream ↗

235void ftCommonDeadRightSetStatus(GObj *fighter_gobj)
⋮
244    ftCommonDeadInitStatusVars(fighter_gobj);

src/ft/ftcommon/ftcommondead.c lines 235–244 at 572a747 · upstream ↗

277void ftCommonDeadLeftSetStatus(GObj *fighter_gobj)
⋮
286    ftCommonDeadInitStatusVars(fighter_gobj);

src/ft/ftcommon/ftcommondead.c lines 277–286 at 572a747 · upstream ↗

318void ftCommonDeadUpStarProcUpdate(GObj *fighter_gobj)
⋮
362            ftCommonDeadUpdateScore(fp);

src/ft/ftcommon/ftcommondead.c lines 318–362 at 572a747 · upstream ↗

412void ftCommonDeadUpFallProcUpdate(GObj *fighter_gobj)
⋮
468            ftCommonDeadUpdateScore(fp);

src/ft/ftcommon/ftcommondead.c lines 412–468 at 572a747 · upstream ↗

48void ftCommonDeadUpdateScore(FTStruct *this_fp)
⋮
59    if ((this_fp->damage_player != -1) && (this_fp->damage_player != GMCOMMON_PLAYERS_MAX))
⋮
61        gSCManagerBattleState->players[this_fp->damage_player].score++;
⋮
70    else gSCManagerBattleState->players[this_fp->player].total_selfdestructs++;
⋮
72    if (gSCManagerBattleState->game_rules & SCBATTLE_GAMERULE_STOCK)
⋮
74        this_fp->stock_count--;

src/ft/ftcommon/ftcommondead.c lines 48–78 at 572a747 · upstream ↗

Checked against the evidence by its author, an AI model, 2026-10-22.

Revised after a check by a second AI model, 2026-10-22.

In the claim ledger

^ a bIn 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).CodeVetriTheRetri/ssb-decomp-rerevised

How we know

431    fp->shield_health = (fp->fkind == nFTKindYoshi) ? 55 : 55;

src/ft/ftmanager.c line 431 at 572a747 · upstream ↗

3837    if (!(fp->is_shield) && (fp->shield_health < 55))
⋮
3839        fp->shield_heal_wait--;
⋮
3841        if (fp->shield_heal_wait == 0.0F)
⋮
3843            fp->shield_health++;
⋮
3845            fp->shield_heal_wait = 10.0F;
⋮
3848    fp->shield_health -= fp->shield_damage_total;
⋮
3850    if (fp->shield_health <= 0)
⋮
3852        fp->shield_health = (fp->fkind == nFTKindYoshi) ? 30 : 30;
⋮
3854        is_shieldbreak = TRUE;

src/ft/ftmain.c lines 3837–3854 at 572a747 · upstream ↗

3856    if (fp->damage_knockback != 0.0F)

src/ft/ftmain.c line 3856 at 572a747 · upstream ↗

3925    else if (fp->shield_damage != 0)
⋮
3927        if (is_shieldbreak != FALSE)
⋮
3929            ftCommonShieldBreakFlyCommonSetStatus(fighter_gobj);

src/ft/ftmain.c lines 3924–3929 at 572a747 · upstream ↗

2072    victim_fp->shield_damage_total += (attack_coll->damage + attack_coll->shield_damage);

src/ft/ftmain.c line 2072 at 572a747 · upstream ↗

2264    fp->shield_damage_total += damage + wp_attack_coll->shield_damage;

src/ft/ftmain.c line 2264 at 572a747 · upstream ↗

2446    fp->shield_damage_total += damage + it_attack_coll->shield_damage;

src/ft/ftmain.c line 2446 at 572a747 · upstream ↗

72void ftCommonGuardUpdateShieldVars(GObj *fighter_gobj)
⋮
76    if (fp->is_shield)
⋮
78        if (fp->status_vars.common.guard.shield_decay_wait != 0)
⋮
80            fp->status_vars.common.guard.shield_decay_wait--;
⋮
82            if (fp->status_vars.common.guard.shield_decay_wait == 0)
⋮
84                fp->shield_health--;
⋮
86                if (fp->shield_health != 0)
⋮
88                    fp->status_vars.common.guard.shield_decay_wait = FTCOMMON_GUARD_DECAY_INT;

src/ft/ftcommon/ftcommonguard1.c lines 71–88 at 572a747 · upstream ↗

234#define FTCOMMON_GUARD_DECAY_INT 16

src/ft/ftcommon.h line 234 at 572a747 · upstream ↗

Checked against the evidence by its author, an AI model, 2026-10-22.

Revised after a check by a second AI model, 2026-10-22.

In the claim ledger

^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.CodeVetriTheRetri/ssb-decomp-re
How we know
```
1469    if (gSCManagerBackupData.error_flags & LBBACKUP_ERROR_RANDOMKNOCKBACK)
⋮
1471        knockback = syUtilsRandFloat() * 200.0F;
⋮
1473    return knockback;
```
src/ft/ftparam.c lines 1469–1473 at 572a747 · upstream ↗
```
168#define LBBACKUP_ERROR_RANDOMKNOCKBACK (1 << nLBBackupErrorRandomKnockback)		// 0x1 - Random knockback between 0.1 (?) and 1.0 x 200u
```
src/lb/lbdef.h line 168 at 572a747 · upstream ↗
```
1622    if (!(gSCManagerBackupData.error_flags & LBBACKUP_ERROR_RANDOMKNOCKBACK) && (gSCManagerBackupData.boot > 21) && (gSYMainImemOK == FALSE))
⋮
1624        gSCManagerBackupData.error_flags |= LBBACKUP_ERROR_RANDOMKNOCKBACK;
```
src/mn/mnvsmode/mnvsmode.c lines 1622–1625 at 572a747 · upstream ↗
```
134void syMainSetImemStatus(void)
⋮
136    if (IO_READ(SP_IMEM_START) == 6103)
⋮
138        gSYMainImemOK = TRUE;
⋮
140    else gSYMainImemOK = FALSE;
```
src/sys/main.c lines 134–141 at 572a747 · upstream ↗
```
172f32 syUtilsRandFloat(void)
⋮
177    return ((step >> 16) & 0xFFFF) / 65536.0F;
```
src/sys/utils.c lines 172–177 at 572a747 · upstream ↗
Checked against the evidence by its author, an AI model, 2026-10-22.
Checked by a second AI model, 2026-10-22.
In the claim ledger

Sources

Code

VetriTheRetri. 2026. “ssb-decomp-re: a decompilation of Super Smash Bros. (VetriTheRetri/ssb-decomp-re).” Commit 572a747. VetriTheRetri/ssb-decomp-re @ 572a747 · licence, all uses

Related

Mentioned in

Mechanics

References

Sources

Code