Damage percent

References

1. ^ abIn 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;
   

   3856    if (fp->damage_knockback != 0.0F)
   ⋮
   3872        fp->damage_knockback -= knockback_resist;
   ⋮
   3878        ftParamUpdateDamage(fp, fp->damage_queue);
   

   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;
   

   1000    s32 percent_damage;                 // Fighter's damage
   

   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

2. ^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.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;
   

   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
   

   2672    FTAttributes *attr = this_fp->attr;
   

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

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

   2990    this_fp->damage_knockback = knockback;
   

   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);
   

   3816void ftMainProcParams(GObj *fighter_gobj)
   

   4007    fp->damage_queue = 0;
   

   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