Series

Mario

Nintendo's franchise around Mario, from the Super Mario platformers to the racing, puzzle, and role-playing series named for him.

Mario is Nintendo’s franchise around its hero of the same name. Its center is the Super Mario platformers, which began with Super Mario Bros. in 1985¹. Miyamoto set out to make that game like his arcade Mario Bros. of 1983, but scrolling, bright, and with bigger characters², and its specification refines pieces of Donkey Kong, Donkey Kong Jr., and Mario Bros.³. Other series take Mario’s name into kart racing (Mario Kart), role-playing (Paper Mario), and falling-block puzzles (Dr. Mario).

Series

Dr. Mario — Nintendo's falling-block puzzle series, begun on the NES and Game Boy in 1990.
Mario Kart — Nintendo's kart-racing series with Mario's cast, begun on the Super NES in 1992.
Paper Mario — Intelligent Systems' role-playing series with Mario, begun on the Nintendo 64 in 2000.
Super Mario — Nintendo's platformers starring Mario, begun on the Famicom in 1985.

Games

Mechanics

Mechanic	Super Mario Bros. 1985	Super Mario Bros.: The Lost Levels 1986	Super Mario Bros. 2 1988	Super Mario Bros. 3 1988	Super Mario Land 1989	Dr. Mario (NES) 1990	Super Mario World 1990	Mario Kart 64 1996	Super Mario 64 1996	Paper Mario 2000	Super Mario Sunshine 2002	Mario Kart: Double Dash!! 2003
Action command										Timed pressHold and release
Air control	Momentum			Momentum			Momentum
Bonus stage			Slot machine
Chain						Cascade
CHR bank switching	Fixed			Mid-frame
Clearing						Line of four
Climbing			Vine or ladder
Continue		Unlimited
Coyote time	None	None		Some platforms			None
Damage formula										Attack minus defense, no roll
Delayed auto shift						Delay, then repeat
Demo playback	Input script
Destructible terrain	Breakable tiles
Difficulty ramp		Level flag
DPCM samples				Music track
Drift boost								Stick stages
Drop speed						Piece ramp
Enemy spawning		Generated
Engine class								Top speed
Entry delay						Animation
Extra life		Other condition	Other condition
Flight			Hover	Run-up							Held height
Garbage						Dropped on top
Gravity	Switch on release	Switch on release	Lighter while held	Lighter while held	None		Lighter while held		One gravity		One gravity
Ground pound									Hover then drop
Healing item			Instant
Health upgrade			Whole containers
Hit points			uses
Hitbox	Points and a box						Points and a box
Invincibility frames	Slow timer	Slow timer	Frame timer	Frame timer			Frame timer
Item distribution								By placeFlat				By place
Jump	Speed from the run	Speed from the run	Speed by state	Speed from the run	Table		Speed from the run		Speed from the run		Speed from the run
Knockback			Launch
Lock delay						None
Long jump									From a crouch slide
Mode 7							Rotate and scale
Multiplayer				Alternating
Music driver	Length table						Fractional tempo
Palette cycling	Color step
Piece randomizer						Dealt in advance
Power-up				Until hit
Projectile				Ballistic
Raster effects	Two bands			Several bands
Rocket start								Press window
Rubber-band AI								Power boost
Running	Run button	Run button	Run button	P-meter			P-meter		Analog
Sampled sound							Sampled instruments
Slope sliding				On Down
Springboard		Timed press
Sprite flicker	Rotating slots
Status bar split	Sprite 0 hit			Scanline IRQ			Scanline IRQ
Timed guard										Reduce · MarioNegate · partners
Triple jump									Landing chain		Landing chain
Variable jump height	Gravity switch	Gravity switch	Held gravity	Held gravity	Hold timer		Held gravity		Release cut		Release cut
Wall jump	uses								Kick		Wall slide
Wind		Area push
Stage select				uses
Water physics				uses

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 Mario Bros. 1985	Super Mario Bros.: The Lost Levels 1986	Super Mario Bros. 2 1988	Super Mario Bros. 3 1988	Super Mario Land 1989	Dr. Mario (NES) 1990	Super Mario World 1990	Mario Kart 64 1996	Super Mario 64 1996	Paper Mario 2000	Super Mario Sunshine 2002	Mario Kart: Double Dash!! 2003
Action command										In the US version of Paper Mario, the jump action command (`action_command_jump`) is one press of A timed to the stomp, and runs only once Mario has learned action commands (not `AC_MODE_NOT_LEARNED`). The basic Jump (`EVS_UseMove_Basic`, the script for menu level 0) computes the jump's length as `(distance - 20) / 10.588 + 15` from Mario to the target, gives that count to `PlayerBasicJumpToGoal`, and passes the same count to the command as `prepareTime`, at difficulty `AC_DIFFICULTY_STANDARD` (index 3 of 8). Each update the command counts `prepareTime` down until it is no more than the window size, `actionCmdTableJump[difficulty]`, which is 4 at standard in a table running 7 down to 0; it then sets the window timer to that size and counts it down to 0. A press of A while `prepareTime` is still counting sets `wrongButtonPressed`, and the window then takes no press; the update in which the count reaches the window size runs that early-press test before falling through into the window, so a press there is early too, and a press counts only while the timer runs from 3 to 0, 4 updates at standard (computed), the last of the command's updates. When the partner isn't acting, `adjust_action_command_difficulty` lowers the difficulty index by 3 for each Dodge Master badge equipped, clamped at 0, so one badge widens the window to 7 updates (computed). A good press makes the basic Jump's first stomp a nice hit, and the script then bounces Mario into a second stomp; each stomp passes a damage of 1. A missed press ends the move after the first. Code In the US version of Paper Mario, the hammer action command (`action_command_hammer`) is a hold and release of the stick to the left. When action commands are learned and the Berserker badge isn't equipped, the hammer script (outside the tutorial and auto-success) waits up to 45 updates for the stick to be held left, then starts the command with a duration of 51 (45 plus 6) at `AC_DIFFICULTY_STANDARD`, whose table value `actionCmdTableHammer[3]` is 8 without a Dodge Master badge. The command's timer counts up from 0 each update. Its look-back count is the table value minus the updates left (`duration - stateTimer`) plus 3, at least 0: while it is 0, a stick not held left fails the command at once (`ACTION_RESULT_EARLY`), and once it is above 0 the command succeeds if any of that many latest entries of the held-button buffer has the stick not held left. That opens the release window at timer 41 and keeps it through timer 51, 11 updates (computed); the command marks ready (`HES_TimingReady` and its sound) at timer 42, one update after the window opens (computed). A stick still held when the timer passes 51 fails. With the basic hammer, a success passes a damage of 2 and a failure 1 (comments in the script call them "good input dmg" and "bad input dmg"). Code
Air control	In the air `X_Physics` takes the running cap `$28` and acceleration `$E4` while Mario's speed is `$19` or more, and the walking cap `$18` with `$98` (or `$D0` while `RunningSpeed` is set) below it, whatever B does. Code `LRAir` runs `ImposeFriction` only while Left or Right is held, so in the air a held direction accelerates Mario toward it up to the cap and a released d-pad keeps his speed. Code Because a jump keeps Mario's take-off facing, steering back slows him at the plain rate until he moves the other way, then at double the rate (`$1A0` from a run). Verified			With neither Left nor Right held, Mario's horizontal speed gets friction only on the ground; in the air the routine returns and he keeps his speed. Code			In the air with neither Left nor Right held, Mario's horizontal routine returns before friction, so he keeps his speed. Code Holding a direction in the air accelerates Mario by `MarioAccel_`'s 1.5/16 px/frame each frame up to his top speed, or by 5/16 (2.5/16 without Y) while he still moves the other way. Code Measured in the game, a running jump keeps 36/16 px/frame when Right is let go, and turning Left in the air reverses it within 8 frames and reaches 36/16 the other way 29 frames after the turn. Verified In the air Mario's horizontal speed follows the ground's code except that a released d-pad keeps the speed and the cap index never reaches 2 unless he left at full P-meter; a frame-by-frame model of these rules reproduces every probed frame. Verified Measured frame by frame, a running jump turned with Left and Y held drops from 35/16 px/frame to exactly 0 in 7 frames of −5/16, then gains −1.5/16 a frame and reads −36/16 on the 31st frame of the turn. Verified
Area transition			A thrown potion that lands makes a door in a puff of smoke, except in a vertical area, where only the smoke is left. Through the door, Subspace lasts 96 ticks of four frames, about 384 frames, and ends early if the player dies. Its grass gives coins on the level's first two visits that pull a coin, and small vegetables after. Code
Bonus stage			The Bonus Chance after a level spins three reels of eight positions, one coin a spin. Each position holds one of four symbols: a Snifit, a turnip, a star, or a cherry. Each reel steps every 4 frames, and A stops the leftmost still spinning. A cherry on the first reel wins a life, cherries on the first two win two, three cherries five, and three of another symbol one; lives stop at 255. Each reel holds one cherry. Code Both games end a level with a Bonus Chance, and Doki Doki Panic's disk holds Super Mario Bros. 2's 24 bytes of slot-machine reels with two exceptions. Where SMB2's first reel has a turnip (its second symbol) and a Snifit (its fifth), the disk has `$00`, the value SMB2's code reads as a cherry, so that reel holds three of SMB2's cherry values on the disk and one in SMB2. A cherry on the first reel wins a life. Code
Chain						When a clear happens, `updateField` sends the placed pill's steps back to `checkDrop`, which lets unsupported halves fall, and the match checks run again, so one pill can set off a chain of clears. Code In a one-player game each virus cleared scores 100, 200, or 300 points at Low, Med, or Hi, times 1, 2, 4, 8, 16, then 32 for the 6th to 11th virus cleared by the same pill. The multiplier isn't capped (the clamp is one of the disassembler's bugfix options, not in the original build), so from the 12th virus on it indexes bytes past the end of the 11-entry table. Code
CHR bank switching	The cartridge header declares two 16 KB PRG ROM pages and one 8 KB CHR ROM page, so the game's tile set never changes. Code			At the status bar the IRQ handler switches the background's two 2 KB CHR banks to the status bar's tiles and all four 1 KB sprite banks to blank tiles, so no sprite shows over the bar. Code In ordinary levels the game picks the 2 KB background bank at PPU `$0800` from `PT2_Anim`, banks `$60`, `$62`, `$64`, `$66`, by frame-counter bits 3-4, so the animated tiles step every 8 frames on a 32-frame loop; an active P-Switch forces bank `$3E`. Code
Clearing						After a pill lands the game scans the bottle row by row for 4 or more cells of one color in a row, then column by column for 4 or more in a column, and clears every run it finds. Code
Climbing			On a vine, chain, or ladder the player climbs up at `$F0` (1 px/frame), down at `$20` (2 px/frame), and sideways at 1 px/frame. Holding up and down together reads past the end of the table, the byte `$A5`, and sends the player up at 5.6875 px/frame. Holding left and right together reads past the end of the sideways table too, again a byte `$A5`, the first of `HandlePlayerState_Climbing`, and sets the sideways speed to 5.6875 px/frame to the left. Code
Continue		At a game over outside World 9, Select switches between CONTINUE and RETRY and Start picks. Continue restarts the current world at its first level, small, with three lives, the score and coins at zero, and the hidden 1-up available again. Retry ends the game and clears the record of completed worlds. Code
Coyote time	Mario gets no grace window after leaving a ledge; `ProcJumping` refuses airborne jumps unless he is swimming. Code Mario leaves a ledge on the frame his horizontal move leaves neither foot point over a block; the falling state that `PlayerBGCollision` sets first then stays, so he ends that frame in the air, with a vertical speed of 0, and starts falling on the next. Walking right, the left foot point decides, so he walks 5 px past the edge (measured); walking left, the right foot point decides, 4 px past it (from the code's points). Verified	`ProcJumping` starts a jump only while `Player_State` is 0, on the ground, or while the player is swimming, as Super Mario Bros.'s does. Walking off a ledge doesn't keep that state: `PlayerBGCollision` sets a player in the normal or climbing state to falling (or, swimming, to state 1) on each frame of play before it looks for ground, and only landing on a block sets the state back to 0, so out of water a jump can't start after walking off a ledge. The background check skips that step only during the game's scripted routines (`GameEngineSubroutine` 0 to 3 and `$0B`). Code		Some objects Mario rides set `Player_AllowAirJump`, a countdown in which a jump still starts in the air, to 5, 8, or 16; the Parabeetle sets 5 as it droops. `Player_JumpFlyFlutter` decrements the count before testing it, so those values leave 4, 7, or 15 updates in which a press of A jumps. Code			When neither foot point finds a block and Mario isn't in the air, collision sets `PlayerInAir` to `$24` (falling). Collision follows the move, so he counts as airborne on the frame whose move carries his trailing foot past the edge, already moved by the ground's vertical speed, 6/16 px/frame (3/16 with B held); gravity then adds 6/16 a frame (3/16 held) up to 70/16. Verified Mario gets no grace window after walking off a ledge; `CODE_00D5F2` starts a jump only while `PlayerInAir` is 0, and block collision, earlier in the same frame, has already set it to `$24`. Verified
Damage formula										In the US version of Paper Mario, `calc_player_damage_enemy` works out Mario's damage to an enemy by subtraction. A forced immune hit (`BS_FLAGS1_FORCE_IMMUNE_HIT`) skips the calculation, and some hits return before it: an illusory, transparent, or buried target (buried unless the attack is a quake) is missed; a stone target takes nothing; a jump on a spiky top without Spike Shield, a contact attack on an explode-on-contact part, on a fiery part without Fire Shield or Ice Power, or on the alternate spiky flag without Spike Shield backfires; and a fire attack that sets off a part that explodes on fire returns before damage. Otherwise it starts from the move's damage (`curAttackDamage`, which the move script passes), adds Power Plus badges (`count_power_plus`), and adds or takes fixed amounts for Merlee, the jump and hammer charges, other badges, and statuses (L456-L535). A missed All or Nothing sets the damage to 0, and outside the Japanese build the defense too; a shrunk Mario's damage is halved, but stays at least 1; a blast on a part that explodes on ignition sets the damage to the target's HP and the defense to 0; and `DAMAGE_TYPE_STATUS_ALWAYS_HITS` sets both to 0. The total is capped at 99, and the target's defense is then subtracted: `get_defense`, plus the defense boost unless the attack ignores defense, plus 127 for a part flagged extreme defense, or 0 when the total is below 0. A result below 0 becomes 0, and a Power Bounce then adds its counter, keeping a hit above 0 at least 1. The function's one `rand_int` call, the `DAMAGE_TYPE_FEAR` scare-away test, runs after the damage is taken off the target's HP. Code
Delayed auto shift						A press of Left or Right moves the pill at once and zeroes `currentP_horVelocity`; held, the count rises each frame and at 16 the pill moves and the count restarts at 10, so it moves again 16 frames after the press and then every 6. The European build uses 13 and 5. Code A blocked shift sets the count to 15, so a pill held against a wall or the stack moves on the first frame the way is clear. Code
Demo playback	Super Mario Bros.' demo is a script of 21 controller bytes in `DemoActionData`, each held for the number of frames at the same place in `DemoTimingData`; `DemoEngine` moves to the next byte when the count runs out. The 21 counts add up to 1,119 frames (computed), about 18.6 seconds at the NES's 60.1 frames a second (computed). Code The demo writes each byte into `SavedJoypad1Bits`, the byte the interrupt routine fills from controller 1 every frame, and then calls `GameCoreRoutine`, the same engine a game in play runs, so Mario moves by the ordinary player code. Code Each time the title screen starts, `InitializeGame` sets `DemoTimer` to `$18` (24). It is one of the interval timers, which the interrupt routine counts down once every 21 frames, so the demo starts about 500 frames after the title appears (computed: 24 × 21 = 504, less up to 20 for the first tick). Pressing Select, or B once world select is enabled, puts the timer back to `$18`. Code The demo ends, and the title screen restarts from `InitializeGame`, in three ways: the script reaches its closing count of 0; the engine reaches its lose-life routine (`GameEngineSubroutine` 6); or a player presses Start (alone or with A) or Select on either controller; B, which the title screen checks for world select, isn't tested while the demo runs. Code The demo doesn't reseed the random generator. `PseudoRandomBitReg` at `$07A7` gets its seed `$A5` only at reset, and the interrupt routine shifts it every frame; `InitializeGame` clears memory only up to `$076F`. The generator's state when the demo starts therefore depends on the number of frames since reset. Code
Destructible terrain	`CheckForSolidMTiles` splits what a head can meet by the metatile's top two bits: at or above `$10`, `$61`, `$88`, or `$C4` in its group is solid (smb1/head-solid); below is hit (`PlayerHeadCollision`). The collision map stores nothing below `$10`, `$51`, `$88`, and `$C0` in the same groups, so the hit kinds are `$51`–`$60` (bricks, the cracked-rock ground, bricks with items, hidden blocks) and `$C0`–`$C1` (? blocks); a used block (`$C4`), the solid blocks from `$61`, and pipes are solid. Code `PlayerHeadCollision` bumps the block unless Mario is big and the metatile is missing from `BrickQBlockMetatiles`, the list of ? blocks (`$C0`, `$C1`), hidden blocks (`$5F`, `$60`), and bricks with items (`$55`–`$5E`); then it breaks it (smb1/brick-break). So big Mario breaks plain bricks (`$51`–`$53`) and bumps the rest, and small Mario bumps everything. Size is `PlayerSize`, so by the code a crouching big Mario breaks bricks too (not probed). Measured: big Mario, standing, broke a brick and bumped a ? block and a hidden block; small Mario bumped a brick and a ? block. Verified A bump (`BumpBlock`) sets Mario's vertical speed byte to 0, keeping the fraction, and starts a block object at the block's row moving up at 2 px/frame under a gravity of `$50`/256 px/frame². The object moves on the hit frame itself, after the player; measured against its row, it reads −2, −4, −6, −7, −7, −8, −8, −8, −7, −6, −5, −4, −2, 0 px on the hit frame and the 13 after, and it ends when its Y's low nybble is under 5. The block's cell holds `$23` from the hit frame, and the next frame's `BlockObjMT_Updater` writes the block back: a used block (`$C4`) for ? blocks, hidden blocks, and item bricks, the metatile itself for a plain brick or ground block that small Mario hit. Measured: the cell held `$23` for 14 frames. Verified Every head hit that reaches `PlayerHeadCollision`, bump or break, sets `BlockBounceTimer` to 16, a frame timer. Until it is back at 0, the head check treats bricks and ? blocks as solid without the sound (smb1/head-solid), so no second block can be bumped or broken for 16 frames. Measured after five bumps: 16 on the hit frame, 0 sixteen frames later. Verified During a bounce, and on the frame after a brick breaks, the block's cell holds `$23`, and every test of `PlayerBGCollision` takes its solid path for it: the head check's solid range starts at `$10` in group 0; the foot check's exceptions (climbable from `$24`, the axe `$C5`, hidden blocks `$5F` and `$60`) miss it, so it lands Mario or pushes him back; and the side check's exceptions (hidden blocks, climbable, coins `$C2` and `$C3`, jumpspring `$67` and `$68`, the pipe openings) miss it, so it ends in `StopPlayerMove`. Code Breaking a brick (`BrickShatter`) sets Mario's vertical speed byte to −2, adds 50 points, spawns debris (smb1/brick-debris), and flags the cell, which holds `$23` meanwhile, to be cleared to 0. The clearing comes on the next frame's `BlockObjMT_Updater`, after that frame's `PlayerBGCollision`, so the next frame's head check still meets `$23` and sets the speed to 1: a break stops the jump one frame later, 1 or 2 px higher (computed), not passing through. Measured: 1 px higher, speed 1, and the cell 0 by the end of that frame, with a second brick stacked above never reached. Verified `SpawnBrickChunks` makes the debris from two block objects at the block's place, the upper starting up at 6 px/frame and the lower, 8 px down, at 4 px/frame, both with horizontal speed `$F0`. `BlockObjectsCore` moves each under `ImposeGravityBlock` (`$50`/256 px/frame², fall cap 8) and draws them with `DrawBrickChunks`, which puts each object's two sprites at its own X and at the original X mirrored across it, plus 6, so four chunks fly apart. Code Big Mario breaks a ground block he hits from below: the overworld's terrain metatile, `$54` (cracked rock), is in the hit range and not in `BrickQBlockMetatiles`, so the game treats it as a plain brick (smb1/bump-or-break). Measured with a `$54` block written 4 rows above World 1-1's floor: big Mario broke it, for 50 points, and small Mario bumped it, the block bouncing and coming back as `$54`. Verified A brick with coins (`$58`, `$5D`) starts `BrickCoinTimer` at 11 on its first hit. Every bump gives a coin; while the timer runs the brick comes back as itself, and the first bump after it reaches 0 leaves a used block. It is an interval timer, counted down once every 21 frames, so the brick pays out for 11 such ticks, 211 to 231 frames (computed). Code						A turn block (`$11E`) under the head point is hit from below like any functional block: it becomes bounce sprite 7, the turning turn block. That path doesn't read `Powerup`, and it breaks a block only when the block's `IntBlk_BounceSprite` entry is 7; the turn block's entry is 6 (its sprite number is 7), so a plain head hit never breaks a turn block, big or small. On the hit frame collision skips the head's downward move and only zeroes a rising speed. Verified A block hit from below becomes a bounce sprite with an 8-frame timer and a vertical speed of `$C0` (−4 px/frame), and on its first frame, the hit frame, the block's cell becomes an invisible solid tile (`$152`) under it. Each frame the sprite moves by its speed's high nybble plus the carry of its low nybble into a fraction byte, then adds `$10` to the speed (a ? block) or `$13` (a turn block). Nothing clears that fraction, so a slot's leftover from its last bounce carries into the next. Verified After a head hit, a turn block bounces through the hit frame and the five after it; on the sixth it snaps back to its cell as the always-turning tile (`$048`), which nothing collides with, so Mario passes through it. Its spin timer, `$FF` at the hit, runs down by one a frame, and 255 frames after the hit frame the cell becomes a turn block again. Verified
Difficulty ramp		Every area from World 4-4 on, and every area of worlds A to D, starts with the secondary hard mode flag set; the areas of worlds 1 to 3 and 4-1 to 4-3 start without it. The memory clear at the start of each area resets it first. Code With the secondary hard mode flag set: enemies the level data marks for hard mode appear, where otherwise they are skipped; a Bullet Bill cannon is picked to fire when a pseudorandom number masked to three bits is below 6 (6 of 8 values, against 6 of 16 with four bits); up to four flying Cheep Cheeps at once instead of three; hammer bros throw on a shorter timer (`$1C` against `$30`), can take the longer of two jump timers (`$37` against `$20`), and in worlds 1 to 6 wait a shorter time before walking left (`$50` against `$80`; in worlds 7 to 9 they don't wait either way, and worlds A to D, which share world numbers 1 to 4 and always have the flag, take `$50`); Bloopers pick a new direction when two pseudorandom bits are clear rather than six, and then a Blooper in an even enemy slot turns toward the player, one in an odd slot takes the player's moving direction; Bowser's fire breath and the flames that fly in on their own come 16 timer ticks sooner, and the flames move faster (`$60` subtracted from their fractional position each frame, against `$40`); and the large lifts are drawn four sprites wide instead of six with a smaller box, as they always are in castles, with balance platforms and their ropes placed for the shorter width. Code The code keeps the primary hard mode flag's checks, which turn Goombas into Buzzy Beetles, start walking enemies faster (`$F4` against `$F8`), and revive stomped enemies sooner and send them off faster. Nothing in The Lost Levels' code sets the flag, and starting a game clears it, so none of these takes effect. Super Mario Bros. sets it from its world select flag when a game starts. Code
DPCM samples	During the overworld and underwater songs the sound engine raises a counter by 1 a frame up to `$30` and writes it to the DMC's output level at `$4011`; other songs count it back down to 0, and the game plays no samples. Code			The music data has a sample track beside the other channels' tracks; each note byte on it queues a sample, and `Music_PlayDMC` loads that sample's rate, address, and length from three 16-entry tables and restarts the DMC. Code The 16 sample entries play 9 recordings, some reused at a lower rate or cut short; their rate bytes are `$0F` (33,144 Hz) for most, and `$0E` (24,858 Hz) or `$0D` (21,307 Hz) for some of the reused copies. Code
Drift boost								In the US version of Mario Kart 64, while a kart drifts on the ground, holding the stick at least 10 of its 53 steps toward the outside of the turn counts up `driftStateCounter`. Letting the stick back after 18 to 99 counts raises `driftState` by one, up to 3, and sets the count to 10, so each later step takes 8 more counts (computed); letting it back before 10 counts, or at 100 or more, resets both to 0. When a human player's drift ends with `driftState` at 2 or more, the kart gets `MINI_TURBO_EFFECT` for 31 player updates (computed), during which a term in its forward force moves toward 580 by a fifth of the gap each update. Code
Drop speed						`fallingPill_checkYMove` counts frames at the pill's row and drops it when the count passes an entry of `speedCounterTable`, so a row takes the entry plus one frame. The speed setting picks the starting entry, index 15, 25, or 31 for Low, Med, and Hi, which is 40, 20, or 14 frames per row; entries 0 to 14 are never reached. Code Every 10th pill moves the speed one step further along `speedCounterTable`, up to 49 steps, and each level past 20 starts a step further. After 49 steps a row takes 4 frames at Low, 2 at Med, and 1 at Hi, the table's last entry. Code Holding Down, and no other direction, drops the pill a row on every other frame, and the drop resets the gravity count. Code
Enemy spawning		While Lakitu's stretch of a level runs, the game checks every 128 frames whether a Lakitu is on screen. When none is, it counts the check, and on the third it sends a new Lakitu if an enemy slot is free (if none is, it tries again at the next check); the count starts over when a Lakitu is set up. The new one flies high in worlds 1 to 6 (`$20`) and lower in worlds 7 to 9 and A to D (`$60`). When one is on screen, the same check leads to the Spiny throw, not covered here. Code
Engine class								In the US version of Mario Kart 64, in Grand Prix and Versus the engine class sets each kart's top speed from `gTopSpeedTable` when it spawns: 290 at 50cc, 310 at 100cc, and 320 at 150cc for Mario, Luigi, Donkey Kong, Wario, and Bowser, and 4 more for Yoshi, Toad, and Peach. Extra uses the 100cc numbers, Time Trials always reads the 100cc row, and Battle gives every driver 245. Code
Entry delay						In a one-player game each new pill waits for Mario's throw: `action_sendPill` steps the pill along a table of 21 positions, once a frame at Med and Hi and on every other frame at Low, and puts it in the bottle when the table ends. In a two-player game the pill goes straight to the bottle. Code
Extra life		Grabbing the flagpole gives an extra life in place of the height's points when the coin count's two digits are the same and match the timer's last digit (11 coins with the timer ending in 1, for example). Code	uses
Flight			The Princess's `Floating Time` is `$3C`; the other three have 0. With the button held once her rise has slowed to `-$04` or less, each frame sets her vertical speed from `FloatingYVelocity`, cycling up, still, down, still, until the timer runs out. Letting go ends the float for that jump. Measured in Mesen (MesenCE 2.2.1) from power-on, on the floor at the bottom of 1-1's first area, a jump with A held floats for 60 frames, holding each speed of the cycle for 8 frames, and then falls. Verified	The P-meter, `Player_Power`, is seven bits. Mario runs, for the meter, on a frame he is on the ground and not sliding, with B held and his speed already `$28` or more. Each time `Player_PMeterCnt` reaches 0, a running frame adds a step and sets it to 8, and any other frame takes one away and sets it to 24; at 0 steps the counter stays 0, so the next run adds one at once. A full meter, `$7F`, takes 7 steps, and each running frame at full sets the counter to 16, so the meter stays full 16 frames past the last one. While `Player_FlyTime` is counting, none of this runs (flight-time). Measured in Mesen from power-on as Raccoon Mario at World 1-1's start, with Right and B held from rest the first step comes the frame after he reaches `$28`, then one every 8 frames to full; with B let go, it drops 16 frames later and then every 24. Verified A jump with the meter full and no flight time left sets `Player_FlyTime` to `$80`, which counts down every other frame, about 256 frames; when it reaches 0 the meter empties (`$FF`, the P-Wing's value, never counts down). In the Raccoon or Tanooki suit, the suits with the flight bit in `PowerUp_Ability`, each press of A in the air starts a 16-frame wag. During a wag, unless he is rising faster than `-$18`, his vertical speed is set to `-$18` while the timer is `$0F` or more, to `-$10` from `$0E` to `$08`, and to 0 from `$07` to `$01`; since the timer ticks every other frame, those two stages last 14 frames each. At 0 the tail only slows a fall (tail-wag). Measured in Mesen from power-on as Raccoon Mario at World 1-1's start, a jump at full speed with A pressed every 4 frames sets the timer to `$80`, climbs at `-$18`, then for 14 frames at `-$10` and 14 at 0, and the timer and meter run out 255 frames after the take-off. Verified On the ground, `Player_JumpFlyFlutter` clears `Player_FlyTime` unless the suit has the flight bit, so Raccoon and Tanooki Mario keep the rest of a flight through a landing, with the meter still full, and can take off again; for the other suits a full-meter jump's timer ends when they land. Code Out of flight time, a wag of A with the Raccoon or Tanooki tail caps Mario's fall at `PLAYER_TAILWAG_YVEL`, `$10`, and leaves a rise or a slower fall alone. Measured in Mesen from power-on as Raccoon Mario at World 1-1's start, wagging every 4 frames after a flight runs out, his fall levels off at `$10`, 1 px a frame. Verified							In Super Mario Sunshine, by the decompilers' Player code, which doesn't yet match, FLUDD's hover nozzle holds Mario up through the status the code calls `MARIO_STATUS_ROCKET`. `rocketCheck`, which the jumps, the wall kick, standing, and running call, enters it, unless Mario is already in it or in `MARIO_STATUS_ROCKET_LANDING`, when he has FLUDD, the current nozzle's `mRocketType` parameter is 1, his upper body is in `UPPER_STATE_PUMPING`, and the nozzle is spraying (`canSpray`, a name a decompilers' comment calls fabricated), and sets a target height `mHoverHeight` (default 160) above him; standing or running, the callers set it above the floor instead. The status's entry code has a voice for the hover, rocket, and turbo nozzles, and the height-holding code in `rocketing` runs only for the hover. Each update `rocketing` sets his vertical speed to the gap to the target times the parameter `mAccelRate` (default 0.03) and multiplies his forward speed by `mBrake` (default 0.95), the stick adding forward speed or turning him, and then `jumpProcess` moves him a quarter of his velocity: with the defaults he closes 0.75% of the gap each update (computed), and any rise or fall he carried in is dropped at once. The hover is a trigger nozzle (`TNozzleTrigger`). While Mario pumps, and in water only with a full tank, each update adds 150 times R's analog reading to `mInsidePressure`, and every update takes away `mInsidePressureDec` (default 100); when the pressure passes `mInsidePressureMax` (default 4500) while the spray is idle and the nozzle's `mRumbleOnCharge` is false, the spray starts with a timer of `mTriggerTime` updates (with `mRumbleOnCharge` true, an A press with R held starts it instead). An empty tank sets the spray back to idle; the timer running out or the pumping stopping sets it to the state the code calls `SPRAY_STATE_DEAD`, which returns to idle only once R reads 0. Without a spray, `rocketing` ends in `MARIO_STATUS_ROCKET_LANDING`. On each update it sprays, each of the nozzle's emitters asks the water manager for drops, between `mNumMin` and `mNum` by the pressure, and the tank, which holds `mAmountMax` (default 2100), loses `mDecRate` for each drop accepted. Which nozzles have `mRocketType` 1, the timer, and the tank are data in each nozzle's file, NozzleTrgHover.prm for the hover. Banjo-Kazooie's Feathery Flap, a lift of 280 units/s and a fall capped at −399.9 units/s for up to 2.5 s, slows a fall where the hover holds a height (banjo-kazooie/feathery-flap). Code notes
Garbage						In a two-player game, 2 or more matches from one pill send that many half-pills, at most 4, in the colors of the matches, to the other player's bottle, where they land at its top row in a frame-dependent column. Code
Gravity	Vertical motion is 8.8 fixed point; each frame, `ImposeGravity` adds speed to position, the fraction via the `YMF_Dummy` subpixel byte, then gravity to speed. Code `MovePlayerVertically` gives `ImposeGravity` 4 px/frame as Mario's maximum fall speed; the clamp sets the speed back to 4 only when its whole part is at least 4 and its fraction byte at least `$80`. Code `ImposeGravity` clamps a fall of 4 px/frame or more only when the fraction byte is at least `$80`. Code A falling Mario's gravity is `VerticalForceDown`, which `FallingSub` copies in every frame. Each area's entrance sets it to $28 (40/256 px/frame²), and only a jump changes it, to its row's falling gravity, so a walk-off before any jump falls at $28 and one after a jump at that jump's falling gravity. Verified	The movement and gravity routines (`MoveObjectHorizontally` through `ImposeGravity`) are Super Mario Bros.'s, instruction for instruction: `ImposeGravity` and `MoveDropPlatform` are byte for byte the same, and the other seven differ only in the addresses of their calls and jumps. Code	Super Mario Bros. 2 keeps speeds as 4.4 fixed point; `ApplyPlayerPhysics` takes whole pixels from a speed's upper nibble. Code `PlayerGravity` adds the character's lighter gravity on any frame the jump button is held and the heavier one otherwise, and adds none once a fall has reached `$39` (3.5625 px/frame). The last add can carry the fall past that, up to `$3F` (3.9375 px/frame) under a gravity of `$07`. Two branches come first: sunk in quicksand (`QuicksandDepth` 2 or more), the routine adds `GravityQuicksand`, `$08` for all four (quicksand), at any speed; and while the Princess floats, it sets her speed outright from `FloatingYVelocity` and adds nothing (float). Code	Super Mario Bros. 3 keeps Mario's speeds as 4.4 fixed point: the high nibble is whole pixels per frame, the low nibble sixteenths. `Player_ApplyYVelocity` caps the fall at `FALLRATE_MAX`, `$40`, before the frame's gravity is added, so the move never exceeds 4 px a frame. Measured in Mesen from power-on as Raccoon Mario at World 1-1's start, a jump's fall levels off at 4 px a frame. Verified In the air `Player_JumpFlyFlutter` adds 5 to Mario's vertical speed each update, or 1 while A is held and he rises faster than `$20`; a Micro-Goomba stuck to him keeps the 5 even with A held. A tail wag can then overwrite the speed (flight-time, tail-wag), and a Tanooki statue skips this routine (tanooki-statue). Measured in Mesen from power-on as Raccoon Mario at World 1-1's start, a jump with A held gains 1 a frame until the rise slows to `-$20`, then 5 a frame; with A pressed for one frame it gains 5 a frame from the frame after the take-off. Verified	uses		Each frame `CODE_00D928` adds 3/16 px/frame to Mario's vertical speed while A or B is held and 6/16 otherwise, rising or falling. Code Gravity's routine cuts a downward speed above `$40` (4 px/frame) back to `$40` before adding gravity, so Mario falls at most 70/16 px/frame, or 67/16 holding the button. Verified Each frame the player routine moves Mario by his current speed (`CODE_00DC2D`), then handles a jump press (`CODE_00D5F2`), then adds gravity (`CODE_00D7E4`), so the press frame doesn't lift him and his first step up is the take-off speed plus held gravity. Code `CODE_00DC4F` adds a speed's low nybble to a subpixel byte and its high nybble, sign-extended, plus the carry to the 16-bit position, so Mario moves in sixteenths of a pixel. Code		Super Mario 64 keeps Mario's speeds as floats in world units per frame: `perform_air_step` moves him a quarter of his velocity in each of four quarter steps. A frame waits for two vertical blanks in `display_and_vsync`, so on an NTSC console the game runs at most 30 frames a second. Code Mario's usual gravity subtracts 4 units/frame from his vertical speed each frame, down to a fastest fall of −75. The long jump and the slide kick use 2 instead, with the same cap. Code		In the doldecomp decompilation of Super Mario Sunshine, most of Mario's movement constants are named parameters (`TParamRT`), each built with a default in the code, in sets that each name a file, such as `/Mario/Jump.prm`. `TParams::load`, in a file configure.py marks as matching the game's code, reads the set's file from the scene's `/map/params` folder if it is there and from the `params` archive if not, and a record whose key and name match a parameter replaces that parameter's default; the rest keep theirs. The values the game plays with are data on the disc, which the atlas hasn't read, so the numbers in these claims are the code's defaults. The jump set's gravity, `mGravity`, defaults to 0.8. In the jumping states, `jumpProcess` in the decompilers' Player code, which doesn't yet match, moves Mario by a quarter of his velocity in one step per update. Then `fallProcess` subtracts `mGravity` from his vertical speed, except in a dive (the dive set's own gravity, with a cap of its own), in a spin jump's descent (`mSpinJumpGravity`, default 0.6), and when a release cuts the rise (sms/jump); in every case it then caps the fall at −75. Super Mario 64 also moves Mario a quarter of his velocity at a time, but in four steps a frame (sm64/units). Code notes
Ground pound									Z in the air starts a ground pound. Mario stops dead and, on each of the first 10 frames (t counting from 0), rises 20 − 2t units, 110 in all, each rise skipped unless his new height plus 160 stays below the ceiling. He holds there until his spin animation ends plus 4 frames; then he falls from −50 units/frame under the usual gravity. Code
Healing item			Every eighth enemy defeated, counted as it falls off the screen, comes back as a heart 96 px above where it left; stray bullets and bosses don't count, and the count carries over deaths until the level ends. A heart adds one mark, up to the meter's length. Code
Health upgrade			A level has up to two Subspace mushrooms, each adding a mark to the life meter and refilling it. One taken stays taken, and the extra marks stay, through deaths until the level ends, a game over, or a warp, which set `PlayerHealth` to `PlayerHealth_2_HP` and `PlayerMaxHealth` to 0: a meter of two marks, both full. Code Super Mario Bros. 2's code puts a mushroom in Subspace that adds a mark to the life meter and refills it, where Doki Doki Panic's manual describes a heart. SMB2's manual names the mushroom in its item list, but its Subspace paragraph still calls it a heart that increases the life meter. Manual
Held item			Each character's stats table holds a second take-off for each kind of jump, used while carrying something. Standing, charged, and running, they are: Mario `$B0`, `$98`, `$AA`; Luigi `$D6`, `$C9`, `$D4`; Toad `$B2`, `$98`, `$AD`; the Princess `$B3`, `$98`, `$B3`. Against the empty-handed ones (mario-stats and the rest), an item lowers only the running jump: Mario's and Luigi's by `$04`, and the Princess's to her standing one; Toad's are unchanged. The same tables hold the ground caps, `$18` empty-handed for all four, and carrying `$18`, `$16`, `$1D`, and `$15` (carry-speed). Code What the player carries sets the ground cap: an enemy, a mushroom block, or a POW block uses the character's carrying speed (Mario `$18`, Luigi `$16`, Toad `$1D`, the Princess `$15`), and anything else (vegetables, shells, coins, bombs, rockets, keys, potions) the empty-handed `$18`. Sunk 4 pixels or more into quicksand, every character's cap is `$04`. B raises each by half (run-cap). Code Pulling something up, from the ground or off an enemy's or a block's top, holds a first pose for 6 frames, then steps through six more poses whose waits are the character's pick-up speeds, read from last to first: Mario's and Luigi's 7, 4, 1, 2, 4, 0, Toad's 2, 1, 1, 1, 1, 0, and the Princess's 12, 6, 2, 4, 6, 0, a wait of 0 lasting one frame. A small vegetable or dug sand takes Toad's waits whoever pulls it. Measured in Mesen (MesenCE 2.2.1) from power-on, pulling the large vegetable on the ledge in 1-1's first area, Mario and Luigi lift for 25 frames, Toad for 13, and the Princess for 37. Verified B throws what the player carries, unless it is sand from digging. A bomb, rocket, mushroom block, POW block, key, or potion needs room in the tile ahead; enemies, vegetables, shells, and coins fly at once. Those fly forward at `$30` (3 px/frame), rising at `$08` (0.5 px/frame) if the player was moving at `$08` or more and falling at `$18` if not. The others fly forward at `$30` level if the player was moving, and if standing are set down 16 px ahead, falling at `$18`. Code
Hit points			Both games start the life meter at two marks and let it grow to four. Doki Doki Panic's manual says so, as does Super Mario Bros. 2's, whose code sets health from a table of three values, two to four marks, by the number of extra marks found, and sets two marks again when a level ends, on a game over, and on a warp. Manual Super Mario Bros. 2 shrinks a character whose life meter is down to one mark. Chris Kohler's report on Kensuke Tanabe's talk says it was added because growing and shrinking was one of Mario's best-known traits. SMB2's cartridge keeps a full-size and a small tile bank for each character; Doki Doki Panic's disk has one tile file for each of its four, IMAJIN-C, LINA-C, MAMA-C, and PAPA-C, of 832 bytes. Interview
Hitbox	`BoundBoxCtrlData` gives Mario a box for touching objects from 2 to 14 px across his sprite, and 8 to 32 px down when big or 20 to 32 px crouching; small Mario's runs from 3 to 13 across and 20 to 32 down. Code Against the level, `PlayerBGCollision` tests a head point at x+8, feet at x+3 and x+12 (y+32), and sides at x+2 and x+13, at y+8 and y+24 when big and both at y+24 when small or crouching. Code `BlockBufferCollision` turns a point into a block lookup: it adds the point's offsets to Mario's position, takes the block column from X ÷ 16 and the block row from (Y & $F0) − 32, and returns the metatile stored there, with the low nybble of Mario's Y (head and feet) or X (sides) as the point's place inside its block. Code `PlayerBGCollision` runs after the frame's movement (smb1/frame-order). It first sets a grounded Mario's state to falling (2), then tests the head, then the two foot points, then the side points, the left pair before the right; the first side point that hits ends the check. Code When a foot point finds an ordinary solid block and Mario isn't moving up, `PlayerBGCollision` lands him if his Y is less than 5 px into the block's 16 px row; 5 px or more, it calls `ImpedePlayerMove` in his moving direction instead, which pushes him 1 px back unless he is already moving away, and leaves without checking his sides. Code A side point in a block calls `ImpedePlayerMove`, which moves Mario 1 px away from the block and zeroes his speed byte, unless he is already moving away; either way it clears that side's d-pad bit in `Player_CollisionBits`, which the next frame's `ImposeFriction` ANDs with the d-pad, so the next frame's friction ignores the direction into the wall. Verified While Mario moves up, `PlayerBGCollision` tests a single head point, the first of its point set (smb1/bg-points), after the frame's movement and before the feet. It acts only if his vertical speed byte is negative, the low nybble of his own Y is 4 or more, and his Y is at least `$20` (big) or `$10` (small, or big and crouching), and only if the point's metatile is nonzero and not a coin. So one block at most is hit per frame: when his head spans two blocks, the one under the point is hit and the other is ignored. Measured: big Mario under a brick that covered only his box's left part rose past it untouched. Verified When the head point finds a block in the solid ranges (smb1/head-kinds), `PlayerBGCollision` sets Mario's vertical speed byte to 1 and plays the bump sound; his position and the speed's fraction are left as they are, so the frame ends with his head inside the block and he starts down on the next. In water levels, and while `BlockBounceTimer` runs (smb1/bounce-timer), a brick or ? block gets the same speed of 1 without the sound and without being hit. Verified						`GetMarioClipping` gives Mario a box for touching sprites 12 px wide from x+2, 26 px tall from y+6 when big, and 12 px tall from y+20 when small or ducking. Code Against blocks Mario tests six points, a center, two side points, a head, and two feet at x+5 and x+11, y+32; big Mario's head point is at y+8 and small Mario's at y+16. Code `GetBlockAtPlayer` adds a point's offsets to Mario's position and reads the block holding that pixel, x ÷ 16 for the column and y with its low 4 bits cleared for the row; in a horizontal level's layer 1, every point below y `$1B0` (432 px) reads as air. Side points stop at blocks `$111`–`$16D`, and a falling foot lands on `$100`–`$16D`. Code With Mario's x in the left half of a block column (`PlayerBlockXSide` 0), collision tests his side points at x+14, and unless he's flush at x mod 16 = 2 marks him blocked on the right; in the right half (1), it tests those at x+2, flush at 13, blocked on the left. After all six points, it moves him 1 px back out of the wall and, if his speed points into the wall, zeroes its high byte but not its low byte. Verified Mario's head point (x+8, and y+8 big or y+16 small; block-points) is the fourth of collision's six points, after the center and side points and before the feet. In the air, when it is in a solid block, collision moves him down by 15 minus the point's row in the block, keeping the subpixel, so the point ends on the block's bottom row, and zeroes his vertical speed if he was rising. Gravity then acts on that frame as usual. A turn block hit this way skips the move on that frame (turn-block-hit). Verified On the ground, a head point in a solid block's upper 9 rows (0–8) ejects Mario left: collision marks him blocked on the right and zeroes his horizontal speed's high byte, and the wall push then moves him 1 px left a frame (side-push). In rows 9–15 he isn't moved. Either way it sets the top-blocked bit, and while that bit is set a jump press on the ground doesn't jump. Verified A ? block under the head point (tile `$124`, a coin, in the probe) is hit from below: it gives its contents and bounces (block-bounce), and collision then treats it as solid, moving Mario down onto its bottom row and stopping his rise on the same frame (head-hit). When the bounce timer runs out, 7 frames after the hit frame, the cell becomes a used block (`$132`), which is solid and is never hit again. Verified
Invincibility frames	A hit on big Mario sets `InjuryTimer` to 8, and enemy contact is skipped until it is back at 0. It is one of the interval timers, which `DecTimers` counts down once every 21 frames, so the window lasts 8 such ticks, 148 to 168 frames while the game's timers run. Code	A hit on big Mario sets `InjuryTimer` to 8, as in Super Mario Bros., and the timer counts down once every 21 frames with the interval timers, through the same timer loop as Super Mario Bros.'s. Code	Health is `$0F` for one mark of the life meter and `$10` more for each further mark, up to `$3F` for four. A hit takes `$10`, one mark, and sets `DamageInvulnTime` to `$7F`, during which `DamagePlayer` returns at once; the timer drops every frame. If the health left is `$10` or more, two marks or more, the hit also launches the player upward at `$C0` and sideways at four times the screen distance from the enemy. A hit on the last mark (health under `$10`) stores no health and sets no invulnerability: it turns the enemy toward the player (for the types before `Enemy_BeezoDiving`), stuns it for `$10` frames, sets the player's vertical speed to `$C0` and `PlayerStateTimer` to `$20`, and jumps to `KillPlayer`, which sets the dying state and health to 0. A dying player holds still for those 32 frames, then rises at `$C0` and falls back, gaining `$02` a frame up to `$39`, and loses a life once below the screen. Code	A hit that doesn't kill Mario, including one that only takes Kuribo's Shoe, sets `Player_FlashInv` to `$71`, and `Player_GetHurt` ignores hits while it is nonzero. `Player_Draw` counts it down each time it runs, blinking Mario in 2-tick halves. Code			`HurtMario` returns at once while `IFrameTimer` is nonzero. After the power-down animation Super Mario World sets it to `$7F`, and the timer loop counts it down on every frame the sprites aren't locked. Code
Item distribution								In the US version of Mario Kart 64, `gen_random_item` picks an item as one byte from a 100-byte row of a table, the row for the driver's current place. In Grand Prix, human players read `common_grand_prix_human_item_curve` and CPU drivers `common_grand_prix_cpu_item_curve`, and that branch reads no player count. Versus picks one of three tables by the number of players (two, three, or four), and Battle reads one row whatever the place. The slot is a random number from 0 to 100 (`random_int(100)`) plus the previous slot, a counter that held A, B, and R buttons advance, and the race frame counter, taken mod 100. Code				In the doldecomp decompilation of Mario Kart: Double Dash!!, which builds a USA debug version (`MarioClub_us`) and whose item manager, `Sato/ItemObjMgr.cpp`, does not yet match the game's code, the item pick reads byte weights from a file on the disc, `/Item/ItemSlotList.dat` (or `ItemSlotList1.dat` or `ItemSlotList2.dat`, by the race's item-slot type). The file holds lists, each with a row of weights for every place, and a Grand Prix or Versus pick reads the row for the kart's place less one. Outside LAN play, Grand Prix reads a list by engine class (150cc and Mirror share one) for human players and the next list for CPU drivers, and Versus reads one list for every driver by the number of karts, two to four. The pick adds the row's weights for nine common kinds and for the driver's own special item, draws a whole number below the total (computed), and walks the running sum. The special's weight is multiplied by 1.5 when the two riders are a default pairing (`isDefaultCharCombi`), and the special is left out when the partner holds or stocks a special item, or when it is `ItemHeart` and the kart already has one; four common kinds (`ItemThunder`, `ItemStar`, `ItemKinokoSuc`, and `ItemFlyTurtle`, which the atlas reads as the Spiny Shell) are left out when the partner holds or stocks the same kind. `startShuffle` clears the flag the code calls `_7`, and `startItemShuffleSingle` sets it when its `doShuffle` argument is true; with it set, the pick first draws among the specials alone. `setDynamicRate`, which copies the weights the pick reads, writes 0 for any kind whose `IsAbleToCreateItem` is false (a function the decompilers comment as fabricated), and in Grand Prix multiplies the CPU list's `ItemFlyTurtle` weight by 1.5 while `RivalBodyCtrl::isPlayerFirst()` is true. In Grand Prix, Mario Kart 64 instead reads one byte from a 100-slot row for the place, from a human or a CPU table, with no partner or character in the pick. Code notes In the doldecomp decompilation of Mario Kart: Double Dash!!, which builds a USA debug version (`MarioClub_us`) and whose item manager, `Sato/ItemObjMgr.cpp`, does not yet match the game's code, King Boo and Petey (character IDs 19 and 20) get an `ItemRndSpecialShuffleMgr` for their item picks, as every driver does in Balloon Battle and the battle the code calls `ESCAPE_BATTLE`; other drivers get the plain `ItemShuffleMgr`. Where the plain pick adds one special item, the driver's own, the random-special pick adds all nine specials, each weighted from the row's columns 18 to 26, counting from 0 (`slotTable[1][i + 18]` for i from 0 to 8, computed) and multiplied by 1.5 for a default pairing unless `isMiniGame()` is true, and leaves out the heart when the kart already has one. It leaves all nine out when the partner holds or stocks a special item. In Grand Prix, Mario Kart 64's pick takes only the place and whether the driver is a CPU. Code notes
Jump	A jump starts only on the frame A goes down while Mario is grounded; `InitJS` zeroes the vertical subpixel and sets the jumping state. Code `InitJS` picks one of five jump rows by take-off horizontal speed, stepping up at `$09`, `$10`, `$19`, and `$1C`. Code `PlayerYSpdData` starts a jump at −4 px/frame (rows 0–2) or −5 px/frame (rows 3–4). Code `InitMForceData` gives jump rows 0–4 a zero speed fraction, so take-off is exactly −4.00 or −5.00 px/frame. Code The press frame already moves Mario, since `PlayerPhysicsSub` starts the jump before the state dispatch runs `JumpSwimSub` and `MovePlayerVertically`. Code Swimming jumps use row 5 of the jump tables, or row 6 in a whirlpool. Code `InitJS` leaves Mario's horizontal speed alone and sets the jumping state before `X_Physics` runs, so the press frame already uses the air rules, and the take-off speed only picks the jump row. Code On landing, `PlayerBGCollision` snaps Mario's Y to a 16 px row and zeroes his vertical speed and its fraction, then sets the ground state; his horizontal speed is untouched, and the ground rules apply from the next frame. Verified Mario can jump off a wall because the foot check counts a block in the wall's side as ground. If his move into a wall puts a foot point in a wall block while he is falling and less than 5 px below a block boundary, `PlayerBGCollision` lands him there; he starts the next frame on the ground, so a fresh press of A then jumps. Code A wall jump's press has to come on a frame that starts with Mario caught on the wall's side, which is the frame after the catch and, when his foot went 1 px deeper, the frame after that too. Measured in the cartridge with big Mario, the window was one frame for a walking jump into a wall laid into World 1-1's start, two for a running hop into the level's first pipe, unedited, and one for a running hop from the bricks into World 2-1's last wall (smb1/world-2-1-wall-jump); a press on the catch frame itself, or one frame after the window, did nothing. Verified Super Mario Wiki counts Super Mario Bros.' wall jump among the glitches that resemble the later, designed Wall Jump, with "frame-perfect timing"; TASVideos' resource page explains it by the floor check running during the push out of a wall, and asks for speed above 16 (1 px/frame) toward the wall and feet meeting it at a block boundary. Wiki World 1-1's first four pipes stand at block columns 28, 38, 46, and 57, each two blocks wide, with their tops on rows 9, 8, 7, and 7, so 2, 3, 4, and 4 blocks above the floor; the fourth is the one Mario can enter. Code World 2-1 ends with a column of solid blocks two wide and ten high, at block columns 190 and 191 from the level's start, rows 1 to 10, so its top is 160 px above the floor. Two columns before it is a jumpspring (column 188); over the ground in front of that are two bricks on row 7 (columns 185 and 186, tops 64 px up) and, over the second, a hidden coin block on row 3 (top 128 px up). Verified No jump from the floor or the bricks in front of it clears World 2-1's last wall, and a wall jump from the bricks does. Measured in the cartridge with big Mario, starting from the wall's screen: after a running hop onto the bricks, a running jump from them with A held peaked 147 px above the floor, short of the wall's top at 160, and he next stood on the floor. From the floor, by arithmetic rather than a run, his highest jump's 83 px rise can't reach 160. A 4-frame hop from the bricks brought his foot to the wall's side 80 px up on the way down, at the end of frame 91; a press on frame 92 jumped him to 163 px and onto the top, and presses on frames 91 and 93 didn't jump. The level has another way up without a wall jump: the hidden coin block over the second brick, once hit, is a ledge 128 px up, and a jump from it reaches the top. Verified	The Lost Levels keeps Super Mario Bros.'s movement tables for Mario byte for byte. Take-off speeds, held and falling gravities, frictions, and top speeds all match. Code Picking Luigi copies his own gravities and frictions over Mario's: held gravity `$18`–`$22` for the five jump rows against Mario's `$1E`–`$28`, falling gravity `$3E`–`$5D` against `$60`–`$90`, and friction `$B4`, `$68`, `$A0` against `$E4`, `$98`, `$D0`. It also writes an `RTS` over the `ASL` that doubles Mario's friction when he faces away from his motion. His take-off speeds are Mario's. Each area's setup loads the chosen player's set; the axe at the end of a castle loads Mario's set and `ASL` back for the walk that follows, whoever is playing, until the next area loads the player's own again. Code	`PlayerStartJump` first checks quicksand: sunk with `QuicksandDepth` 2 or more, the player takes off at `JumpHeightQuicksand`, `$E0` for all four (quicksand), and the table is skipped. Otherwise it picks the take-off speed from the character's table by three bits: running (horizontal speed of `$08` or more), a charged crouch (`CrouchJumpTimer` at `$3C`), and holding an item. A charged jump clears the running bit. Code Measured in Mesen (MesenCE 2.2.1) from power-on, on the floor at the bottom of 1-1's first area (probes/super-mario-bros-2/movement.mjs), empty-handed Mario's jumps leave the ground at -5 standing, -5.625 running, and -6.5 px/frame from a charged crouch, and each frame adds 0.25 px/frame with A held and 0.4375 without: `MarioStats`' `$B0`, `$A6`, and `$98`, and its gravities `$04` and `$07`. With an item, see carry-stats. Verified Luigi takes off far slower but falls under a far lighter gravity. Measured in Mesen (MesenCE 2.2.1) from power-on, on the floor at the bottom of 1-1's first area, empty-handed, his jumps leave the ground at -2.625 standing, -3 running, and -3.4375 px/frame charged, and each frame adds 0.0625 px/frame with A held and 0.125 without: `LuigiStats`' `$D6`, `$D0`, and `$C9`, and its gravities `$01` and `$02`. With an item, see carry-stats. Verified Measured in Mesen (MesenCE 2.2.1) from power-on, on the floor at the bottom of 1-1's first area, empty-handed Toad's jumps leave the ground at -4.875 standing, -5.1875 running, and -6.5 px/frame charged, and fall under Mario's gravity, 0.25 px/frame a frame with A held and 0.4375 without: `ToadStats`' `$B2`, `$AD`, and `$98`, and `$04` and `$07`. With an item, see carry-stats. Verified Measured in Mesen (MesenCE 2.2.1) from power-on, on the floor at the bottom of 1-1's first area, the empty-handed Princess's jumps leave the ground at -4.8125 standing, -5.25 running, and -6.5 px/frame charged, and fall under Mario's gravity, 0.25 px/frame a frame with A held and 0.4375 without, apart from her float (float): `PrincessStats`' `$B3`, `$AC`, and `$98`, and `$04` and `$07`. With an item, see carry-stats. Verified Holding Down on the ground charges the crouch jump for 60 frames, except on a flying carpet or in quicksand. Crouched on the ground, left and right do nothing; in the air, with Down held, they still steer. Let go of Down before then and the charge is lost; let go after and it is kept until left or right is pressed or the player jumps. Code Doki Doki Panic's disk holds Super Mario Bros. 2's character stats table, 92 bytes in the same layout. Mario's, Toad's, and the Princess's 23 bytes each equal the first, second, and fourth blocks on the disk. Luigi's block, the third, differs only in its six take-off speeds, each `$02` lower in SMB2, so read as SMB2 reads them, Luigi leaves the ground 0.125 px/frame faster than the disk's block would. The four offsets before the table hold the same values, with the last two swapped. Code Both games have the charged crouch jump. Doki Doki Panic's manual says the character flashes while Down is held and then jumps about 1.5 times as high as a standing jump, and Super Mario Bros. 2's manual says the same of its power squat jump. SMB2's code charges it after 60 frames of crouching on the ground (smb2/jump-start). Manual	A jump takes off at `PLAYER_JUMP`, `-$38`, minus `Player_SpeedJumpInc` indexed by the whole part of Mario's horizontal speed: `-$38`, `-$3A`, `-$3C`, or `-$40`. Measured in Mesen from power-on as Raccoon Mario at World 1-1's start, a jump from a standstill and one at the full-meter speed `$38` take off at `-$38` and `-$40` (the first frame's speed, one more after that frame's held-A gravity). Verified A jump starts on the frame A goes down if Mario is on the ground, or in the air while `Player_AllowAirJump` is counting down. Code	A jump starts on the frame A goes down while Mario's jump status (`$C207`) is 0 and his on-ground flag (`$C20A`) is set. Unless Mario is running, the jump also sets the jump index `$C208` to 2. Code Measured in the game, a standing jump with A held moves Mario up nothing on the press frame, then 3, 3, and 2 px a frame to 24 px, then 1 px or 0 a frame to an apex of 33 px on frame 23. The fall retraces the rise in reverse, and he lands on frame 49. Verified Measured, a running jump with A held rises 4, 4, 3, 3, then 2 px a frame and peaks at 41 px on frame 25, higher than the standing jump's 33. Verified		On the ground, a fresh press of B (or X) starts Mario's jump and a fresh press of A a spin jump; `CODE_00D5F2` takes the take-off speed from `DATA_00D2BD` at an index set by his horizontal speed. Code `DATA_00D2BD` gives a normal jump −80/16 to −97/16 px/frame (`$B0`–`$9F`) and a spin jump −74/16 to −90/16 (`$B6`–`$A6`), faster for every 0.5 px/frame of horizontal speed. Code Measured in the game, a standing spin jump climbs 54.8 px with A held and 28.5 px tapped, against 64.2 and 33.3 for a normal jump. Verified The jump press sets only Mario's vertical speed and air state, then falls into the horizontal code, so the press frame already uses the air rules and his speed carries over unchanged. Verified Landing clears `PlayerInAir` during block collision, before the frame's speed update, so the landing frame already brakes or accelerates by the ground rules; the jump itself leaves the horizontal speed alone. Verified A foot point in a block's top half lands Mario unless he is moving up; `CODE_00EE11` takes the point's row within the block, and below 8 the landing subtracts it from his y, keeping the subpixel, which stands him on the block's top. In the lower half the point doesn't land him. Verified		A single jump sets Mario's vertical speed to 42 plus a quarter of his forward speed, in units per frame, and multiplies the forward speed by 0.8. Code A press while Mario lands from a jump or a fall starts a double jump, at 52 units/frame plus a quarter of his forward speed. The landing lasts 4 frames, and each of them sets `doubleJumpTimer` to 5; that timer counts down once a frame, and while it runs a press from the stop action that follows the landing still double-jumps, because `set_jump_from_landing` checks the timer and the previous action. With the stick held, the stop action turns into walking at once, and walking's previous action is the stop, so only a Mario standing still can double-jump after the 4-frame landing. Code A press while Mario lands from a double jump starts a triple jump if his forward speed is above 20 units/frame, and a single jump otherwise. With the wing cap, the press always starts a different action, the flying triple jump (`ACT_FLYING_TRIPLE_JUMP`, 82 units/frame). The triple jump takes off at 69 units/frame whatever the speed, and releasing A doesn't cut it. Code		In Super Mario Sunshine, by the decompilers' Player code, which doesn't yet match, a press that starts a jump through `changePlayerJumping` first goes to a miss jump if `isJumpMiss` is true, then to a spin jump if `considerRotateJumpStart` reads the stick's recent turning as a spin, and otherwise to the status it asks for. For the single jump, `MARIO_STATUS_JUMP`, `setStatusToJumping` sets Mario's vertical speed to 42 plus a quarter of his forward speed and multiplies the forward speed by 0.8, constants in the code rather than parameters, and the same take-off as Super Mario 64's single jump (sm64/jump-speed). On two kinds of floor, which the code tells apart only as `isThing2` and `isThing3`, the speed is replaced or added to and the jump becomes `MARIO_STATUS_FORCE_JUMP`; on Yoshi it is multiplied by the parameter `mJumpYoshiMult`, and while `isSinking()` is true both speeds are scaled by a factor from the `mGraffitoParams` set. When the new jumping status carries the bit the code calls `MARIO_STATUS_FLAG_UNK2000000` (0x2000000), as the single jump, the double jump, and the wall kick do, `setStatusToJumping` sets bit 0x100 of `unk78`, and it clears that bit for any other jumping status (other code clears it too). While that bit is set, the status has neither bit 0x1000 nor 0x20000, A isn't held, and Mario rises faster than 20, `fallProcess` multiplies his vertical speed by 0.75 on each update in place of the gravity. Super Mario 64 divides it by 4 on each frame when A isn't held and Mario rises faster than 20, if its `MARIO_UNKNOWN_08` flag is set, the action is neither intangible nor invulnerable, and the action has `ACT_FLAG_CONTROL_JUMP_HEIGHT`, the same bit, 0x02000000 (sm64/jump-release). The status numbers line up too: Sunshine's single jump is 0x2000000 \| 0x800 \| 0x080 (computed 0x2000880), and Super Mario 64's `ACT_JUMP` is 0x03000880. Code notes
Knockback			uses
Level loading		`LoadAreaPointer`, `FindAreaPointer` and `GetAreaDataAddrs` are Super Mario Bros.'s, with the area data address tables made tables of words (indexed with an ASL) where Super Mario Bros. keeps separate low and high byte tables; the tables themselves hold The Lost Levels' worlds, and `AreaDataOfsLoopback` its 12 loop points. Of the level data, only the 9-byte pipe intro area (`L_GroundArea10`) is byte for byte Super Mario Bros.'s. Code
Lock delay						When a drop is blocked, the pill moves back up and is placed in the bottle at once, so a pill resting on the stack locks at its next gravity step. Code
Long jump									Z while running starts a crouch slide, and A in its first 30 frames at a forward speed above 10 units/frame starts a long jump. It takes off at 30 units/frame up and multiplies the forward speed by 1.5, capped at 48; in the air it falls with a gravity of 2 instead of 4. Code The long jump's cap clips only a forward speed above 48. A backward (negative) speed is multiplied by 1.5 with no limit, which the decompilers' comment names as the cause of backwards long jumps (BLJs). A long jump's landing chains into another long jump on A with Z held. In the air, each frame moves the speed 0.35 toward 0, adds the stick's push (up to 1.5 along Mario's facing), and adds 2 more while it is below −16. This is the US build; the Shindou and iQue builds set a negative speed to 0 when a long jump lands. Code
Metasprites		The sprite drawing code (`DrawVine` through `DrawSpriteObject`) is Super Mario Bros.'s with these changes: `DrawPowerUp` draws every mushroom from tiles $D8, $DA, $DB and $FF where Super Mario Bros. uses $76-$79, and gives the poison mushroom, a fifth row, palette 3; `EnemyGfxHandler`'s tile table takes up $76-$79, and the handler also flips the upside-down piranha plants and colors the jumpsprings green on world numbers 2, 3 and 7; `RenderPlayerSub` plays the skid sound; `FlagpoleGfxHandler`'s score table gains the 1-up; `GetYOffscreenBits` has two of its tables' halves swapped, its instructions unchanged; `DrawBlock` uses a renumbered metatile. 12 regions, `PlayerGfxHandler` among them, differ only in their addresses, and five, `DrawSpriteObject` among them, are byte for byte the same. Code
Mode 7							The game keeps a Mode 7 angle, 0 to `$1FF` for a full turn, and an X and a Y scale, `$20` for 1.0, and turns them into the matrix with a quarter-wave sine table of 129 entries; D copies A and C is −B, a rotation scaled per axis. Code In the Reznor fight the Reznor in sprite slot 7 sets the Mode 7 center to `$80` and adds 1 to the angle each frame, wrapping at `$1FF`, so the Mode 7 wheel the four Reznors ride (the "Reznor sign" in the comments) turns once every 512 frames. Code
Multiplayer				uses
Music driver	The NMI handler calls the sound engine once a frame; its music handler steps square 2, square 1, the triangle, and the noise channel in turn, and each channel counts its note length down by 1 per frame and reads its next byte at 0. Code A song's header picks an 8-entry row of `MusicLengthLookupTbl`, and a length code of 0-7 indexes it in frames; the overworld theme's row is 54, 3, 9, 6, 18, 27, 36, 12, a quarter note of 18 frames, and the hurry-up version adds 8 to the row offset for 36, 2, 6, 4, 12, 18, 24, 8. Code A note byte is an offset into `FreqRegLookupTbl`, a table of 51 two-byte timer periods that the driver writes to the channel's timer registers; a recreation turns period $t$ into $f_{C P U} / (16 (t + 1))$ Hz on a square channel and half that on the triangle. Code A new area-music square note sets duty and volume byte `$82` and an envelope index of 8; each frame the driver writes `AreaMusicEnvData[index]` to the channel and counts the index down, so the note plays at 50% duty with volumes 0, 8, 7, 6, 5, 5, 4, 4 and then 0 until the next note. Code The noise channel plays three drum sounds, all at constant volume 12 (`$400C` = `$1C`), a short beat at period index 3, a strong beat at period index 12, and a long beat at period index 3 with a longer length-counter load (`$58` instead of `$18`). Code	SM2MAIN's music data is Super Mario Bros.'s less the victory theme: the headers lose `VictoryMusHdr` and their offsets shift by its five bytes, the residual header bytes differ, and `VictoryMusData` is gone from between the castle-clear music and the frequency tables, with two of the three unused bytes after it (the ending's music lives in `SM2DATA3`). The notes of every other song and the frequency, note-length and envelope tables after them are byte for byte the same. Code 1,299 bytes of The Lost Levels' music are Super Mario Bros.'s byte for byte: the last bytes of the music headers and the notes of every song SM2MAIN plays, from the star music (`Star_CloudMData`) through the ground music's parts, death, castle, game over, time running out, level end, underground, water and the castle-clear music (`EndOfCastleMusData`). Code					The engine's main loop waits on timer 0, set to tick every 2 ms; for each tick it adds the song's tempo byte to an 8-bit accumulator, and on a carry out it calls the routine APU_0BC0, unless a flag at audio RAM `$0388` is set. That routine wasn't read; the structure suggests it is one step of the music, which would make the tempo set the step rate. The tempo starts at `$36`, which gives 500 × 54 / 256, about 105 carries a second. Code
Palette cycling	Every 8th frame `ColorRotation` rewrites background palette 3 at `$3F0C`, putting the next of six colors, `$27`, `$27`, `$27`, `$17`, `$07`, `$17`, in its second entry, so the question blocks and coins shimmer on a 48-frame loop. Code
Piece randomizer						At the start of each level `generatePillsReserve` deals 128 pills, shared by both players. Each pill is one of 9 color pairs, found by adding a random 0 to 15 to the previous pill's index and subtracting 9 until it fits; the game reads the reserve in a loop, so the same 128 pills come round again. Code Because the 16 random values wrap at 9, steps of 0 to 6 from the previous pill's index each come from two values and steps of 7 and 8 from one, so the same pill follows itself with chance 2/16, where a uniform pick would give 1/9. Code A level holds (level + 1) × 4 viruses; for player 1 levels past 20 count as 20, while player 2's count is uncapped. The count of viruses still to add runs down, and its low two bits pick the color (0 yellow, 1 red, 2 blue, 3 a color from a 16-entry table), so each run of four from a multiple of 4 goes yellow, random, blue, red. Each virus goes at a random height no higher than the level allows and a random column, moving on to the next free cell, and takes another color if one of its own lies two cells away in a straight line. Code
Power-up		A poison mushroom comes out of a block of its own kind, and stays a poison mushroom whatever the player's size, where an ordinary mushroom block gives a fire flower to a big or fiery player. It slides along like a mushroom. Touching it removes it and runs the injury routine: a small player dies, and a big or fiery one drops straight to small, with the blink that follows any hit. During that blink, or while a star's invincibility lasts, it is removed and does nothing. Code The poison mushroom is drawn from the same four tiles as the mushroom and the 1-up mushroom (`$D8`, `$DA`, `$DB`, `$FF`) in sprite palette 3, where the mushroom uses palette 2 and the 1-up palette 1. Like them it keeps its colors, where the fire flower and the star cycle theirs. Code		uses
Projectile				uses
Raster effects	uses			In the N-Spade card game three IRQs, at scanlines 32, 84, and 136, each give one row its own horizontal scroll and set the next IRQ 52 lines on, and a fourth restores the status bar, so three bands of the screen slide independently. Code
Rocket start								In the US version of Mario Kart 64, the start boost's window opens when Lakitu's countdown finishes the animation after its second light sound, before the green-light sound. A press of A that begins within 8 counts of the race frame counter from the first update the window is open (20 in Time Trials) sets `START_BOOST_TRIGGER`, and letting go of A before the start clears it. The trigger gives the kart the Mushroom's effect and the same boost timer, 80. Once the window is open, a kart that revs to 90% of its top speed without the trigger gets `START_SPINOUT_TRIGGER`, the spin-out for holding the gas. Code
Rubber-band AI								In the US version of Mario Kart 64, `CPU_FAST_EFFECT`, which the decompilers comment as the "CPU Rubberbanding flag", raises a CPU driver's forward force: while it's set, a term in that force moves toward 380 by half the gap each update, and once it's cleared the term falls toward 0 by a tenth of the gap. `regulate_cpu_speed` sets the flag on a CPU driver below its target speed when the pacing check `func_800088D8` returns true, and clears it otherwise. Code
Running	Horizontal speeds are 4.4 fixed point, whole pixels and sixteenths per frame; `MoveObjectHorizontally` shifts the sixteenths into the subpixel byte. Code Mario's top ground speed is `$18` walking and `$28` running (B held). Code Each frame `PlayerCtrlRoutine` splits the d-pad bits, runs the jump check, `X_Physics`, and the state's routine (which changes the speed, then moves Mario), sets `Player_MovingDir` from the speed's sign, and only then runs `PlayerBGCollision`, which lands him. Code `Player_X_MoveForce` is a fraction byte below `Player_X_Speed`, so acceleration works in 1/256 of a sixteenth (1/4096 px/frame) and carries into the speed byte, but `MoveObjectHorizontally` moves Mario by the speed byte alone. Code `FrictionData` gives Mario's acceleration and braking per frame: `$E4` running, `$98` walking, and `$D0` walking while still fast from a run, in 1/4096 px/frame. Code On the ground `X_Physics` uses the running row (cap `$28`, acceleration `$E4`) while B and the direction Mario moves in are held and for the 9 frames after B goes up; otherwise the walking row (cap `$18`, `$98`, or `$D0` while `RunningSpeed` is set or his speed is `$21` or more). Code `X_Physics` doubles the acceleration whenever Mario faces away from the direction he moves, so a turn brakes at `$130`, `$1A0`, or `$1C8` a frame. Code When a held direction carries the speed to its cap or past it, `ImposeFriction` sets the speed byte to the cap, so a speed above the cap drops to it in one frame. Code With neither Left nor Right held on the ground, `ImposeFriction` brakes Mario by the frame's acceleration toward zero and stops once the speed byte reaches 0, leaving the fraction byte as it is. Code On the ground, `GetPlayerAnimSpeed` zeroes Mario's speed and turns his moving direction to his facing one when a button other than A is held, the d-pad's Left/Right bits differ from his moving direction, and his speed is below `$0B`. Code On the ground `OnGroundStateSub` turns Mario toward a held Left or Right before friction runs; the jumping and falling routines change his facing only while he swims. Code On the ground, Down with Left or Right clears both, so Mario neither walks nor crouches and brakes as if the d-pad were released; big Mario holding Down alone crouches. Code Measured from a standstill in World 1-1, Mario reaches `$18` on frame 40 walking and `$28` on frame 45 running, and let go at those speeds he stops in 40 and 49 frames. Verified A frame-by-frame model of `X_Physics`, `GetPlayerAnimSpeed`, and `ImposeFriction` reproduces Mario's speed bytes, facing, moving direction, and run timer on every frame of 17 probed traces, walking, running, skidding, crouching, and jumping. Verified	uses	Holding B raises the top speed by half: running right with nothing carried, from `$18` to `$24` (1.5 to 2.25 px/frame). Measured in Mesen (MesenCE 2.2.1) from power-on, on the floor at the bottom of 1-1's first area, all four characters run right at 1.5 px/frame and, with B, 2.25 px/frame. Verified The run button's half is added to whatever cap applies, the carrying speed (carry-speed) or quicksand's `$04` as well as the unladen `$18`. To the left the cap is negative, and halving it with the carry set rounds it away from zero: a cap of `$EB` to the left becomes `$E0`, where `$15` to the right becomes `$1F`. Code On ordinary ground, holding right adds `$02` to the speed each frame, so a character reaches walking speed, `$18` (1.5 px/frame), 12 frames from a standstill; with neither direction held the ground takes `$03` a frame off the speed, to zero. Measured in Mesen (MesenCE 2.2.1) from power-on, on the floor at the bottom of 1-1's first area, each character reaches 1.5 px/frame in 12 frames from a standstill; letting go of everything at 2.25 px/frame drops the speed to the 1.5 cap at once, and friction stops the character 8 frames later. Verified Left and right push at the same `$02` a frame in the air, and with neither held the air keeps the speed. Any push resets a crouch jump's charge (crouch-charge). Crouched on the ground, left and right do nothing, and the ground's friction slows the player. On ice the push comes on one frame in four and the friction on one in sixteen. Code Super Mario Bros. 2's manual gives B a third use, running faster, and its code raises the top speed by half while B is held (smb2/run-cap). Doki Doki Panic's manual gives B only lifting and throwing. Both manuals say every character runs at the same speed. Manual	Off uphill slopes, Mario's speed tops out at `$18` walking, `$28` holding B, and `$38` while the P-meter is full; walking uphill, the cap comes from `Player_UphillSpeedVals` instead. Measured in Mesen from power-on as Raccoon Mario at World 1-1's start, holding Right levels off at `$18`, and Right with B at `$28` until the meter fills, then at `$38`. Verified Below the top speed, a held direction adds the suit's entry in `Player_XAccelMain` plus the carry from adding its `Player_XAccelPseudoFrac` entry to `Counter_Wiggly`, on the ground and in the air. Each frame `Counter_Wiggly` becomes its high nibble minus `$90`, so it steps through all 16 high nibbles: computed, an `$E0` fraction carries on 14 of every 16 frames, so every suit but the Frog gains 1 on 14 frames in 16, about 0.88 a frame, while the Frog's entry adds 2 every frame. Pressing against the motion adds 2 the other way for every suit. With no direction held on the ground, or over the top speed on the ground, the friction entry takes 1 on each frame without a carry: 14 in 16 for Super, Fire, and Raccoon Mario (`$20`), 10 in 16 for small, Tanooki, and Hammer Mario (`$60`), and every frame for the Frog (`$00`). Over the top speed in the air nothing changes it, and slippery ground uses other entries. Measured in Mesen from power-on as Raccoon Mario at World 1-1's start, holding Right from rest gains 1 on 14 of any 16 frames and reaches `$28` (with B) on the 46th. Verified			Measured on flat ground, Mario's top speed is 20/16 px/frame walking, 36/16 holding Y, and 47/16 to 49/16 once the P-meter is full, near `DATA_00D535`'s `$14`, `$24`, and `$30`. Verified Each frame the player routine moves Mario by last frame's speed, runs block collision (which lands him), then `CODE_00D5F2` updates his horizontal speed, so a speed change first moves him on the next frame and a landing frame already uses the ground rules. Verified `PlayerXSpeed` is 16 bits, a high byte in 1/16 px/frame and a low byte below it, so acceleration works in 1/4096 px/frame; position moves by the high byte alone. Code On flat ground `MarioAccel_` speeds Mario toward a held direction by `$0180` (1.5/16 px/frame) a frame, with or without Y; holding against his motion uses its turning row, `$0280` (2.5/16) walking and `$0500` (5/16) with Y. Code `DATA_00D535` caps Mario's ground speed at `$14` walking and `$24` holding Y, and at `$30` while the P-meter is full and charging. Code `CODE_00D742` compares only the speed's high byte with the cap; below it the frame adds the full acceleration, unclamped, and at or past it the frame applies friction instead, so Mario's top speed cycles around the cap. Code With no direction held on the ground, `CODE_00D76B` moves Mario's speed 1/16 px/frame a frame toward the slope's target speed, 0 on flat ground, and stops exactly on it. Code Mario turns at the turning row's rate while his speed's high byte is nonzero and points against the held direction; the step is not clamped at zero, so the last one overshoots into the new direction. Code A held Left or Right turns Mario to face it on the same frame, on the ground and in the air, unless he carries an item. Code On flat ground, Down makes Mario duck, and a ducking Mario ignores Left and Right, so friction alone slows him; the duck flag is set only on the ground, so a duck jump stays ducked and steers. Code Measured from a standstill on Yoshi's Island 1, Mario first passes `$14` on frame 14 walking and reaches `$24` on frame 24 holding Y; with Y held his P-meter fills 56 frames later. Verified		On the ground the stick's tilt sets a target speed: `intendedMag` is 32 times the square of the tilt's fraction of full. Below the target Mario gains 1.1 − speed/43 units/frame each frame (1.1 from a standstill); above it, on level ground, he loses 1. The target is at most 32, or 24 on slow floors, and the speed is capped at 48. Code
Sampled sound							The sound engine runs on the SPC700. Its set-instrument command (`$DA`) reads a 5-byte entry from a table in audio RAM at `$5F46` and writes the first four bytes to the voice's DSP registers, the sample number (SRCN), ADSR1, ADSR2, and GAIN, and keeps the fifth as a pitch multiplier, so every instrument is a recorded sample with an envelope. Code
Slope sliding				Holding only Down on a slope starts a slide, except in the Frog or Hammer suit (bit 1 of `PowerUp_Ability`) or Kuribo's Shoe. Each update the slope's push is added to the slide speed, which is capped at `$40` and then loses 1 toward 0, so it tops out at `$3F`. Code
Springboard		Landing on a springboard sets both the held and the falling gravity to `$70` and a launch speed of −7 px a frame (`$F9`). Over the spring's four steps it carries the player down 2 px a step, then up 2 px a step, and on the last step it launches them. A press of A, not held from before, in the second step or later raises the launch to −12 px a frame (`$F4`), or to −32 px a frame (`$E0`) on the green springboards of world numbers 2, 3, and 7, which the letter worlds share as B and C, since the test reads the world number without the letter-world flag. With both gravities at `$70`, the bounce rises and falls under one pull whether A is held or not, for Mario and Luigi alike. While the game's timers are stopped the spring waits. Code
Sprite flicker	Every unpaused frame `SpriteShuffler` adds one of three amounts, `$58`, `$48`, or `$38` in turn, to each object's OAM offset at or above `$28`, wrapping within `$28`-`$FF`, so the objects' sprites change OAM slots each frame and a ninth sprite on a line drops out on different frames. Code
Stage select				uses
Status bar split	Each frame the NMI handler waits for the sprite 0 flag to clear, spins until the sprite 0 hit, waits a short loop for horizontal blank, and only then writes the level's scroll, so the status bar above the hit stays still. Code The game sets sprite 0 to OAM bytes `$18`, `$FF`, `$23`, `$58`, so tile `$FF` sits at Y `$18` and X `$58` behind the background in sprite palette 3. Code			Each frame the NMI handler loads the MMC3's scanline counter with 192, and the IRQ it raises points the PPU at the status bar's nametable rows and swaps in the status bar's tile banks. Code			In the Mode 7 boss rooms other than Bowser's, the NMI sets Mode 1 for the status bar at the top of the frame, and an interrupt at the line where the bar ends switches to Mode 7 and writes the Mode 7 layer's scroll; the bar ends at line 36, or 45 in Morton's and Roy's rooms. Bowser's room skips the status bar interrupt and goes straight to Mode 7. Code
Timed guard										In the US version of Paper Mario, an enemy's hit on Mario is guarded when A was pressed shortly before it lands. `calc_enemy_damage_target` calls `check_block_input(BUTTON_A)` when Mario's debuff is none or one numbered at or after `STATUS_KEY_POISON` (so not dizzy, paralyzed, asleep, frozen, or stopped), he isn't stone, and the attack isn't `DAMAGE_TYPE_UNBLOCKABLE`; with the Berserker badge, `rand_int(1)` decides instead. The check returns false before action commands are learned and in demo battles, and returns a guard with no press in the tutorial battle while the mode is `AC_MODE_TUTORIAL_BLOCK`. It guards if a fresh press of A is in the last 3 entries of the battle's pressed-button buffer, which `btl_update` writes once per battle update (5 entries with a Dodge Master badge, when the partner isn't acting), unless A was also pressed in the 10 entries before those. A guard takes 1 from Mario's damage, plus 1 for each Damage Dodge badge equipped. A guard by the partner, checked the same way when the partner isn't stone or knocked out, sets the damage to 0. Code
Triple jump									uses		In Super Mario Sunshine, by the decompilers' Player code, which doesn't yet match, the double jump, the backflip (`MARIO_STATUS_BACK_JUMP`), the spin jump, and the jumps the code calls `trample` and `wireJumping` all land in `MARIO_STATUS_SEC_JUMP_SLIP`. Its `jumpSlipEvents` counts updates and ends the landing on the 16th, before reading A, so a press on one of the first 15 (computed) goes to `changePlayerJumping`, which can still turn it into a miss or spin jump (sms/jump): the triple jump, `MARIO_STATUS_ULTRA_JUMP`, if the forward speed is at least the parameter `mTriJumpEnableSp` (default 20), and a single jump if not. The single jump and the wall kick land in `MARIO_STATUS_JUMP_SLIP` instead, where a press makes a double jump only at a forward speed of at least `mSecJumpEnableSp` (default 20). The triple jump takes off at `mUltraJumpForce` plus `mUltraJumpSpeedMult` times the forward speed (defaults 70 and 0.25) and multiplies the forward speed by `mUltraJumpXZMult` (default 0.8); its status lacks the bit that lets a release cut the rise. Super Mario 64's triple jump starts from the double jump's 4-frame landing at a forward speed above 20, takes off at 69 whatever the speed, and can't be cut either (sm64/triple-jump, sm64/jump-release). Code notes
Variable jump height	While a jump rises with A held, gravity is `JumpMForceData`'s `$20`, `$20`, `$1E`, `$28`, `$28` subpixels/frame² for rows 0–4. Code After the switch, gravity is `FallMForceData`'s `$70`, `$70`, `$60`, `$90`, `$90` subpixels/frame² for rows 0–4. Code In rows 0–1, the standing and slow jumps, held gravity is `$20`/256 = 0.125 px/frame². Code In rows 0–1, falling gravity is `$70`/256 = 0.4375 px/frame². Code In rows 0–1, falling gravity (`$70`) is 3.5 times held gravity (`$20`). Code `JumpSwimSub` swaps in falling gravity, never back, once speed is zero or downward, or once the jump has risen at least `DiffToHaltJump` on a frame when A is not held, or was not held the frame before. Code `InitJS` sets `DiffToHaltJump` to 1, so a release switches gravity only once Mario has risen at least 1 pixel. Code Measured in the game on flat ground, the apexes, tapped/held, are 24/66 px standing, 27/71 px walking (row 2), and 29/83 px running (row 4). Verified Measured in the game with A held, Mario's jumps peak at 66 px standing, 71 px walking, and 83 px running. Verified	uses	uses	Measured in Mesen from power-on as Raccoon Mario standing at World 1-1's start, a jump with A held rises 71 px, about four and a half tiles, and a jump with A pressed for one frame rises 21 px. Both follow from the take-off (jump-speed) and the two gravities (gravity). Verified	Letting go of A while Mario rises moves the jump index to `$0F`, near where the table's 1 px steps begin, unless the index is already at `$0F` or past it. Measured, a 1-frame tap reaches 10 px, 5 frames 19 px, 10 frames 29 px, and 15 frames or more the full 33. Verified		Measured in the game, Mario climbs 64.2 px held and 33.3 px tapped from a standstill, 72.6 px held at walking speed, 81.6 px held running, and 85.3 or 91.1 px held sprinting. Verified Measured in the game from a standstill, Mario's climb grows with each frame B is held, from 33.3 px tapped to 64.2 px at 28 frames or more. Verified		Releasing A cuts a jump short: on a frame with A up and the rise above 20 units/frame, `apply_gravity` divides the vertical speed by 4 instead of subtracting gravity. Only actions flagged `ACT_FLAG_CONTROL_JUMP_HEIGHT` do this, among them the single and double jumps and the wall kick; the triple jump, backflip, and side flip lack the flag and keep their full height. The check also needs a flag that every airborne action sets and bouncing off an enemy clears. Code		uses
Wall jump	uses								A jump that hits a wall at a forward speed above 16 turns Mario around and holds him in `ACT_AIR_HIT_WALL`. A press on its first 2 frames kicks off the wall. On the 3rd he bonks away, `wallKickTimer` is set to 5 and counts down once a frame, and A still kicks while it is nonzero: 7 frames in all. The kick takes off at 62 units/frame up and at least 24 forward. Code		In Super Mario Sunshine, by the decompilers' Player code, which doesn't yet match, when `jumpProcess` reports a wall to `jumpingBasic` during a jump, Mario is knocked back if his forward speed is above the parameter `mClashSpeed` (default 50) outside the wire roll jump, stops on Yoshi, stops on a wall marked `isNoWallJump`, and catches a fence (`isFence`). Otherwise, at a forward speed above 16, he turns about (after `playerRefrection`) and, against a wall, holds on in `MARIO_STATUS_WALL_SLIDE`. There `stayWall` adds 1 to the status timer each update, capped at 60, and 1 more while it is below 20, so he hangs still for 10 updates and then slides down at half the timer: −10.5 on the 11th update, then 0.5 faster each update to −30 (computed). An A press on any update on the wall kicks: `startJumpWall` turns him about and enters `MARIO_STATUS_WALL_JUMP`, whose take-off in `setStatusToJumping` is 62 up and 24 forward, constants in the code; the 52 that `startJumpWall` writes first is overwritten. Landing or losing the wall ends the hold. Super Mario 64 kicks at the same 62 up and at least 24 forward, and its `act_air_hit_wall` also writes a 52 that the kick's take-off overwrites, but it holds Mario only 2 frames and then bonks him away, with A still working for 5 more: 7 frames in all (sm64/wall-kick). With no wall to hold, Sunshine bonks him the way Super Mario 64 does: back down at 38 or faster, and at −8 if faster than 8. Code notes
Water physics				uses
Wind		Wind blows the player to the right. An area object turns it on (`WindOn`) and another off (`WindOff`), and the setup that runs at the start of every area clears it. While it is on, and only in ground-type areas (underground, water, and castle areas stay calm), it moves the player 1 px right on every fourth frame while the frame counter is below 128 and on every second frame from 128 to 255: 96 px every 256 frames, 0.375 px a frame on average. The push is added to the position after the player's own move, on the ground and in the air but not while climbing, so it adds to a rightward speed and takes from a leftward one whatever the speed, and the screen scrolls with it. Its leaves and sound play while it is on, in every type of area. None of it runs until the game has loaded a disk file beyond worlds 1 to 4 (worlds 5 to 8, the ending, or worlds A to D): before that, `FileListNumber` is 0 and both calls are skipped. Code

Code lineage

From	To	Match	Bytes	What
Super Mario Bros. `area-parser-task-handler` … `get-block-buffer-addr`	Super Mario Bros.: The Lost Levels `area-parser-task-handler` … `get-block-buffer-addr`	changed	2,422	The area parser and its object builders (`AreaParserTaskHandler` through `GetBlockBufferAddr`) are Super Mario Bros.'s, with most changes in the metatile numbers they write, which shift with the renumbered metatiles (bridges, flagpole, coins, bricks, cannons, stairs, blocks, water pipe). Beyond those: the object jump table gains entries, the wind on and off commands among them, so three offsets into it change; `ScrollLockObject_Warp` picks the warp zone's destination by world, level and area; the third ledge style uses metatiles $8A-$8C and draws no stem, where Super Mario Bros.'s mushroom ledge uses $19-$1B with a stem (and `RenderUnderPart` drops its stem checks); the vertical pipes place a piranha plant through a shared `SetupPiranhaPlant`, with no exception for world 1-1; `Jumpspring` places nothing when no enemy slot is free. `IncrementColumnPos`, `AlterAreaAttributes`, `KillEnemies` and the object position helpers are byte for byte the same.
Super Mario Bros. `chr-background`	Super Mario Bros.: The Lost Levels `chr-background`	changed	3,200	Background tiles `$24`-`$EB` are Super Mario Bros.'s but for 65 of their 200: `$28`, `$29`, `$2B`-`$2D`, `$30`-`$3C`, `$45`, `$47`, `$4B`, `$4C`, `$4E`-`$52`, `$5D`, `$5E`, `$6B`-`$76`, `$80`, `$81`, `$9B`-`$9E`, `$A0`, `$A1`, `$A9`, `$AA`, `$AF`, `$B4`-`$BD`, `$C0`, `$C1` and `$CF` differ.
Super Mario Bros. `chr-font`	Super Mario Bros.: The Lost Levels `chr-font`	rewritten	576	The font, background tiles `$00`-`$23` (the digits and A to Z), keeps Super Mario Bros.'s layout, so `GameText` spells with the same numbers, but every one of its 36 tiles differs from Super Mario Bros.'s.
Super Mario Bros. `chr-sprites-objects`	Super Mario Bros.: The Lost Levels `chr-sprites`	changed	2,816	Sprite tiles `$50`-`$FF` are Super Mario Bros.'s but for 15: `$5B`, `$76`-`$7B`, `$85`, `$86`, `$D8`, `$DA`, `$DB` and `$FD`-`$FF` differ, among them `$76`-`$79`, Super Mario Bros.'s mushroom, which The Lost Levels' enemy table now draws, and the mushrooms' new tiles.
Super Mario Bros. `chr-sprites-player`	Super Mario Bros.: The Lost Levels `chr-sprites`	identical	1,280	The player's 80 sprite tiles, `$00`-`$4F` of the sprite pattern table, are Super Mario Bros.'s byte for byte.
Super Mario Bros. `draw-vine` … `draw-sprite-object`	Super Mario Bros.: The Lost Levels `draw-vine` … `draw-sprite-object`	changed	3,800	The sprite drawing code (`DrawVine` through `DrawSpriteObject`) is Super Mario Bros.'s with these changes: `DrawPowerUp` draws every mushroom from tiles $D8, $DA, $DB and $FF where Super Mario Bros. uses $76-$79, and gives the poison mushroom, a fifth row, palette 3; `EnemyGfxHandler`'s tile table takes up $76-$79, and the handler also flips the upside-down piranha plants and colors the jumpsprings green on world numbers 2, 3 and 7; `RenderPlayerSub` plays the skid sound; `FlagpoleGfxHandler`'s score table gains the 1-up; `GetYOffscreenBits` has two of its tables' halves swapped, its instructions unchanged; `DrawBlock` uses a renumbered metatile. 12 regions, `PlayerGfxHandler` among them, differ only in their addresses, and five, `DrawSpriteObject` among them, are byte for byte the same.
Super Mario Bros. `enemies-and-loops-core` … `init-jump-gp-troopa`	Super Mario Bros.: The Lost Levels `enemies-and-loops-core` … `init-jump-gp-troopa`	changed	2,033	Enemy spawning and set-up (`EnemiesAndLoopsCore` through `InitJumpGPTroopa`) are Super Mario Bros.'s with these changes: `ProcLoopCommand` reads 12 loop entries where Super Mario Bros. reads 11, and takes each loop's number of checks from a new `MultiLoopCount` table where Super Mario Bros. special-cases world 7; `ProcessEnemyData` skips a check in world 9 and gives one enemy code a piranha plant set-up; `InitHammerBro` checks the world; `LakituAndSpinyHandler` brings Lakitu back once `LakituReappearTimer` reaches 3, where Super Mario Bros. waits until it reaches 7, and brings him back lower on the screen in worlds 7 to 9 and A to D; `InitBowser` first erases any other Bowser; `InitPiranhaPlant` patches the plant's palette and pipe distance, green in worlds 1 to 3 and red from world 4 and in A to D; `InitJumpGPTroopa` starts the jumping paratroopa at x speed $F4 where Super Mario Bros. uses $F8. Of its 27 regions, 15 differ only in their addresses and 5 are byte for byte the same.
Super Mario Bros. `fireball-enemy-collision` … `block-buffer-collision`	Super Mario Bros.: The Lost Levels `fireball-enemy-collision` … `block-buffer-collision`	changed	3,511	The collision code (`FireballEnemyCollision` through `BlockBufferCollision`) is Super Mario Bros.'s with the upside-down piranha plant, the poison mushroom and the renumbered metatiles added: the fireball, enemy, background and stomp checks treat the upside-down plant like a piranha plant; `HandlePowerUpCollision` injures the player on power-up type 4; `InjurePlayer` also does nothing while the star's `StarInvincibleTimer` runs; `HandlePECollisions` checks for the cannon's Bullet Bill before the piranha plants and Podoboo, where Super Mario Bros. checks it after them; `PlayerEnemyCollision` decides a stomp with LDY, DEY, BPL on the vertical speed where Super Mario Bros. uses BMI and BNE (the two disagree only at speed $80); every stomp bounces the player through a new `SetBounce`, at vertical speed $FA, or $F8 off red paratroopas and flying green paratroopas, where Super Mario Bros. sets $FD after a stomp that defeats an enemy and $FC after one that demotes a paratroopa or knocks an enemy into its shell; `HandleClimbing` gives a life for grabbing the flagpole when the coin tally's digits and the timer's last digit match; `HandlePipeEntry` sends the player to the warp zone's one destination whichever pipe they take, where Super Mario Bros. picks by the pipe's x position; `HandleCoinMetatile`'s axe restores Mario's physics; `ChkForLandJumpSpring` sets `VerticalForceDown` to $70 as well as `VerticalForce`; `PlayerHammerCollision` also skips while the player is off screen; `HandleEToBGCollision` bounces a power-up on a bumped block without stunning it and never demotes a piranha plant; `CheckPlayerVertical` drops its test of how far down the screen the player is; one bounding box grows from $14 to $16. The platform collisions, `LandEnemyProperly`, the side checks and `BlockBufferCollision` differ only in their addresses, and three regions, `PlayerCollisionCore` among them, are byte for byte the same.
Super Mario Bros. `floatey-numbers-routine` … `reset-screen-timer`	Super Mario Bros.: The Lost Levels `floatey-numbers-routine` … `reset-screen-timer`	changed	910	The score numbers, the screen setup tasks, the status bar and the game's text (`FloateyNumbersRoutine` through `ResetScreenTimer`) are Super Mario Bros.'s with these changes: `GetPlayerColors` no longer picks a palette row by `CurrentPlayer` (Super Mario Bros.'s table has a row for Luigi); `WriteBottomStatusLine` goes through a new `GetWorldNumForDisplay`, which shows worlds A to D as letters; `DisplayIntermediate` blanks the screen after the world and lives screen in world 9, and `DisplayTimeUp` writes its text and resets the screen timer itself where Super Mario Bros. jumps into `DisplayIntermediate`; `ClearBuffersDrawIcon`'s title-screen part moves to the title code; the screen task list gains `DemoReset`; `GameText` drops the two-player and Luigi texts and adds CONTINUE and RETRY to the game-over screen. `InitScreen`, `SetupIntermediate`, `GetAreaPalette`, `GetAlternatePalette1`, `WriteTopStatusLine`, `AreaParserTaskControl` and `ResetScreenTimer` keep every instruction, with only addresses changed.
Super Mario Bros. `game-core-routine` … `get-screen-position`	Super Mario Bros.: The Lost Levels `game-core-routine` … `get-screen-position`	changed	363	`GameCoreRoutine` and `ScrollHandler` are Super Mario Bros.'s with three changes: the game mode's task list gains `GameModeDiskRoutines` at its head and the core no longer reads the current player's saved joypad bits; each frame of play calls `SimulateWind` once a disk file beyond worlds 1 to 4 is loaded; `ScrollHandler` waits for the status bar's timer IRQ before it scrolls and keeps the name table in `NameTableSelect`, where Super Mario Bros. sets it in its PPU control mirror. `GetScreenPosition` is byte for byte the same.
Super Mario Bros. `game-menu-routine`	Super Mario Bros.: The Lost Levels `game-menu-routine` … `demo-engine`	changed	261	`GameMenuRoutine` and `DemoEngine` are Super Mario Bros.'s menu and demo, rewritten in part: the menu drops the one- or two-player choice and the world select, and starts the game at world 1, or at world A when A is held and the game has been beaten 8 times; Select switches between Mario and Luigi; the demo plays new button presses and durations through the same code.
Super Mario Bros. `game-routines` … `impose-friction`	Super Mario Bros.: The Lost Levels `game-routines` … `impose-friction`	changed	1,518	The player's control and movement code (`GameRoutines` through `ImposeFriction`) is Super Mario Bros.'s, instruction for instruction in 14 of its 19 regions, with these changes: `OnGroundStateSub` and the jump and swim code move the player through a new `JmpMove`, which lets the wind push them (`BlowPlayerAround`) once a disk file beyond worlds 1 to 4 is loaded; `PlayerPhysicsSub`'s friction table moves up to follow the fall forces, inside the 17 bytes that `LoadPhysicsData` overwrites with Mario's or Luigi's set; `PlayerEndLevel` queues the level-end music once, guarded by a new `FlagpoleMusicFlag`, where Super Mario Bros. queues it whenever `ScrollLock` is set, and sets the hidden 1-up's flag on 10 coins in any world, where Super Mario Bros. reads a per-world table, and starts world 9 over after 9-4; `PlayerDeath` shares one RTS. The entrances, pipes, size change, injury blink, flagpole slide, falling, climbing, animation speed and `ImposeFriction` differ only in their addresses.
Super Mario Bros. `init-bal-platform` … `run-fireworks`	Super Mario Bros.: The Lost Levels `init-bal-platform` … `run-fireworks`	changed	2,798	The platforms' set-up, the enemy object loop, the enemies' movers, Bowser and the fireworks (`InitBalPlatform` through `RunFireworks`, 32 regions) are Super Mario Bros.'s instruction for instruction, with two changes: the enemy movers' jump table (`EnemyMovementSubs`) sends enemy 4, the upside-down piranha plant, to the new `MoveUpsideDownPiranhaP`, where Super Mario Bros. has `MoveNormalEnemy`; `MoveSwimmingCheepCheep` adds $40 to a swimming Cheep Cheep's vertical fraction each frame where Super Mario Bros. adds $20. Three of the regions are byte for byte the same, and the rest differ only in the addresses of their calls, jumps and tables.
Super Mario Bros. `jump-engine` … `update-screen`	Super Mario Bros.: The Lost Levels `jump-engine` … `update-screen`	relocated	240	`JumpEngine`, `InitializeNameTables`, `ReadJoypads` and `UpdateScreen` are Super Mario Bros.'s, instruction for instruction: `JumpEngine` is byte for byte the same, and the other three differ only in the addresses of their calls, jumps and tables.
Super Mario Bros. `load-area-pointer` … `world-addr-offsets`	Super Mario Bros.: The Lost Levels `load-area-pointer` … `area-data-addrs`	changed	456	`LoadAreaPointer`, `FindAreaPointer` and `GetAreaDataAddrs` are Super Mario Bros.'s, with the area data address tables made tables of words (indexed with an ASL) where Super Mario Bros. keeps separate low and high byte tables; the tables themselves hold The Lost Levels' worlds, and `AreaDataOfsLoopback` its 12 loop points. Of the level data, only the 9-byte pipe intro area (`L_GroundArea10`) is byte for byte Super Mario Bros.'s.
Super Mario Bros. `move-object-horizontally` … `impose-gravity`	Super Mario Bros.: The Lost Levels `move-object-horizontally` … `impose-gravity`	relocated	325	The movement and gravity routines (`MoveObjectHorizontally` through `ImposeGravity`) are Super Mario Bros.'s, instruction for instruction: `ImposeGravity` and `MoveDropPlatform` are byte for byte the same, and the other seven differ only in the addresses of their calls and jumps.
Super Mario Bros. `music-handler`	Super Mario Bros.: The Lost Levels `alt-sound-engine`	rewritten	856	`AlternateSoundEngine`, the ending's sound engine in `SM2DATA3`, is a rewrite of Super Mario Bros.'s `MusicHandler` that keeps its note and length code: it has no event or area music buffers and no time-running-out handling, steps through a list of patterns with `PatternNumber`, reading each pattern's header from `MusicHeaderData`, has its own pause and silence code, and plays the ending's music on the disk system's wavetable channel as well as the square, triangle and noise channels, with its own waveform, envelope and modulation tables.
Super Mario Bros. `music-header-data` … `star-cloud-m-data`	Super Mario Bros.: The Lost Levels `music-header-data` … `star-cloud-m-data`	changed	1,713	SM2MAIN's music data is Super Mario Bros.'s less the victory theme: the headers lose `VictoryMusHdr` and their offsets shift by its five bytes, the residual header bytes differ, and `VictoryMusData` is gone from between the castle-clear music and the frequency tables, with two of the three unused bytes after it (the ending's music lives in `SM2DATA3`). The notes of every other song and the frequency, note-length and envelope tables after them are byte for byte the same.
Super Mario Bros. `print-status-bar-numbers` … `run-game-over`	Super Mario Bros.: The Lost Levels `print-status-bar-numbers` … `run-game-over`	changed	846	The status bar numbers, game setup, lives and game over (`PrintStatusBarNumbers` through `RunGameOver`) are Super Mario Bros.'s with a new `GameOverSubs` dispatch among them and these changes: the status bar's digit tables lose the second player's entries; `UpdateTopScore` checks one score where Super Mario Bros. checks two; `DigitsMathRoutine` drops a compare with zero before its BEQ; `DefaultSprOffsets` loses the sprite 0 data; `InitializeArea` loads the player's physics (`LoadPhysicsData`) and sets the secondary hard mode flag from 4-4 on and in all of worlds A to D (`HardWorldFlag`), where Super Mario Bros. sets it from 5-3 on or once the primary hard mode flag is set; `SecondaryGameSetup` sets the name table and switches on the status bar's IRQ split, where Super Mario Bros. sets the second player's lives and switches on the sprite 0 check; `InitializeMemory` also spares $0100-$0108; `PlayerLoseLife` reads its own halfway pages and no longer swaps players; `RunGameOver` opens the continue-or-retry menu (or, in world 9, ends the game) where Super Mario Bros. ends the game on Start or when the screen timer runs out and then hands over to the other player if they have lives left. `GetAreaMusic` and `Entrance_GameTimerSetup` keep every instruction, though the level timer's digits moved from $07F8 to $07EC.
Super Mario Bros. `proc-fireballs` … `vine-object-handler`	Super Mario Bros.: The Lost Levels `proc-fireballs` … `vine-object-handler`	changed	1,013	Fireballs, the level timer and the stage objects (`ProcFireballs` through `VineObjectHandler`) are Super Mario Bros.'s with these changes: `RunGameTimer` tests the player's height with BPL instead of BCS and points at the timer digits' new place; `WarpZoneObject` no longer counts up `WarpZoneControl`; `FlagpoleRoutine` gives a life for the new sixth flagpole score; `JumpspringHandler` launches with the green springs' force on world numbers 2, 3 and 7; `VineObjectHandler` erases the vine and its metatiles once it goes off the left of the screen. `ProcFireballs` and `ProcessWhirlpools` differ only in their addresses, and `SetupVine` is byte for byte the same.
Super Mario Bros. `process-cannons` … `block-obj-mt-updater`	Super Mario Bros.: The Lost Levels `process-cannons` … `block-obj-mt-updater`	changed	1,358	Cannons, hammers, coins, power-ups and blocks (`ProcessCannons` through `BlockObjMT_Updater`) are Super Mario Bros.'s with the poison mushroom added and one player: `BumpBlock`'s contents table gains poison mushroom blocks and `MushFlowerBlock` gains `PoisonMushBlock`, which sets power-up type 4; `PowerUpObjHandler` walks types 4 and 5 like a mushroom; `BlockBumpedChk` checks 19 block metatiles where Super Mario Bros. checks 14; `GiveOneCoin` and `AddToScore` use fixed offsets where Super Mario Bros. indexes by `CurrentPlayer`; the head-collision and coin checks use the renumbered metatiles. `SetupPowerUp` is byte for byte Super Mario Bros.'s, though the poison mushroom now passes through it, and so are `InitBlock_XY_Pos` and `SpawnBrickChunks`; the cannons, hammers, jumping coins, brick shatter and bouncing blocks differ only in their addresses.
Super Mario Bros. `render-area-graphics` … `water-palette-data`	Super Mario Bros.: The Lost Levels `render-area-graphics` … `water-palette-data`	changed	1,266	The background renderer, the metatile tables and the area palettes (`RenderAreaGraphics` through the palette data) are Super Mario Bros.'s with the metatiles renumbered: The Lost Levels inserts new metatiles, so `ReplaceBlockMetatile` compares against shifted numbers ($56, $4F, $5C and $50 for Super Mario Bros.'s $58, $51, $5D and $52), and `MetatileGraphics_Low` moves some entries and adds others. The palette data region also holds two new messages. `RenderAttributeTables` is byte for byte the same, and `RenderAreaGraphics` and `ColorRotatePalette` differ only in their addresses.
Super Mario Bros. `run-star-flag-obj` … `offscreen-bounds-check`	Super Mario Bros.: The Lost Levels `run-star-flag-obj` … `offscreen-bounds-check`	changed	1,047	`RunStarFlagObj` through `OffscreenBoundsCheck` are Super Mario Bros.'s with these changes: `RunStarFlagObj` sets off fireworks when the timer's last digit matches the coin tally's, where Super Mario Bros. matches the timer's last digit against 1, 3 and 6, and adds its points to the one player's score; `MovePiranhaPlant` moves red piranha plants (the patched palette) every frame; `BalancePlatform` leaves a platform alone when its partner is no balance platform; `OffscreenBoundsCheck` treats upside-down piranha plants like upright ones. `FirebarSpin` is byte for byte the same, and the moving platforms differ only in their addresses.
Super Mario Bros. `sound-engine` … `music-handler`	Super Mario Bros.: The Lost Levels `sound-engine` … `music-handler`	changed	1,705	The sound engine (`SoundEngine` through `MusicHandler`) is Super Mario Bros.'s with two new sounds in the noise handler: the skid, played on the triangle channel from `SkidSfxFreqData`, and the wind, played from `WindFreqEnvData`; both tables sit after the square 2 handler. `SoundEngine`, `Dump_Squ1_Regs`, `Square1SfxHandler` and `MusicHandler` differ only in their addresses.
Super Mario Bros. `star-cloud-m-data`	Super Mario Bros.: The Lost Levels `star-cloud-m-data`	identical	1,299	1,299 bytes of The Lost Levels' music are Super Mario Bros.'s byte for byte: the last bytes of the music headers and the notes of every song SM2MAIN plays, from the star music (`Star_CloudMData`) through the ground music's parts, death, castle, game over, time running out, level end, underground, water and the castle-clear music (`EndOfCastleMusData`).
Super Mario Bros. `start` … `move-all-sprites-offscreen`	Super Mario Bros.: The Lost Levels `start` … `move-all-sprites-offscreen`	changed	664	The Lost Levels' boot, NMI and pause code (`Start` through `MoveAllSpritesOffscreen`) is Super Mario Bros.'s with these changes: `Start` sets mirroring through the disk drive's control register, keeps `WorldNumber` across the reset and sets the BIOS's IRQ flag; the NMI arms the drive's timer IRQ to split the status bar from the level, where Super Mario Bros. waits for the sprite 0 hit, and its VRAM address table is one table of 31 words where Super Mario Bros. has low and high byte tables of 19; `PauseRoutine` allows a pause in game-mode task 4 instead of 3, the game mode's task list having gained a disk task at its head. `SpriteShuffler` and `MoveAllSpritesOffscreen` are byte for byte the same, and the operating-mode dispatch differs only in its addresses.
Super Mario Bros. `victory-mode` … `print-victory-messages`	Super Mario Bros.: The Lost Levels `victory-mode` … `print-victory-messages`	changed	357	The castle victory sequence (`VictoryMode` through `PrintVictoryMessages`) is Super Mario Bros.'s with these changes: on world 8, which world D also uses, `VictoryMode` runs a second task list that loads the ending from disk; `SetupVictoryMode` also sets the world's bit in `CompletedWorlds` and queues the castle-clear music; `PrintVictoryMessages` loses Super Mario Bros.'s world 8 branch and its victory music, and gains `EndCastleAward`, which counts the remaining time into points. `DrawTitleScreen`, which sits in the middle, shrinks to a few instructions that queue a layout held in the program, where Super Mario Bros. copies it out of CHR ROM. `PlayerVictoryWalk` keeps every instruction; only its addresses and one branch's distance differ.

References

^Nintendo dates the release of Super Mario Bros. to 13 September 1985.InterviewIwata Asks, SMB 25th, Vol. 2 p. 1 · Iwata Asks, SMB 25th, Vol. 5 p. 1 · Nintendo, Company Historyrevised
How we know
This September 13th marked the 25th anniversary of the release of the game Super Mario Bros.
Vol. 2, p. 1, opening · archived copy ↗
A side-scrolling action game released for the Family Computer System (Famicom) and the Nintendo Entertainment System (NES) in September 1985.
Vol. 5, p. 1, note 1 · archived copy ↗
Started selling the Super Mario Bros. game software for the Nintendo Entertainment System.
1985 · archived copy ↗
The quote matches our archived copy.
Revised after a check by a second AI model, 2026-10-26.
In the claim ledger
^Miyamoto says he set out to make something like his arcade Mario Bros. (1983), which didn't scroll and had a black background, but scrolling, bright, and with bigger characters. Scrolling cost Mario Bros.' simultaneous two-player play.InterviewIwata Asks, SMB 25th, Vol. 5 p. 3revised
How we know
About two years before Super Mario Bros., I made the arcade version of Mario Bros., but the screen didn't scroll, the background was black, and it was sort of plain. … So I decided to test out something like Mario Bros., but which scrolled, had a bright background, and had bigger characters moving around. … I wanted the screen to scroll, so at that point, I gave up on a two-player game. … Two people could enjoy playing Mario Bros., but it didn't scroll sideways.
Vol. 5, p. 3, The Grand Culmination · archived copy ↗
The quote matches our archived copy.
Revised after a check by a second AI model, 2026-10-26.
In the claim ledger
^The game drew on Nintendo's earlier ones. Its specification lists refinements of Donkey Kong's slopes, lifts, conveyor belts, and ladders, Donkey Kong Jr.'s ropes, logs, and springs, and Mario Bros.' enemies, frozen platforms, and POW Blocks. Iwata says the scrolling came from Excitebike and the large characters from Devil World, and Nakago that SRD's makers of Donkey Kong Jr.'s springs brought them in.InterviewIwata Asks, SMB 25th, Vol. 5 p. 3
How we know
Add refinements focusing on Donkey Kong's slopes, lifts, conveyor belts and ladders; Donkey Kong Jr.'s ropes, logs and springs; and Mario Bros.'s enemy attacks, enemy movement, frozen platforms and POW Blocks. … you brought in the partial scrolling technology from Excitebike, which allowed you to scroll part of the screen, and the two-character mode technology from Devil World, which allowed characters twice the size of those in Mario Bros. … Right. It was a combination of elements from previous games. … the SRD members who had made, for example, the Springs in Donkey Kong Jr.12, were also participating in the Super Mario Bros. project, so they brought that straight in.
Vol. 5, p. 3, The Grand Culmination · archived copy ↗
The quote matches our archived copy.
Checked by a second AI model, 2026-10-26.
In the claim ledger

Sources

Primary

Iwata, Satoru and Nintendo Co., Ltd. 2010. “Iwata Asks: Super Mario Bros. 25th Anniversary, Vol. 2, p. 1 (Bringing Video Games Home).” Iwata Asks, Wii, Super Mario Bros. 25th Anniversary, Vol. 2, p. 1. Nintendo Co., Ltd. original · archived · licence, all uses
Iwata, Satoru and Nintendo Co., Ltd. 2010. “Iwata Asks: Super Mario Bros. 25th Anniversary, Vol. 5, p. 1 (Using the D-pad to Jump).” Iwata Asks, Wii, Super Mario Bros. 25th Anniversary, Vol. 5, p. 1. Nintendo Co., Ltd. original · archived · licence, all uses
Co., Nintendo and Ltd. 2026. “Corporate Information: Company History (Nintendo).” original · archived · licence, all uses
Iwata, Satoru and Nintendo Co., Ltd. 2010. “Iwata Asks: Super Mario Bros. 25th Anniversary, Vol. 5, p. 3 (The Grand Culmination).” Iwata Asks, Wii, Super Mario Bros. 25th Anniversary, Vol. 5, p. 3. Nintendo Co., Ltd. original · archived · licence, all uses