Series · part of Mega Man

Mega Man (classic series)

The original Mega Man series, begun on the NES in 1987.

Mega Man let the player take on six Robot Masters in any order, each one beaten giving up its weapon^1,2. Mega Man 2 kept both ideas and made each weapon a weakness of another boss³, and retrospectives credit them with the series’ long run⁴.

#How he moves, game by game

Each NES game sets Mega Man’s speed outright instead of building it up⁵, but the numbers and their timing change from game to game. Mega Man 2 keeps the first game’s speeds and shortens its first step from 9 frames to 7⁶. Mega Man 3 trades the slow step for a short pause, adds the slide, and ends a jump differently when A is let go⁷. Mega Man 4 takes off at 5 px/frame and slides longer⁸, and Mega Man 5 moves the same way on open floor, differing only at the end of a slide and in where he meets walls and ceilings⁹. Mega Man 6 takes off faster still¹⁰, and pressing A in its slide ends the slide instead of jumping¹¹.

Games

Mechanics

Mechanic	Mega Man 1987	Mega Man 2 1988	Mega Man 3 1990	Mega Man 4 1991	Mega Man 5 1992	Mega Man 6 1993
Air control	Direct	Direct	Direct			Direct
Boss weakness		Boss table	Every enemy
Charge shot		None		Tiers on release	Tiers on release	Tiers on release
Climbing						Vine or ladder
Coyote time		None
Destructible terrain						Breakable tiles
Flight						Held height
Gravity	One gravity	One gravity	One gravity			One gravity
Ground slide		None	Timed	Timed	Timed	Timed
Hitbox		Box
Invincibility frames	Frame timer	Frame timer	Frame timer			Frame timer
Jump	One speed	One speed	One speed	One speed	One speed	One speed
Knockback	Fixed shove	Fixed shove	Fixed shove	Fixed shove	Fixed shove	Fixed shove
Palette cycling		Palette sets
Password and battery save		Password				uses
Running	Stepped	Stepped	Stepped			Stepped
Sprite flicker		Alternating order
Status bar split		Sprite overlay
Variable jump height	Release cap	Release cap	Release cap	Release cap	Release cap	Release cap
Weapon energy		Per weapon	Per weapon
Cooperative multitasking						uses
Stage select						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	Mega Man 1987	Mega Man 2 1988	Mega Man 3 1990	Mega Man 4 1991	Mega Man 5 1992	Mega Man 6 1993
Air control	In the air the jumping animation isn't in the speed lookup's table, so each frame sets Mega Man's speed to 1.3125 px/frame (`$01`.`$50`) toward a held Left or Right and to 0 with neither; a direction pressed fresh in the air first sets the first step's animation, so that one frame moves 0.125 px/frame. Verified	Each airborne frame, `_run_megaman_jumping` zeroes Mega Man's horizontal speed, then sets it to the jumping state's 1.3125 px/frame (`$01`.`$50`) toward a held Left or Right. Code Measured in the game, Mega Man moves 1.3125 px/frame in the air, turns around on the frame the other direction is pressed, and stops on the frame the d-pad is let go. Verified	uses	Every frame in the air the d-pad alone sets where Mega Man moves: the air routine copies the held Left or Right into his direction and moves him by his X speed that way, 1.30 px/frame, and with neither held he doesn't move. He turns at once, and nothing carries over from the ground. Code	Every frame in the air the d-pad alone sets where Mega Man moves: the air routine copies the held Left or Right into his direction and moves him by his X speed that way, 1.30 px/frame, and with neither held he doesn't move. He turns at once, and nothing carries over from the ground. Code	In the air the d-pad sets his horizontal speed from the same table at `$8BEA` each frame, 1.30 px/frame or 0, and clears any carried momentum, except when his surface (`$A7`) is `$15`: then the air loop runs the momentum routine code_388B0F instead, and the carried speed stays (momentum-surfaces). On a ladder, Up or Down moves him along it at the same 1.30 px/frame. Code
Area transition				Mega Man 4's first boss door routine follows Mega Man 3's `close_boss_door` step for step: the door sound, then four 16x16 blocks of tiles and attributes through the same buffer, one every 4 frames. Mega Man 4 runs it from the fixed bank, with the stage's bank mapped at $A000, and reads the door's addresses and tiles from fixed places in that bank ($B570-$B57B), where Mega Man 3 indexes tables in its door bank by the door's number. Code Mega Man 4's second boss door routine follows Mega Man 3's `open_boss_door` the same way, with the same changes: it runs from the fixed bank and reads its door's data from $B57C-$B587 in the stage's bank. Code
Boot sequence					Mega Man 5's reset begins with Mega Man 4's first 98 bytes, byte for byte at the same address ($FE00-$FE61): the interrupt, sound, and rendering shutdown, the wait through four vblanks, the PPU address precharge, the RAM clear, the sound queue's empty markers, and the PPU mask shadow. From the mapper setup on, the two differ. Code
Boss weakness		Each weapon has a 14-byte table with one damage value per boss, in the order of `zcurrent_boss`: 0 makes the boss immune, a negative value refills its health, and other values are subtracted, doubled when `zdifficulty` is 0. Metal Blade's byte for Metal Man is 14 (`$0E`), so 14 damage, or 28 when doubled, and 0 for Air Man and Quick Man; the Mega Buster's bytes for the Robot Masters are 1 or 2; Atomic Fire refills Heat Man. Code	Mega Man 3 indexes each weapon's 256-byte damage table by the target's main routine id, one table for regular enemies and bosses alike, where Mega Man 2 gives each weapon a separate 14-entry boss table. In the Spark Shock table the entry for routine id `$C1` is 7, and `$58` marks targets the shock freezes instead of damaging. That `$C1` is Magnet Man is the disassembly's labeling, not checked here. Code
Charge shot		Mega Man 2's Mega Buster has no charge. It fires only on the frame B goes down, with a free shot slot. Code		A B press fires a normal shot and sets the charge counter to 1; each frame B stays held in a state below 4 the counter rises by 1, looping from 100 back to 92. On release, a counter under 32 (`$20`) fires nothing more, 32 or more fires a half-charged shot, and 92 (`$5C`) or more a full one. Code	Mega Man 5 moves Mega Man 4's charge thresholds. On release its counter `$38` fires a normal shot from 16 (`$10`), a half-charged one from 40 (`$28`), and a full one from 80 (`$50`), and nothing under 16; Mega Man 4's counter, which starts at 1 on the press, fires nothing under 32, a half charge from 32, and a full one from 92. So the full charge needs a lower count and the half charge a higher one. Code	Mega Man 6's buster fires a normal shot on the press of B, which sets the charge counter `$9E` to 0; each later frame with B held adds 1, and on release the counter fires a half-charged shot from 36 (`$24`) and a full one from 90 (`$5A`, kept in `$06AB`), and nothing under 36. Between games these are counts, not frames: Mega Man 5's counter, whose start isn't traced, fires its half charge from 40 and its full one from 80, and Mega Man 4's, which starts at 1 on the press, from 32 and 92. Code With the Power adaptor (`$9B` 2) the charge counter gains 2 a frame and caps at 60 (`$3C`), so a half-strength punch comes from 18 frames held and a full one from 30 (computed). Each punch (shot types `$0C`, `$0E`, `$0F` by tier) holds him in a 12-frame pose that keeps the charge off (`$9E` = `$FF`). Code
CHR RAM		Mega Man 2's `_object_tiles_update` is the loop Mega Man enters at `_init_object_tiles`, which copies the tile buffer to CHR RAM, with its RAM at new addresses. Mega Man 2 drops the test in front of it and the `_object_tiles_update_yellow_devil` path, which writes two bytes at each of several PPU addresses, a row ($20) apart. Code
Climbing						uses
Controller reading		Mega Man 2's `_joy` is Mega Man's, line for line; only the two button bytes it writes moved in zero page, from $14 and $18 to $23 and $27. Code	Both games strobe the controllers and merge each port's two data bits, but Mega Man 3's routine is new code. Mega Man 2's `_joy` reads one pad after the other and leaves the newly pressed buttons to the frame wait that calls it; Mega Man 3's `read_controllers` reads both pads in one loop, works out the new presses itself, and clears the d-pad when opposite directions are held together. Code	Mega Man 4's controller read, which works out the new presses and cancels opposite directions, is Mega Man 3's `read_controllers`, byte for byte. Code	Mega Man 5's controller read is Mega Man 4's, byte for byte, with one addition: before it returns, it zeroes controller 2's new presses and held buttons ($15 and $17). Code
Cooperative multitasking						Mega Man 6 runs its objects, Mega Man included, as coroutines. Each frame code_3FE41C counts the slots from 22 down to 0 and calls each live one at its resume address (`$0413`/`$042A`); a script yields by calling code_3FE468, which pops its own return address into that pointer and moves to the next slot, so the script resumes after the call the next frame. Mega Man's movement (slot 0) is written as loops around that call, each loop ending the frame through code_388E95. Code
Coyote time	Every frame that finds a floor under him sets Mega Man's vertical speed to `$FF`.`$40`, −0.75 px/frame, with no gravity after it, so each grounded frame's vertical move takes him 0.75 px down and tests x − 7 and x + 7 on the row under his feet; ground there puts him back on it with the Y fraction zeroed, and none starts a fall. Verified Mega Man first counts as airborne on the frame whose move takes both floor points off the ledge; that frame still moves him at the ground animation's speed, drops him 0.75 px, and leaves him falling at 1 px/frame in the jumping animation, so his feet are 0, 1, 3, 4, 6, 8, and 10 px below the ledge on the walk-off frame and the six after. Verified Mega Man gets no grace window after leaving a ledge; `_run_megaman_on_stage` reads a fresh A press only on the branch where the frame's fall test found ground, either the map's floor or an object he stands on (`_no_damage_collision`). Verified	Mega Man gets no grace window after leaving a ledge; a grounded state that finds no floor switches to the jumping state, which looks for a press only on the frame it lands. Verified On the ground Mega Man keeps a vertical speed of −0.25 px/frame, the gravity applied after each landing's reset, so every grounded frame's vertical move takes him 0.25 px down and tests x − 7 and x + 7 on the row under his feet; ground there puts him back on it with the Y fraction zeroed, and none sends him to the jumping state. Verified Mega Man first counts as airborne on the frame whose move takes both floor points off the ledge; that frame still moves him at the ground state's speed, drops him 0.25 px, and leaves him in the jumping state falling at 0.5 px/frame, so his feet are 0, 0, 1, 2, 3, 5, and 7 px below the ledge on the walk-off frame and the six after. Verified	A grounded frame tests the floor before it moves Mega Man: if no floor point under his last position is solid, he falls 0.25 px, takes the jumping animation and the airborne state, and that frame's horizontal move is the air move, 1.30 px/frame toward a held direction or none. No grace period follows: only the ground state reads a jump press, and it runs only on frames that found a floor. Code	Because the ground state tests the floor before it moves him, Mega Man walks one frame past the edge before he falls: the frame whose move takes all three floor points off a ledge still counts as grounded, and on the next the floor test finds nothing after a 1 px drop, so he leaves the ground falling 1.25 px/frame and that frame moves him by the air's rules. His feet are then 1, 2, 3, 5, 7, and 9 px below the ledge on that frame and the five after (computed). Code Mega Man 4 gives no grace jump off a ledge. The ground state reads A only after the air routine reports him standing, and the air state never reads it, so a press on the frame the floor test first fails, or on any later frame of the fall, doesn't jump. Code	Because the ground state runs the air routine before it moves him, Mega Man walks one frame past the edge before he falls: the frame whose move takes all three floor points off a ledge still counts as grounded, and on the next the floor test finds nothing after a 1 px drop, so the air routine puts him in the air state falling at 1.25 px/frame and moves him by the air's rules that frame. A press on that frame or any later one in the fall doesn't jump, since only the ground state reads A, after the air routine reports him standing. Code	Walking or standing off a ledge, Mega Man 6 stays in his ground loop while the whole byte of his vertical speed is 0: gravity's 0.25 px/frame a frame moves him down 0.25, 0.5, 0.75, and 1 px on the first four frames over the gap, and through the 2nd to 4th a fresh A press still jumps. After the 4th the loop finds the whole byte at 1 and enters the air loop with the fraction set to `$CC`, so he falls at 2.05 px/frame the next frame. Measured in Mesen from power-on, walking right off the ledge at X 160 near the start of Tomahawk Man's stage, he fell 0.25, 0.5, 0.75, and 1 px in the walking state, then 2.05 px/frame in the air; a press of A on the 4th frame over the gap jumped at the full take-off speed, and one on the 5th didn't. Verified
Destructible terrain						uses
Enemy explosion		Mega Man 2's death explosion takes its twelve pieces' x and y speeds and facing flags from five 12-byte tables identical to Mega Man's explosion tables. The code around them is new: Mega Man's `_create_explosion_object` sets up one piece per call, and Mega Man 2's `_create_explosion` loops over all twelve. Code
Enemy spawning			Mega Man 3's `check_new_enemies` is the enemy half of Mega Man 2's `_find_objects`, instruction for instruction, with new RAM and table addresses: both take the screen's left and right edges, then on the side the screen moves toward spawn each placement that comes into range and on the other side move a second cursor past placements left behind. Mega Man 3 drops Mega Man 2's matching walk over a separate item list and the switch to the stage bank around it. The spawn routine each calls starts the same way, skipping a placement already in a slot and taking a free one, and then differs: Mega Man 2 fills the slot from per-type tables in its fixed bank, and Mega Man 3 skips a placement marked defeated and copies the type's properties from bank 0. Code	Mega Man 4's enemy spawn engine is Mega Man 3's `check_new_enemies` instruction for instruction, moved from bank 26 at $9C00 to bank 56 at $8000; only the addresses of the stage's placement tables and one zero-page variable ($2E in Mega Man 3, $2F in Mega Man 4) differ. Code	Mega Man 5's spawn engine walks its stage's spawn list ahead of and behind the camera with Mega Man 4's code, instruction for instruction; only the addresses differ: the stage's placement tables, the two list cursors ($9E and $9F in Mega Man 4, $AD and $AE in Mega Man 5), the scroll direction flag ($2F, $AC), and the four window temporaries, two bytes higher. Code Mega Man 5's routine that spawns an enemy from a spawn list entry follows Mega Man 4's step for step: the same checks for a live copy and the no-respawn bitmap, and the same slot fill from the entry's position and the parameter tables for its code, with the tables and temporaries at other addresses. It changes two things: it keeps the spawn code in the object's $0510 byte, which Mega Man 4 clears, and it masks bit 7 off the flags parameter and, when that bit is clear, ends by calling `entity_facing_to_flags`. Code
Enemy targeting			Mega Man 3's `divide_8bit` is Mega Man 2's `_divide_mod` with its zero-page operands one byte lower ($00-$03 for $01-$04). Its 16-bit division is Mega Man 2's `_divide_fraction` with its RAM moved and two changes: Mega Man 3 saves and restores X around the loop, and stores the low byte of each successful subtraction back in the remainder ($01), where Mega Man 2 writes it to $09, outside its shift chain. Code	Mega Man 4's 8-bit and 16-bit division routines, used to aim enemies, are Mega Man 3's `divide_8bit` and its 16-bit version, byte for byte (103 bytes), at $FC14 in its fixed bank where Mega Man 3 has them at $FCEB. Code	Mega Man 5's routines for an object's distance to the player on each axis, and the direction to him in 16 steps, are Mega Man 4's, with two changes. It adds two routines that measure the same two distances to another slot's object. And its direction routine starts by setting Y to 0, the player's slot, and falls into the copy of slot Y's position, where Mega Man 4 has a separate entry that copies the player's position and jumps on. The rest is byte for byte, except the address of the 48-byte direction table, which is the same in both and follows the code directly in Mega Man 5. Code Mega Man 5's 8-bit and 16-bit division routines are Mega Man 4's, which are Mega Man 3's, byte for byte (103 bytes), at $F207 in its fixed bank. Code
Flight						With the Jet adaptor (`$9B` 1), holding A in the air while not rising and with jet energy left starts the jet. It slows his fall by 1/8 px/frame each frame until he would rise, holds him still for 10 frames, then lifts him from 2 px/frame, faster each frame, and holds him at 84 px (`$54`) above where he stopped; the d-pad steers him at 1 px/frame. Letting go of A, or running out of energy, drops him back into the fall. Code The jet's energy `$9C` drains by 1 every 4 frames the jet runs, and the jet stops when it goes below 0, so a full meter of 20 steps (0 to 19) lasts 80 frames (computed). It refills by 1 every other frame up to 19, from empty in 40 frames (computed), while the jet's frame counter `$9D` is 0, which landing sets, and the buster is the weapon in hand. Code
Forced blanking				Mega Man 4's routine that fills a name table and its attributes with one value is Mega Man 3's `fill_nametable`, byte for byte. Code Mega Man 4's four routines after its name table buffer flush, two that reset or set bits of PPUCTRL and two that turn rendering off and on, are Mega Man 3's `disable_nmi`, `dead_code_enable_nmi`, `rendering_off`, and `rendering_on` instruction for instruction; only the zero-page counter the last two step differs ($EE in Mega Man 3, $EA in Mega Man 4). Code	Mega Man 5's routine that fills a name table and its attributes with one value is Mega Man 4's, byte for byte; Mega Man 5 follows it with routines that clear the sprite buffer and the object slots. Code
Game loop		Both games' stage loops run a frame of play and wait for the NMI, but Mega Man 2's is new code: it calls its own routines in its own order, opens the menu on Start with no Select pause, and waits an extra frame now and then in water. Its region also starts the stage before the loop. Code	Both games' NMI handlers copy the sprites by DMA, write the queued screen and palette updates, set the scroll, and run the sound driver, but Mega Man 3's handler is new code. Mega Man 2's offsets the scroll for the Mecha Dragon and puts the sound off when the NMI interrupts a bank switch; Mega Man 3's also loads the MMC3's scanline counter for the frame's split-screen interrupt and picks the interrupt handler for the screen mode. Code	Mega Man 4's cooperative task scheduler, with its routines to start, kill, and yield tasks, is Mega Man 3's `task_scheduler` instruction for instruction; it sits 5 bytes lower, and only its jump and call addresses differ. Code	Mega Man 5's cooperative task scheduler is Mega Man 4's instruction for instruction; it sits 6 bytes higher, and only its jump and call addresses differ. Code
Gravity	Each airborne frame takes `$40`/256 = 0.25 px/frame off Mega Man's upward speed, and a fall is capped at 12 px/frame (`$F4`). Code `_objects_vertical_moving` first moves Mega Man by his 8.8 fixed-point vertical speed, positive up (his Y, which runs down the screen, subtracts it), and then, on a frame that meets no floor or ceiling, takes gravity off the speed. Code Mega Man's fall is capped at 12 px/frame (`$F4`). Code	Gravity takes `$40`/256 = 0.25 px/frame from Mega Man's upward speed each frame out of water (`$1E`/256 in water). Code `_check_object_vertical_move` first moves Mega Man by his 8.8 fixed-point speed, positive up, and then subtracts gravity. Code Falling speed is capped at 12 px/frame (`$F4`). Code	Mega Man 3 raises the take-off speed from Mega Man 2's `$04`.`$DF` (4.87 px/frame) to `$04`.`$E5` (4.89) and keeps gravity at `$40`, but caps a fall at 7 px/frame (`$F9`) where Mega Man 2 allows 12 (`$F4`). Code Mega Man 3 moves Mega Man vertically before horizontally. Every frame on the ground or in the air first runs the airborne routine: a rise without A held is cut (release-cut), then `move_vertical_gravity` moves him by his vertical speed, takes gravity from it, and tests the floor under a fall or the ceiling over a rise. Only then does the frame's horizontal move run: the air move if he is still airborne, the ground state's move if he stood on a floor. Code Gravity takes `$40`/256 = 0.25 px/frame from Mega Man's upward speed every frame out of water, after the frame's vertical move. Code A fall is capped at 7 px/frame: when gravity takes the speed's whole byte below `$F9`, apply_gravity sets it to `$F9`.`$00`. Code Both games move an object each frame by a speed with a fraction and change its Y speed by gravity, but Mega Man 3's movers are new code that Mega Man and the enemies share. Mega Man 2's enemy routine, left undecoded by its disassembly, checks the object's hits, moves it by its Y speed, subtracts gravity from that speed when a flag bit asks for it, moves it by its X speed in the way it faces, and removes it once it leaves the screen; walls and floors are a separate routine, and Mega Man moves with his own code. Mega Man 3's `move_vertical_gravity` and `move_right_collide` serve slot 0, the player, and every enemy alike, and run the tile check inside each move, snapping the object to the floor, ceiling, or wall it reaches. Code	Mega Man 4's routines that move an entity by its speed without checking tiles, and apply gravity, follow Mega Man 3's with the entity arrays moved, and with four changes. Mega Man 4 drops Mega Man 3's routine that sets a behind-the-background flag from the tile hit. Its gravity tests one flag at $43 first, where Mega Man 3 tests for the player and then a flag at $B9. It drops Mega Man 3's exemption, for one animation ($13), from the cap on falling speed. And when gravity resets, it sets one speed ($FF00) for every entity, where Mega Man 3 sets $FFC0 for the player and $FFAB for the rest. Code	One routine, entity_gravity_collide, moves Mega Man vertically in the ground, air, and slide states, before their horizontal move. By the sign of his speed's whole byte (8.8 fixed point, positive up) it moves him down or up by the speed, takes gravity off the speed, and only then tests the floor points under a fall or the ceiling points over a rise. The ground state runs the whole air routine first and reads A and the d-pad only if that routine found him standing and he was already on the ground. Code Gravity takes 0.25 px/frame (`$40`/256) off Mega Man's upward speed every frame, after the move: the reset code writes `$40` to `$A1`, and the gravity routine subtracts `$A1` from the speed's fraction byte with the borrow into its whole byte. Code When gravity takes Mega Man's speed below −7 px/frame (its whole byte under `$F9`), the gravity routine sets it to exactly `$F9`.`$00`, so he falls at most 7 px a frame. Code On the ground Mega Man's vertical speed rests at −1 px/frame (`$FF`.`$00`): a floor found under a fall snaps him onto it and entity_stop_y sets that speed. So each grounded frame moves him 1 px down, takes gravity, and tests his floor points; ground there puts him back with the same speed, and none leaves him in the air falling at 1.25 px/frame. Code When a falling Mega Man's floor points find a solid tile, LEEF7 subtracts the tested row's depth into its 16 px tile from his Y pixel, which puts the points on the tile's top row and his feet on its top, and keeps the Y fraction. A fall of up to 7 px a frame always ends on the top of the tile it reaches. Code Measured in Mesen from power-on, at the start of Stone Man's stage, Mega Man stood with his Y fraction at `$80` once the teleport landed him. The floor snap keeps the fraction (floor-snap), so it stays with him on flat ground until a slide's end adds to it. Verified Mega Man 5's routines that move an object by its speed without checking tiles, and apply gravity, follow Mega Man 4's, with the gravity amount at $A1 instead of $99 and these changes. Eight bytes before the left mover clear the facing bit and fall into it. The player's gravity is skipped whenever a flag at $52 is set, where Mega Man 4 skips it only while a timer at $43 counts down. And Mega Man 5 adds four routines after them, one of which adds gravity to the vertical speed instead of subtracting it, capped at 7 pixels a frame. Code	Outside tile type `$08`, gravity adds `$40` (0.25 px/frame) to Mega Man's vertical speed every frame before he moves. Measured in Mesen from power-on, at the start of Tomahawk Man's stage, his speed grew by 0.25 px/frame on each frame of a held jump. Verified In tile type `$08` gravity is `$18` a frame (0.09 px/frame) instead of `$40`. Falling, the whole-pixel byte of his speed stops at 7 while the fraction keeps growing, so under the normal gravity his top falling speed steps between 7.05 and 7.80 px/frame (computed). Code
Ground slide		Mega Man 2 has no slide. A fresh A press in a grounded state always starts a jump; that code tests no other button. Code	Down and a fresh A press on the ground start a slide if no wall is ahead: 2 px lower, at 2.5 px/frame (`$02`.`$80`), with a timer of 20 (`$14`). The set-up frame moves once, and each slide frame moves before it tests the timer, so an unbroken slide moves on 21 frames. A turn, a wall, the timer's end, or (from the 9th frame) a fresh A press all lead to the standing test, where a solid tile at standing height keeps the slide going; otherwise it ends, with a jump at walking speed if A was pressed. Verified Starting a slide, Mega Man 3 first tests for a wall 8 and 22 px ahead of his center at its height, and a wall there cancels the press. A slide lowers him 2 px, tests the floor at x − 15, x, and x + 15, 10 px below his lowered center, and moves with a wall point 16 px ahead, at 5 px above and 7 px below that center. A turn, a wall, the timer's end, or a jump press leads to the standing test, the ceiling points 12 px over his lowered center. Code A slide that ends on open ground leaves Mega Man in the ground state with the walking animation, still 2 px low; the next frame's floor test pushes him back up. That walking animation moves him on the next frame toward his facing, so with no direction held he steps once more at 1.30 px/frame and then pauses, and with one held he walks on at once. A slide whose floor test finds nothing ends without moving that frame, and he falls from the next. Verified	Mega Man 4's slide keeps Mega Man 3's 2.5 px/frame but moves on 26 frames (a timer of `$1A`, counted after each move from the set-up frame on) where Mega Man 3's moves on 21 (a timer of 20). Its A test runs on every slide frame, the set-up's included: a fresh A press without Down jumps out whenever he has headroom, where Mega Man 3 waits for its 9th frame, and A with Down held keeps sliding. The set-up's own press comes with Down, and A held from it into the second frame is no fresh press, so the earliest jump out comes on the slide's 3rd frame. Verified Down and a fresh A press start a slide only if the slide's start point, 15 px ahead of his center and 4 px below it, isn't in a wall; with a wall there the press does nothing, neither slide nor jump. The slide moves his Y pixel 2 px down and tests a lower, wider box: floor points 10 px below the new center at x-14, x, and x+14, and wall points 15 px ahead, level with it and 9 px below. With no floor under those points, ground 16 px below the center keeps the slide going, and none stands him up. Code A slide ends in two ways. When the slide box finds no floor and no ground 16 px below his center either (slide-box), he stands up at once, with no headroom test, before that frame's A test and move. Otherwise it ends at the standing test, which a wall, the timer's end, or a turn sends it to. A turn (a held direction against the slide's) zeroes the timer and still moves him 2.5 px the new way on that frame. The test checks his standing headroom, three points 14 px above the slide's center (12 px above his standing one) at x-14, x, and x+14: a solid tile there keeps him sliding at 2.5 px/frame, testing again each frame, and otherwise he stands up in the walking pose, at walking speed, after that frame's move. A fresh A press without Down jumps out of it instead, at 5 px/frame and walking speed, if the same headroom is clear, from the 2 px lower slide center; the earliest such press comes on the slide's 3rd frame (slide-line). Verified	Mega Man 5 keeps Mega Man 4's slide, 2.5 px/frame for 26 frames (`$1A`), with a jump out of it on any slide frame a fresh A press comes without Down and there is headroom. The earliest is the slide's 3rd frame, counting the set-up frame (Down and A) as the 1st: a fresh press needs A let go on the 2nd. Code Down and a fresh A press start a slide only if the slide's start point, 15 px ahead of his center and 4 px below it, isn't in a wall; with a wall there the press does nothing, neither slide nor jump. The slide moves his Y pixel 2 px down and tests a lower, wider box: floor points 10 px below the new center at x−14, x, and x+14; ceiling points 8 px above it at the same three; and wall points 15 px ahead, 5 px above it and 9 px below. Its stand-up and jump-out test his headroom at three points 14 px above the slide's center (12 px above his standing one) at x−14, x, and x+14. Code A slide ends at the standing test, which a wall, the timer's end, or a turn sends it to. A turn (a held direction against the slide's) zeroes the timer and still moves him 2.5 px the new way on that frame. The test checks his headroom (slide-box): a solid tile there keeps him sliding at 2.5 px/frame, tested again every frame; a clear one raises him the 2 px back, puts him in the ground state with the walking pose and walking speed, and sets his vertical speed to −0.25 px/frame (`$FF`.`$C0`), so the next frame's fall moves his Y fraction `$40` down before the floor snap. A slide off a ledge ends at once in the ground state without the 2 px back, at the same −0.25. Code Mega Man 5's ordinary-floor movement differs from Mega Man 4's, though the walk, the step pose, the jump, gravity, the fall cap, air control, and the slide's speed, length, and start are the same. The first difference on flat ground: on a slide's last frame Mega Man 5 raises his center the 2 px the slide lowered it and sets −0.25 px/frame, where Mega Man 4 leaves it 2 px low at −1 px/frame, so for that frame Mega Man 5 stands 2 px higher, and each of its slides adds `$40` to his Y fraction. Against blocks, Mega Man 5's ceiling points are 10 px above his center (Mega Man 4's 9) and his wall points 9 px above it (Mega Man 4's 8); its slide's wall points are 5 px above and 9 px below the slide's center (Mega Man 4's level and 9 below), and its slide's ceiling points 8 px above it (Mega Man 4's level with it). Code	Mega Man 6 keeps Mega Man 5's slide speed and length, 2.5 px/frame for 26 frames (`$1A`), set from the table at `$8003`, outside tile type `$09`, where the table at `$8009` gives 1.5 px/frame (slow-surface). Measured in Mesen from power-on, at the start of Tomahawk Man's stage, a slide from Down and A moved him 2.5 px on each of 26 frames, 65 px in all. Verified A press of A without Down ends Mega Man 6's slide but doesn't jump: the slide hands over to the standing loop, which looks for a jump only in a later frame's fresh press (`$9A`). In Mega Man 5 the same press jumps out of the slide when there is headroom. Measured in Mesen from power-on, at the start of Tomahawk Man's stage, an A press on a slide's 8th frame with Down let go ended the slide that frame, and A held for the next 6 frames left him on the floor. Verified Down and A start the slide only with no Rush adaptor on (`$9B` 0); with one, the press jumps. A turn (a held direction against his facing) ends the slide early, and at its end two tile probes above him keep it going 4 frames at a time while the ceiling is low. Code Mega Man 6's slide ends on a turn, a wall (wall-stop), a fresh A without Down (slide-exit), its 26th frame, or the 2nd frame over a gap, when gravity has taken his speed's fraction to `$41` or more. Unless a low ceiling keeps the slide going (slide-rules), it hands over in the same frame: over a gap to the air loop, with the fraction set to `$CC`, and otherwise to the standing loop, which moves him a second time that frame, at the walking speed toward a held direction or not at all. So a turn out of a slide moves him 2.5 px forward and 1.30 px back in one frame, and the next frame starts a step. Measured in Mesen from power-on near the start of Tomahawk Man's stage, a slide off the ledge at X 160 slid on its first frame over the gap and fell from the second, and Left on a rightward slide's 7th frame moved him 1.20 px right that frame (`$01`.`$34`, the slide's `$02`.`$80` less the walk's `$01`.`$4C`), then 1.30 px left as a step began. Verified
Hitbox	Mega Man's position is his center; the floor and ceiling are tested at x − 7 and x + 7, 12 px below or above it, and walls at x + 8 or x − 8, toward his facing, at 12 px and 4 px above and 11 px below it. Every animation he has on foot or in the air uses these offsets. Code `_check_special_blockset_or_tsa_collision` turns a test point into a tile: X / 32 and Y / 32 pick a 32 px block of the screen's map, bit 4 of Y and of X pick one of its four 16 px tiles, and the tile's top two bits give its kind through a per-stage table: background, block, and two of ladder, spike, ice, and water. Code Each frame on foot or in the air, `_run_megaman_on_stage` moves Mega Man horizontally first, testing for a wall, then vertically, testing the floor under a fall or the ceiling over a rise, and only then checks for a jump or lands, runs, slides, or stands, so a frame's floor test uses that frame's new X. The one change made before the move is a Left or Right pressed fresh, which sets the first step's animation (ground-states). Code When the horizontal move puts the wall point ahead in a solid tile, `_objects_rightward` or `_objects_leftward` puts x + 8 on that tile's first column moving right, or x − 8 on the first column past it moving left, and keeps the X fraction of the move; his speed and animation are untouched, so he runs in place. Verified When a rising Mega Man's move puts a ceiling point, x − 7 or x + 7 at 12 px above his center, in a block, `_objects_vertical_moving` puts that point on the first row under the block's 16 px tile, zeroes the Y fraction, and sets his speed to −0.75 px/frame, the speed a landing gets; `_run_megaman_on_stage` then returns before the release test and before setting the jumping animation, and he falls from the next frame. Measured in Mesen at the start of Bomb Man's stage, under 16 px blocks that the probe adds to the stage's collision. Verified	Mega Man's position is his center; the floor and ceiling are tested at x−7 and x+7, 12 px below or above it, and walls at x+8 or x−8 at 12 px and 4 px above and 11 px below it. Code `_tsa_collision` turns a test point into a tile: X / 32 and Y / 32 pick a 32 px block of the stage map, bit 4 of X and of Y pick one of its four 16 px tiles, and the tile's top two bits give its kind, background, block, or one of a per-stage pair such as ladder and spike. Code Each of Mega Man's grounded and jumping states moves him horizontally first, testing for a wall, then vertically, testing the floor under a fall or the ceiling over a rise, and only then changes state or checks for a jump, so a frame's floor test uses that frame's new X. Code When the horizontal move puts the wall point ahead in a solid tile, `_check_object_horizontal_move` zeroes Mega Man's X fraction and pushes him back by the point's depth into the tile, so x + 8 ends on the wall's first column moving right and x − 8 on the first column past it moving left; his speed and state are untouched, so he runs in place. Verified A pit has no floor of its own; once Mega Man's Y passes $E8 on the screen, `_check_object_vertical_move` asks for a downward scroll, and `_check_scroll` kills him where the stage doesn't scroll down. Code When a rising Mega Man's move puts a ceiling point, x − 7 or x + 7 at 12 px above his center, in a block, `_check_object_vertical_move` zeroes his Y fraction and adds 16 − ((Y − 12) mod 16) to Y, which puts that point on the first row under the block's 16 px tile, then zeroes his speed and takes one step of gravity from it; he stays in the jumping state and falls from the next frame, starting at 0.25 px/frame. Verified	Mega Man's position is his center. A fall tests the floor at x − 7, x, and x + 7, 12 px below it, and a rise tests the ceiling at x − 7 and x + 7, 12 px above it; a horizontal move tests x + 8 or x − 8 at 11 px above, level with, and 11 px below the center. Each point reads the 16 px tile holding it. Code When a horizontal move puts a wall point in a solid tile, the move routine pushes Mega Man back by the point's depth into the tile, so x + 8 ends on the wall's first column moving right and x − 8 on the first column past it moving left. The X fraction stays as it was, and his speed and state are untouched, so he walks in place against the wall. Code When a rise puts a ceiling point, x − 7 or x + 7 at 12 px above his center, in a solid tile, `snap_y_to_ceil` adds 16 − ((Y − 12) mod 16) to Mega Man's Y pixel, which puts that point on the row under the tile, keeps the Y fraction, and sets the resting speed, 0.25 px/frame down; he stays airborne. Since a jump runs the airborne routine on its press frame, a ceiling within the first frame's 4.89 px is met on that frame. Code		Mega Man's position is his center. Standing, walking, and in the air his floor points are 12 px below it at x−7, x, and x+7; his ceiling points 10 px above it at x−7 and x+7; and his wall points 8 px to the side he moves toward, at 9 px above, level with, and 11 px below his center. Tiles are 16 px. Code When the horizontal move puts a wall point in a solid tile, the move routine pushes Mega Man back by the point's depth into that 16 px tile, so x+8 ends on the wall's first column moving right and x−8 on the first column past it moving left. The X fraction, his speed, and his pose stay, so he walks in place against it. Code When a rising Mega Man's move puts a ceiling point, x−7 or x+7 at 10 px above his center, in a solid tile, LEEDD adds 15 minus the point's depth into the tile to his Y pixel, which leaves the point on the tile's bottom row, and entity_stop_y sets his speed to −1 px/frame; he stays in the air and falls from the next frame. Code	Mega Man 6 tests the tiles at points around his center, from the table at `$9119` (X) and `$912D` (Y): falling or standing, his floor at 12 px below the center, at the center and 7 px to each side; rising, his head at 9 px above it, at the same three; and walls 7 px to the side he moves toward, at 7 px below the center (level with it when rising), 9 px above, and 10 px below. In a slide the high wall point and the head's two side points drop to 3 px above the center (the head's center point stays 9 above), and the low wall point to 12 below. Each point reads the 16 px tile holding it. Code After each move Mega Man 6 tests his points in a fixed order: the center floor or head point, then the wall point at mid height, then, if he moves sideways, the high wall point, then the two floor or head corners, and last one more wall point, the low one if he moves sideways or the high one if not. A floor or ceiling found pushes him out at once, so the points after it test from where it left him; a wall found ends the frame's tests. Code When a floor or head point finds a solid tile, Mega Man 6 is pushed out of it by the point's depth in its 16 px tile: from the tile's top half up to the row above it, from its bottom half down to the row below it; his Y fraction stays. Falling or standing, his vertical speed is set to 0; rising, only its whole byte (ceiling-hit). After the frame's tests a push moves him 1 px back down, so a standing Mega Man's floor point lies in the floor's top row. Standing, gravity adds `$40` to his speed and his Y every frame and the floor pushes him back, so his Y fraction drifts by `$40` a frame while his whole Y stays. Measured in Mesen from power-on near the start of Tomahawk Man's stage, a walk, a slide, and a jump off the ledge at X 160 each landed with his floor point on the top row of the lower floor (row 160, 32 px below the start floor's top row, 128), the speed 0. Verified When a wall point finds a solid tile, Mega Man 6 is pushed back out across by the point's depth in its 16 px tile, from its left half to the column left of it, from its right half to the column right of it; his X fraction stays, and the frame's other tile tests are skipped. The push also ends a slide. Measured in Mesen from power-on near the start of Tomahawk Man's stage, walking left on the lower floor into the face of the ledge at X 160 held his X at 167, his left wall points on column 160, right of the face, while he kept walking. Verified At the end of every frame Mega Man 6 holds Mega Man on the screen: his X is kept from 16 px (`$A8`, which his routine's start sets to `$10`) to 244 px right of the camera's left edge, with its fraction left as it is, and a Y of 240 or more on the screen's own rows kills him. Measured in Mesen from power-on near the start of Tomahawk Man's stage, where the camera can't scroll left, walking left stopped at X 16 while his X fraction kept changing. Verified
Invincibility frames	A hit sets `zmegaman_invincibility_time` to 111 (`$6F`); while it is nonzero no contact damages Mega Man, and the stage loop counts it down by 1 on each pass that runs the enemies. Code	A hit sets `zmegaman_invincibility_time` to 111 (`$6F`); contact damage is skipped while it is nonzero, and it counts down by 1 each time Mega Man's sprite is processed, hiding him on alternate pairs of frames. Code	Mega Man 3 starts the invincibility after the knockback: when the hurt state ends it sets `invincibility_timer` to 60 (`$3C`), which the prelude counts down every frame. Mega Man 2 sets 111 at the moment of the hit. Code			A hit sets Mega Man 6's invincibility timer `$A2` to 60 frames (`$3C`), but the 30-frame knockback runs through the frame routine's entry past the countdown (code_388EB9), so the timer starts to count, and he starts to blink, only once the knockback ends: he can't be hurt for 90 frames in all (computed). The damage routine skips a hit while `$A2` isn't 0. Code
Jump	A fresh A press on the ground sets Mega Man's upward speed to `$04`.`$DF`, 4.87 px/frame. Code Mega Man 2 keeps Mega Man's jump and running numbers. Both take off at `$04`.`$DF`, subtract `$40` of gravity a frame, cap a fall at `$F4`, cut a rise of 2 px/frame or more to 1 when A is up, and move at 0.125, 1.375, and 1.3125 px/frame stepping, running, and in the air. Code When a falling Mega Man's floor points find a block, `_objects_vertical_moving` sets his Y to the top of that 16 px tile less 12, which puts his feet on it, zeroes the Y fraction, and sets the speed to −0.75 px/frame (ground-check); so a fall of up to 12 px a frame always ends on the top of the tile it meets. Verified No grounded frame tests the ceiling, since Mega Man's vertical speed on the ground is −0.75 px/frame (ground-check) and the vertical move tests only the floor at a negative speed; the jump press then sets the jump speed without testing the ceiling, so a press under a block still starts the jump, and the rise meets the block on a later frame. Measured in Mesen at the start of Bomb Man's stage, under a 16 px block the probe adds to the stage's collision. Verified A jump press returns before the animation changes, and the jumping animation is set only after the next frame's move, so the press frame and the one after both move at the ground animation's speed (two frames of 1.375 px/frame from a run, of 0.125 from a first step, and none from standing still); from the third frame the air speed applies. Verified Mega Man lands running, at 1.375 px/frame from the next frame with no first step, only if Left or Right is held on the landing frame itself; with the direction let go on that frame he lands standing, and with nothing held then or the frame before he lands into the landing animation, which moves no faster than standing. A direction pressed fresh on the landing frame starts the first step. Verified	In the standing, walking, running, and landing states, a fresh A press (`zjoy1_pressed_bits`) copies `zjump_speed` into Mega Man's vertical speed after the frame's move, so the press frame doesn't lift him. Code Mega Man's jump speed is `$04`.`$DF`, 4.87 px/frame upward, out of water (`$05`.`$80` in water). Code The jump check runs after the frame's move, so the press frame moves at the ground state's speed, and from the next frame the jumping state's 1.3125 px/frame (or nothing, with no direction held) replaces any run. Verified Mega Man lands into the running state if Left or Right was held on the frame before landing, at 1.375 px/frame from the next frame with no first step, and into the landing-stop state otherwise. Verified When a falling Mega Man's floor points find a block, `_check_object_vertical_move` subtracts (Y + 12) mod 16 from his Y, which puts his feet on that 16 px tile's top, zeroes the Y fraction and the vertical speed, then takes one step of gravity from the speed; so a fall of up to 12 px a frame always ends on the top of the tile it meets. Verified No grounded state tests the ceiling, since each grounded frame leaves Mega Man's vertical speed at −0.25 px/frame (ground-check) and the vertical move tests only the floor at a negative speed; the jump press then sets the jump speed and the jumping state without a test, so a jump always starts under a ceiling, and the rise first meets it on a later frame. Verified Under a block 32 px above the floor, 8 px over his head, a standing jump meets the block on its second rising frame and lands on frame 11, with his feet 0, 5, 8, 8, 8, 7, 6, 5, 3, 1, and 0 px up on frames 1-11. Verified	A fresh A press on the ground without Down sets Mega Man's upward speed to `$04`.`$E5`, 4.89 px/frame, and runs the airborne state at once. Code Landing on Rush Coil launches Mega Man at `$06`.`$EE`, 6.93 px/frame, once per bounce, and sets `force_full_jump`, so releasing A doesn't cut that rise. Code When a fall's floor points find a solid tile, `snap_y_to_floor` subtracts (Y + 12) mod 16 from Mega Man's Y pixel, which puts his feet on the tile's top, and leaves the Y fraction as it was; his vertical speed becomes the resting `$FF`.`$C0`, 0.25 px/frame down. Every grounded frame repeats the fall, so standing still his Y pixel holds while the fraction steps by `$40` each frame: in Top Man's stage start in Mesen it cycles through `$00`, `$40`, `$80`, and `$C0`. Verified A jump lifts Mega Man on its press frame: the ground state sets the jump speed and runs the airborne routine at once, which moves him 4.89 px up from where that frame's floor test left him (the test takes him 0.25 px down, or, when that crosses into the next pixel and the snap puts his feet back on the floor, 0.75 px up), takes gravity, and gives the frame the air move, 1.30 px/frame toward a held direction or none, in place of the ground move. A press in a walking pause still jumps, since the press is read before the walk. Verified A landing frame moves Mega Man only vertically: the airborne routine snaps him onto the floor, sets the ground state and the turning animation already on its second frame, and returns before the air move. From the next frame he walks at once if a direction is held, with no pause. An A press on the landing frame is lost, since the airborne state reads no presses. Verified	uses	Nothing tests the ceiling before a jump starts: a fresh A press on the ground sets the jump speed and runs the air routine again, whose rise is the first test. So under a block two tiles over the floor, the lowest he can walk under, the jump still starts, and its 3rd frame meets the block: his ceiling points must rise 11 px to reach its bottom row, and the rise is 5, then 4.75, then 4.5 px (9.75 px after two frames, 14.25 after three). Code The frame a falling Mega Man's floor test finds ground puts him in the ground state with the walking pose (`$04`) and still moves him by the air's rules. On the next frame he walks on at once if he holds the direction he held on landing; any other direction, or none, starts the step pose. The air state reads no A press, so a press on the landing frame is lost, and the next frame's press jumps. Code	On a fresh A press with no slide, on ordinary floor, Mega Man 6's standing loop sets his vertical speed to `$FA`.`$CC`, 5.20 px/frame up, where Mega Man 5 writes 5 px/frame (`$05`.`$00`); in tile type `$09` it writes the slower `$FB`.`$CC` instead (slow-surface). The air loop adds gravity before each move, so the first frame lifts him 0.25 less, 4.95 px. Measured in Mesen from power-on, standing where he lands at the start of Tomahawk Man's stage, the first frame of a jump moves him up at that 4.95 px/frame. Verified Computed from the ordinary take-off and gravity, outside tile types `$08` and `$09` (fall-limits, slow-surface), a jump with A held peaks 51.6 px above the floor on its 20th frame. Measured in Mesen from power-on, at the start of Tomahawk Man's stage, the held jump rose 51.56 px and turned to fall after frame 20. Verified A Mega Man 6 falling onto a floor has his vertical speed set to 0, fraction included, by the floor push (floor-snap). The air loop reads the landing on the next frame, from the fraction being 0, and goes into the walking loop at once: that frame he turns to a held direction and walks at 1.30 px/frame with no step, or a fresh A press jumps again. A press on the touchdown frame itself is never read, since only the air loop runs then, and it reads A only as held. Code Rising into a solid tile, Mega Man 6 is pushed down below it and 1 px further, and the whole byte of his vertical speed is set to 0 while its fraction stays, so on the next frame, gravity added, he moves down 0.30 to 1.05 px (under the normal gravity). He stays in the air loop, and the jump's release cut, which needs the whole byte negative, no longer applies. Code Nothing in Mega Man 6's ground loops tests the ceiling before a jump or a slide: a fresh A press sets the take-off speed or starts the slide outright, and a jump under a low ceiling meets it on its first move (ceiling-hit). Mega Man 5 tests a point over his head before a slide starts. Code Mega Man 6's ordinary-floor movement isn't Mega Man 5's: the first difference is a jump's take-off. Mega Man 6 sets his vertical speed to `$FA`.`$CC`, 5.20 px/frame up; Mega Man 5 sets its whole byte `$03F0` to `$05` and its fraction `$03D8` to `$00`, 5 px/frame (jump-speed). Letting go of A sets only the whole byte to 0 in Mega Man 6 and both bytes in Mega Man 5 (release-cut), and Mega Man 5 tests for headroom before a slide where Mega Man 6 doesn't (jump-under-ceiling). The two run different code: Mega Man 5's player is a state machine dispatched each frame from `$30`, Mega Man 6's a coroutine of loops (coroutine-scheduler). Code
Jump physics				One routine, entity_player_collide, moves Mega Man vertically in every state: by the sign of his speed's whole byte it moves him down or up by the speed (8.8 fixed point, positive up), takes gravity off the speed, and only then tests the floor points under a fall or the ceiling points over a rise. The ground, air, and slide states all run it before their horizontal move, so a frame's floor and ceiling tests use the X the frame started with and its wall test the new Y. Code Gravity takes `$40`/256 = 0.25 px/frame from Mega Man's upward speed every frame; the stage start writes `$40` to `gravity` ($99). Verified When gravity takes Mega Man's speed below -7 px/frame (its whole byte under `$F9`), the gravity routine sets it to exactly `$F9`.`$00`, so he falls at most 7 px a frame. Code On the ground Mega Man's vertical speed rests at -1 px/frame (`$FF`.`$00`), which every landing and every floor contact sets through entity_stop_y. So each grounded frame moves him 1 px down, takes gravity, and tests his floor points one row lower; ground there puts him back on it at the same speed, and none leaves him in the air, falling at 1.25 px/frame from the next frame. Verified When a falling Mega Man's floor points find a solid tile, align_down subtracts the tested row's depth into its 16 px tile from his Y pixel, which puts the points on the tile's top row and his feet on its top, and keeps the Y fraction; the speed goes back to -1 px/frame. A fall of up to 7 px a frame always ends on the top of the tile it reaches. Code Mega Man's position is his center. Standing, walking, and in the air his floor points are 12 px below it at x-7, x, and x+7; his ceiling points 9 px above it at x-7 and x+7; and his wall points 8 px to the side he moves toward, at 8 px above, level with, and 11 px below his center. Code When the horizontal move puts a wall point in a solid tile, the move routine pushes Mega Man back by the point's depth into that 16 px tile, so x+8 ends on the wall's first column moving right and x-8 on the first column past it moving left; the X fraction, his speed, and his pose stay, so he walks in place against it. Code When a rising Mega Man's move puts a ceiling point, x-7 or x+7 at 9 px above his center, in a solid tile, entity_align_to_tile adds 16 minus the point's depth into the tile to his Y pixel, which puts the point on the row under the tile, and entity_stop_y sets his speed to -1 px/frame; he stays in the air and falls from the next frame. Code Nothing tests the ceiling before a jump starts: a fresh A press on the ground sets the jump speed and runs the air routine, whose rise is the first test. On tile floor the lowest ceiling he can walk under is 32 px up, 11 px over his ceiling points, so a jump there rises 5 px and then 4.75 px on its first two frames and meets the block on the 3rd, which turns it into a fall. Code The frame a falling Mega Man's floor test finds ground puts him in the ground state with the walking pose ($04), and still moves him by the air's rules. On the next frame he walks on at once if he holds the direction he held on landing; none starts the pause pose, and the other direction starts it with one move that way, as a turn does. The air state reads no A press, so a press on the landing frame is lost, and the next frame's press jumps. Verified Mega Man 4's movement on ordinary floor differs from Mega Man 3's in five numbers. The first is the jump's take-off speed: 5 px/frame (`$05`.`$00`) against Mega Man 3's 4.89 (`$04`.`$E5`). The second is the speed on the ground and after a landing: -1 px/frame (`$FF`.`$00`) against -0.25 (`$FF`.`$C0`). Third, a release cuts a rise to 0, where Mega Man 3 sets the same -0.25. Fourth, the slide timer starts at 26 (`$1A`) against 20 (`$14`), so the slide moves on 26 frames against 21 (slide-line, mega-man-3/slide). Fifth, Mega Man 4 tests for the jump out of a slide on every slide frame, where Mega Man 3 skips the test while the timer is 12 (`$0C`) or more, so the earliest jump out comes on the 3rd frame against the 9th. Code
Knockback	A hit faces Mega Man against the enemy's facing and puts him in the hit animation (`$12`), which sets his upward speed to 1.25 px/frame (`$01`.`$40`) once and pushes him backward, against his own facing, at 0.5625 px/frame (`$90`) under the usual gravity until the animation ends. Code Mega Man 2 keeps Mega Man's hit numbers too, 111 frames of invincibility (`$6F`) and a knockback of 1.25 px/frame up and 0.5625 back. Code	`_megaman_hit` sets Mega Man's upward speed to 1.25 px/frame (`$01`.`$40`) and his horizontal speed to 0.5625 (`$90`) once; the hit state then moves him against his facing under the usual gravity until his animation's upper timer returns to 0, and leaves to the jumping or standing state. Code	A hit (state `$06`) sets Mega Man's vertical speed to the resting `$FF`.`$C0` on its first frame, then each frame applies gravity and pushes him against his facing at 0.5 px/frame (`$00`.`$80`) until the hurt animation's state reaches 9; a hit during a slide doesn't push him. Code	Mega Man 4 keeps Mega Man 3's knockback, 0.5 px/frame (`$00`.`$80`) against his facing under gravity until the hurt animation reaches 9, with no push when the hit lands during a slide. Code	Mega Man 5 keeps the 0.5 px/frame knockback, always against the way Mega Man faces, but lets the player resist it: with the direction he faces held, the push drops to 0.25 px/frame (`$40`). Code	Mega Man 6 keeps Mega Man 5's knockback: 0.5 px/frame against his facing, or 0.25 px/frame (`$40`) with the direction he faces held, here for 30 frames (`$1E`), with Up, Down, Start, and Select masked out of the held buttons. Code
Level loading		The last 16 screens of Metal Man's map, $1C to $2B (1,024 bytes), are byte for byte the last 16 of Mega Man's Cut Man and Wily stage 1 map: Cut Man's screens $0C to $0F and Wily stage 1's $10 to $1B. Metal Man's screens $18 to $1B repeat four of them, Wily stage 1's $18 to $1B. Code
Music driver		Mega Man 2's song data reader is Mega Man's, instruction for instruction and with the same RAM, so the two games read the same note and command format. It sits $100C lower: only its jump and call addresses, its command table, and the address of the note table differ. Code Mega Man 2's note length and pitch tables are Mega Man's but for one pitch: the period of the note the disassembly names `nEb1` drops from $059E to $0594, about 12 cents higher (computed). The region also ends with 3 bytes of $FF filler instead of 7. Code		Mega Man 4's sound bank opens with Mega Man 3's entry jumps, multiply, and sound-data read, at the same addresses; only the two bank numbers the read maps differ: the overflow data bank, $18 in Mega Man 3 and $1D in Mega Man 4, and the data bank it restores, $17 and $1F. Code Mega Man 4's music track reader is Mega Man 3's (labeled `process_sfx_channel` there), byte for byte at the same address, so the two games read the same track format. Code Mega Man 4's note-to-pitch routines are Mega Man 3's, byte for byte at the same address. Code Mega Man 4's volume envelope and fade code is Mega Man 3's, byte for byte at the same address. Code Mega Man 4's code that writes each channel's pitch to the APU, with vibrato, detune, and slides, is Mega Man 3's, byte for byte at the same address. Code Mega Man 4's sound driver tables, through the note period table, are Mega Man 3's at the same addresses; the 37 bytes after it ($8A1B-$8A3F), all zero in Mega Man 3, hold data in Mega Man 4. Code	Mega Man 5's sound bank, bank $18, opens with Mega Man 4's entry jumps, multiply, and sound-data read at the same addresses; only the two bank numbers the read maps differ: the overflow data bank, $1D in Mega Man 4 and $1A in Mega Man 5, and the data bank it restores, $1F and $19. Code Mega Man 5's music track reader is Mega Man 4's, byte for byte at the same address. Code Mega Man 5's note-to-pitch routines is Mega Man 4's, byte for byte at the same address. Code Mega Man 5's volume envelope and fade code is Mega Man 4's, byte for byte at the same address. Code Mega Man 5's code that writes each channel's pitch to the APU, with vibrato, detune, and slides, is Mega Man 4's, byte for byte at the same address. Code Mega Man 5's sound driver tables, through the note period table, are Mega Man 4's at the same addresses. The 37 bytes after it ($8A1B-$8A3F), which hold data in Mega Man 4, are all zero in Mega Man 5, as in Mega Man 3. Code	Mega Man 6's sound bank, bank $34, opens with Mega Man 5's entry jumps, multiply, and sound-data read at the same addresses; only the two bank numbers the read maps differ: the overflow data bank, $1A in Mega Man 5 and $36 in Mega Man 6, and the data bank it restores, $19 and $35. Code Mega Man 6's music track reader is Mega Man 5's, one byte lower ($8392 against $8393); only its call and jump targets, jump-table entries, and the addresses of the tables it reads differ. Code Mega Man 6's note-to-period lookup is Mega Man 5's, one byte lower; the only differences are the two operands that address the period table, which sits seven bytes higher in Mega Man 6 ($8960 against $8959). Code Mega Man 6's volume envelope code is Mega Man 5's, one byte lower; only its jump-table entries, call targets, and the address of the envelope step table, seven bytes higher, differ. Code Mega Man 6's period output is Mega Man 5's with one step added: after adding the channel's signed offset at $0714 to the period, a period of zero becomes 1. The added 8 bytes push the sound tables seven bytes higher, and the routine's table operands follow. Code Mega Man 6's sound tables (note lengths, octave offsets, envelope steps, octave thresholds, and the period table) are Mega Man 5's byte for byte, seven bytes higher at $891C; the zero padding after them, up to the song directory at $8A40, is seven bytes shorter. Code Mega Man 6's music $13, 116 bytes at $A19B-$A20E of bank $36, is Mega Man 5's music $11 moved. Only the four track pointers in its header differ, each $625 lower, as far as the song's start moved. Verified Mega Man 6's instrument table, 71 instruments of 8 bytes at $8B0F, has as many instruments as Mega Man 5's at $8ADB, but only 27 are the same under the same number. The longest such run is nine instruments, $3D-$45 (72 bytes). One more of Mega Man 6's is in Mega Man 5's table under another number. Verified
Palette cycling		Once a frame `_background_palette` counts up to a stage's frame byte and then copies the next 16-byte background palette set into the working palette, wrapping after the stage's set count; Heat Man's stage has 3 sets and a frame byte of 6, so its palette 3 rotates `$36`, `$26`, `$16` one step every 7 frames. Code
Password and battery save		Mega Man 2's password is 9 dots on a 5 by 5 grid; the entry screen counts down from 9 as the player places dots with A and takes them back with B, and reads the password when the ninth is placed. Code Mega Man 2's password holds the E-tank count and, for each of the 8 Robot Masters, whether he is beaten; a dot in the top row's first five cells gives 0-4 E-tanks, and each Robot Master has one "beaten" cell and one "not beaten" cell among the other 20, which also include 4 cells that mean nothing. Code Mega Man 2 shifts the 20 boss cells by the E-tank count; table entry i goes to cell 5 + (E-tanks + i) mod 20, wrapping from the last cell back to the first cell of the second row, so the same bosses beaten give a different grid for each E-tank count. Code Mega Man 2 reads the E-tank count as the first dot in the top row's first four cells, or 4 if none of them holds one, without looking at the fifth; it then ORs each dotted cell's boss into a beaten byte or a not-beaten byte and accepts the password only if the two together cover all 8 bosses, else it writes PASSWORD ERROR ! and, after two waits of 125 frames, returns to the menu of START and PASSWORD. Code A correct Mega Man 2 password gives Mega Man the weapon of every boss in its beaten byte, Item 1 if Heat Man is beaten, Item 2 if Air Man is, and Item 3 if Flash Man is, plus its E-tank count; the password holds nothing else. Code				uses
PRG bank switching		Both games' bank switch routines map a PRG bank at $8000, but Mega Man 2's is new code for a different board: Mega Man writes the bank number once, to its own byte of a bank table (the disassembly's `uxrom_prg_bank`), and Mega Man 2 writes it to MMC1 one bit at a time, then runs any sound an NMI put off during the switch. Code	Both games flag a bank switch in progress and catch up on the frame's sound afterward if the NMI arrived during it, but Mega Man 3's switch is new code for a different board: Mega Man 2 maps one 16 KB bank at $8000 by writing its number to MMC1 one bit at a time, and Mega Man 3 writes two 8 KB banks, at $8000 and $A000, to the MMC3 as whole bytes. Code		Mega Man 5's routine that maps the two switchable PRG banks from their shadows, and then runs a sound request that arrived while it was busy, is Mega Man 4's, byte for byte (37 bytes). Mega Man 5 enters it through 6 new bytes that set both shadows from one bank number, the bank and the one after it. Code
Running	Off ice, Mega Man never accelerates. Each frame his animation picks a speed from `special_object_xcoord_speed_table`, 0 standing, 0.125 px/frame on the first step, 1.375 running, 0.5 sliding to a stop, 0 landing, and 0.5625 when hit; any other animation, such as the jump, moves at 1.3125 with a direction held and 0 without. Code Mega Man's animation is his state. A Left or Right pressed fresh, with neither held the frame before, starts the first step (`$03`) with its timer at 0, on the ground or in the air; each frame on the ground after the move, a held direction turns the step into the run (`$06`) once its timer reads `$22`, and lands a jump running; a direction let go turns a run into the slide to a stop (`$0C`, timer 1) and anything else into standing; with no direction this frame or the last, a jump lands into the landing animation (`$0F`, timer 1), and the slide and the landing end in standing when their timer wraps to 0. Code After Mega Man's frame, `_object_frameset_timer` advances his animation's timer from the frameset's first byte: the low nibble counts up to the byte's low nibble, then the high nibble moves to the next animation frame or wraps to 0 after the last. The first step shows 3 frames for 3 frames each; the press frame sets its timer to 0 and the ground check reads it before that frame's advance, so the check first finds `$22` on the step's 9th frame; the slide shows 2 frames for 7 each (8 in the shooting pose), and the landing 2 frames for 2 each. Code Measured from a standstill at the start of Bomb Man's stage, Mega Man's first step lasts 9 frames at 0.125 px/frame, and a released run slides 13 frames at 0.5 px/frame, 6.5 px in all, before he stands; a jump landed with nothing held shows the landing animation for 3 frames. Verified A buster shot sets `aobject_timer` to `$1F`, which shows Mega Man's shooting animations for 15 frames, counting the press frame; their framesets time the slide to a stop at 8 frames per animation frame instead of 7, so a shot fired shortly before or during the slide lengthens it. A Left or Right pressed fresh clears the pose. Code Each frame `_change_direction` faces Mega Man toward a held Left or Right before his speed is looked up and he moves, so he reverses at full speed with no skid; a reversal from one held direction to the other isn't a fresh press, so a run stays a run. Verified Down changes nothing on open ground; `_megaman_on_stage` reads Up and Down only when a ladder tile is at hand. Verified Mega Man's ordinary-floor movement differs from Mega Man 2's, measured in Mesen at the start of Bomb Man's stage and of Heat Man's. The first difference: holding Right from a standstill, Mega Man is still in his first step on the 8th frame, moving 0.125 px, where Mega Man 2 runs at 1.375. After it: a slide of 13 frames, not 8; two frames at the ground speed after a jump press, not one; a landing that runs only with a direction held on the landing frame, not the frame before; 0.125 px/frame on a fresh press in mid-air; −0.75 px/frame on the ground, not −0.25, so a walk-off and a ceiling hit fall faster; and a wall push that keeps the X fraction. Verified	Measured in the game, Mega Man first steps 0.125 px/frame for 7 frames, then runs at 1.375 px/frame. Verified Mega Man's X is 8.8 fixed point, and his horizontal speed is an 8.8 magnitude that `_check_object_horizontal_move` adds or subtracts according to the right bit of `ztoward`. Code Mega Man never accelerates; each frame his state's row of `megaman_status_xcoord_speed_table` sets the speed outright, 0 standing, 0.125 px/frame on the first step, 1.375 running, 1.3125 jumping, and 0.5 sliding to a stop. Code A held direction moves standing Mega Man into the first-step state on the same frame; the step becomes a run when its animation reaches frame 1, a released run becomes a slide, and the slide stops at its animation's frame 2 or restarts the first step if a direction is pressed. Code `_turn_megaman` faces Mega Man toward a held Left or Right at the start of every moving state's frame, and the move direction follows the facing that same frame, so he reverses at full speed with no skid. Verified Measured from a standstill in Heat Man's stage, Mega Man's first step lasts 7 frames, and a released run slides 8 frames at 0.5 px/frame, 4 px in all, before he stands. Verified Down changes nothing on open ground; of the walking states only `_check_shoot_on_ladder` reads Up and Down, and only when a ladder is at hand. Verified	Mega Man 3 drops Mega Man 2's slow step speed but keeps a pause. Before each frame's state runs, the prelude sets the speed to `$01`.`$4C` (1.30 px/frame) unless he is sliding. From standing, a held direction moves him by it at once and starts the turning animation (`$0D`); while that animation is on its first frame the ground state doesn't move him, and once it advances he walks at the same 1.30. In the air a held direction moves him at 1.30 on every frame. Code The turning animation, `$0D`, has 2 frames of 6 ticks each: its sequence's count byte is 1 and its tick byte 5, and the sprite engine advances a frame when the tick that started equal to the tick byte ends. While it shows its first frame the ground state doesn't move Mega Man. Code On the ground Mega Man 3 picks the move from his animation. Standing, a held direction faces him that way, starts the turning animation, and moves him 1.30 px; on the turning animation's first frame he doesn't move; once it reaches its second, a held direction starts the walking animation and moves him, and nothing held stands him. Walking, a direction matching his facing moves him; anything else, letting go or the other direction, starts the turning animation and moves him once more toward his facing. Down alone does nothing on open ground. Code Measured in Mesen from a standstill in Top Man's stage start, Right held moves Mega Man 1.30 px on its first frame, not at all on the next 5, and 1.30 px on every frame after; let go after a walk, he moves 1.30 px on one more frame and then stands. Verified Mega Man 3's ordinary-floor movement differs from Mega Man 2's from the first frame of a walk: Right held from a standstill moves him 1.30 px, then nothing for 5 frames, then 1.30 px a frame, where Mega Man 2 moves 0.125 px a frame for 7 frames, then 1.375. A jump differs from its press frame, which lifts him 4.89 px where Mega Man 2 lifts him 0. Letting go of A mid-rise starts the fall at once, where Mega Man 2 cuts a rise of 2 px/frame or more to 1, and falls cap at 7 px/frame instead of 12. He keeps Mega Man 2's gravity, floor and ceiling corners, and 16 px tiles, and adds the slide. Code	Mega Man walks and moves through the air at the speed held in his X speed (ent_xvel), 1.30 px/frame (`$01`.`$4C`) on ordinary floor; no walking or air code sets it. The slide writes 2.5 px/frame there, and its end and the jump out of it write `$01`.`$4C` back. Measured in Mesen from power-on, at the start of Skull Man's stage, the X speed read `$01`.`$4C` and each walking frame moved him 332/256 px. Verified On the ground Mega Man's sprite sub-type decides whether he moves. Standing ($01), a held direction sets the pause pose ($0D) and moves him one frame; in the pause pose he doesn't move until its animation advances, and then walks ($04) toward a held direction, or stands with none. Walking, the same direction keeps him moving; letting go puts him in the pause pose without a move, and the other direction does too, with one frame's move the new way. Code The pause pose lasts 6 frames: its animation (sub-type `$0D` in bank `$0D`) holds its first frame for 6 animation ticks, one a frame. So from standing, or on a turn, a held direction moves Mega Man on the first frame, holds him still on the next 5, and walks from the 7th; letting go of a walk holds him for 6 frames, whatever the d-pad does, before he stands or walks on. Measured in Mesen from power-on, at the start of Skull Man's stage, Right moved him on frame 1, not on frames 2 to 6, and on every frame from 7 to 40; letting go on frame 41 kept him still in the pause pose on frames 41 to 46, and he stood from frame 47. Verified	Mega Man walks and moves through the air at the speed held in his X speed (`$03C0`.`$03A8`), 1.30 px/frame (`$01`.`$4C`) on ordinary floor; no walking or air code sets it. The slide writes 2.5 px/frame there, and its end and the jump out of it write `$01`.`$4C` back. Measured in Mesen from power-on at the start of Stone Man's stage (`$26` = 2), the X speed read `$01`.`$4C` and each walking frame moved him 332/256 px. Verified On the ground Mega Man's sprite sub-type decides whether he moves. Standing (`$01`), a held direction sets the step pose (`$0D`) and moves him one frame; in the step pose he doesn't move, whatever the d-pad does, until its animation leaves its first frame, and then walks (`$04`) toward a held direction or stands with none. Walking, the same direction keeps him moving; letting go puts him in the step pose without a move, and the other direction puts him in it with one move that way. Code The step pose lasts 6 frames: its animation (sub-type `$0D`, descriptor `$01`,`$05` at `$BB28` in bank `$13`) holds its first frame until its tick count, reset with the sub-type, reaches 5. So from standing, or on a turn, a held direction moves Mega Man on the first frame, holds him still on the next 5, and walks from the 7th; letting go of a walk holds him 6 frames, whatever the d-pad does, before he stands or walks on. Measured in Mesen from power-on at the start of Stone Man's stage. Verified	From standing, a held direction moves Mega Man one frame at the walking speed, `$01`.`$4C` (1.30 px/frame) from the table at `$8BEA`, then holds him in the step pose while a counter of 6 (`$95`) runs out, and walks at 1.30 px/frame from the 7th frame. That is on ordinary floor: on surface type `$05` he walks at once, on `$15` he carries momentum at up to 2 px/frame (momentum-surfaces), and in tile type `$09` he walks at 0.5 px/frame (slow-surface). Measured in Mesen from power-on, at the start of Tomahawk Man's stage, Right moved him 1.30 px on frame 1, not at all on frames 2 to 6, and 1.30 px on each frame after. Verified On the ground Mega Man 6 runs one of three loops, each ending its frame with a yield and reading the next frame's input after it. Standing, a held direction turns him and starts the step: one move at the walking speed, then 5 frames still (walk-start); after it a held direction walks on, turning to it, and none stands him. Walking, letting go stands him on the same frame, and a held direction against his facing turns him at once and walks on with no new step. A fresh A press jumps from any of the three, before that frame's move, or slides with Down held, except on the frame a walk's direction is let go: that frame goes straight to the standing loop's move, and the press is lost. Down alone does nothing. Code Each frame, after a loop's checks, Mega Man 6 makes one move through code_3886CE: on ordinary floor and in the air alike, the horizontal speed comes from the d-pad's table at `$8BEA`, 1.30 px/frame or 0; gravity is added to the vertical speed; he moves by both speeds in 8.8 fixed point; and the tile checks run after the move (collision-order). Code On tile type `$09` (`$064B`) Mega Man moves slower: a jump starts at `$FB`.`$CC` (4.20 px/frame up), the slide at 1.5 px/frame, and walking at 0.5 px/frame, from the tables at `$8009` and `$8BF6`. Code On surface types `$05` and `$15` his walking speed is a carried momentum (`$A1`.`$A0`). A held direction sets it to full speed at once, 1.30 px/frame on `$05` and 2 px/frame on `$15`; with nothing held it slows by 6/256 px/frame each frame, and holding the other way slows it by 12/256 (computed), until its sign flips and it stops. Code
Sound effects		Mega Man 2's sound effect reader is Mega Man's, instruction for instruction and with the same RAM, moved $100C lower: only its jump and call addresses and the addresses in its command table differ. Code		Mega Man 4's sound effect reader is Mega Man 3's (labeled `parse_music_data` there), byte for byte at the same address. Code	Mega Man 5's sound effect reader is Mega Man 4's, byte for byte at the same address. Code Mega Man 5's fixed-bank routine that adds a sound to the queue is Mega Man 4's, byte for byte (27 bytes), at $EC5B where Mega Man 4 has it at $F6BC. Code	Mega Man 6's sound effect stream reader is Mega Man 5's, one byte lower ($8251 against $8252); only its call and jump targets and jump-table entries differ. Code Mega Man 6's sound effects $61 and $62, at $BE99-$BEE7 of bank $36, are byte for byte Mega Man 5's $17 and $18, the first two effects after its music. Verified
Sprite flicker		On even frames `_sprites` writes Mega Man's object slots (0 to `$0F`), then the enemies' (`$10` to `$1F`), then the energy meters; on odd frames it writes the meters first and the slots in reverse, `$1F` down to `$10`, then `$0F` down to 0, so objects that lose the 8-per-scanline race lose it only every other frame. Code
Stage select						uses
Status bar split		Mega Man 2 draws its energy meters as sprites, not a split screen; each meter is a column of 7 sprites from Y `$18` down to `$48`, each showing 0-4 units, at X `$10` for the weapon, `$18` for life, and `$28` for a boss. Code
Tile collision			Both games find the 32-pixel block at a point in the screen's layout and then its 16-pixel quarter, but Mega Man 3's tile check is new code with a new type format. Mega Man 2's `_tsa_collision` tests one point a call and takes its type from the quarter byte's top two bits, which a per-stage table remaps; Mega Man 3's `check_tile_collision` tests a list of points from a hitbox table in one call, clamps them to the screen, takes each type from the upper four bits of the tile's entry in a table at $BF00 in the stage bank, and ORs the types together. Code	Mega Man 4's four routines that push an entity out of a wall, ceiling, or floor after a tile hit are Mega Man 3's `snap_x_to_wall_right`, `snap_x_to_wall_left`, `snap_y_to_ceil`, and `snap_y_to_floor` instruction for instruction; only the addresses of the entity position arrays differ. Mega Man 3 follows them with two calls into its boss door bank, which Mega Man 4 doesn't have there. Code Mega Man 4's four routines that move an entity by its speed and stop it at a wall, floor, or ceiling follow Mega Man 3's `move_right_collide`, `move_left_collide`, `move_down_collide`, and `move_up_collide` step for step. Each saves the player's position before the move, checks for a platform, pushes the player off it, and on a push that crosses a screen retries with the opposite side's tile check. Two things changed. Each tile check is one call, where Mega Man 3 calls its tile check and then `update_collision_flags`. And when the right mover hits a solid tile, Mega Man 4 first copies $45 to $3F for the player, which its disassembly reads as the ground tile type. Two of the screen-crossing tests also test their two flags in the other order, to the same effect. Code	Mega Man 5's four routines that push an object out of a wall, ceiling, or floor after a tile hit are Mega Man 4's, byte for byte but for one instruction: after a ceiling hit, Mega Man 5 clears the carry before adding where Mega Man 4 sets it, so the object ends one pixel higher than in Mega Man 4. Mega Man 5 follows them with four new routines that move an object along X or Y by the amount in $10 or $11 and compare its position with one saved in $02-$03. Code Mega Man 5's routines that move an object right, left, down, or up and then check tiles, and for the player the platforms it stands on, follow Mega Man 4's with three changes besides addresses. The facing flag they set or clear is bit 5 of the object's flags, where Mega Man 4 uses bit 6. A right-wall hit no longer copies the player's ground tile type from $45 to $3F. And before a vertical move, Mega Man 5 saves the player's vertical screen in $03, where Mega Man 4 saves its horizontal screen. Code
Variable jump height	On every rising frame with A not held, Mega Man's upward speed, if its whole part is 2 or more, drops to exactly 1 px/frame; the test follows the frame's vertical move. Code	In the jumping state, with A not held, `_run_megaman_jumping` drops an upward speed of 2 px/frame or more to exactly 1 px/frame. Code The release cut tests only the speed's whole byte, so it applies at 2 px/frame or more and leaves a slower rise alone. Code `_run_megaman_jumping` checks the release after the frame's move and gravity, so the capped speed first moves Mega Man on the next frame. Code Gravity brings the 4.87 px/frame take-off under 2 px/frame on frame 13, so letting go of A after 12 frames changes nothing. Verified Measured in the game, Mega Man's jump peaks at 8 px on frame 5 when A is tapped and at 50 px on frame 19 when it is held 12 frames or more, landing on frames 15 and 41. Verified	On every rising frame without A held, Mega Man 3 sets the vertical speed to `$FF`.`$C0`, 0.25 px/frame downward, whatever the speed was, before the frame's move. Mega Man 2 only lowers a rise of 2 px/frame or more to 1, after the move. Code	Mega Man 4 takes off at exactly 5 px/frame (`$05`.`$00`), up from Mega Man 3's `$04`.`$E5`, and a release cuts any rise to a speed of 0 where Mega Man 3 sets 0.25 px/frame downward. Both cut on every rising frame without A. Code A jump moves Mega Man on its press frame. The ground state has already run the air routine and found the floor; the A press sets 5 px/frame and runs the air routine again, which lifts him 5 px and moves him by the air's rules, so the ground's own walk doesn't run that frame. Measured in Mesen from power-on, standing where he lands at the start of Skull Man's stage, a jump's first frame raised his Y by exactly 5 px. Verified	Mega Man 5 keeps Mega Man 4's jump. Both write 5 px/frame (`$05`.`$00`) into the vertical speed at `$03F0`/`$03D8` on a jump, and set it to 0 on any rising frame without A. Code	On a rising frame without A, Mega Man 6 sets the whole-pixel byte of his vertical speed to 0 and keeps its fraction, so he starts down at once at under 1 px/frame; Mega Man 5 sets both bytes to 0. Outside tile type `$08` the cut waits until the rise is no faster than 5 px/frame (`$05C8` at `$FB` or above), and it needs bits `$0C` of the fraction set, which they always are under the normal gravity, since the jump's `$CC` gains `$40` a frame. Measured in Mesen from power-on at the start of Tomahawk Man's stage, with A let go after 3 frames, the 4th frame left him falling at 0.80 px/frame (`$00`.`$CC`). Verified
VRAM buffer				Mega Man 4's name table buffer flush is Mega Man 3's `drain_ppu_buffer`, byte for byte (37 bytes). Mega Man 4 follows it with four short routines: two that change PPUCTRL and two that turn rendering off and on. Code	Mega Man 5's name table buffer flush and the four PPU routines after it are Mega Man 4's instruction for instruction; only the zero-page counter the rendering switches step differs ($EA in Mega Man 4, $F0 in Mega Man 5). Code
Weapon energy		Each weapon has its own energy byte, filled to 28 (`$1C`) before a Robot Master stage or the first Wily stage but not before the later Wily stages; each weapon's routine takes its own cost, such as 2 per Air Shooter shot, 4 per Crash Bomber, and 1 per 4 Metal Blades counted on a shared counter. Code	Mega Man 3 moves weapon costs into two tables indexed by weapon: `weapon_cost`, the units taken, and `weapon_framerate`, how many uses (or frames, for Rush Marine and Rush Jet) each take costs, counted on one shared counter. Needle Cannon costs 1 unit per 4 shots and Gemini Laser 2 per shot. Mega Man 2 writes the costs into the weapons' own routines, as its Air Shooter, Crash Bomber, and Metal Blade code shows. Code

Code lineage

From	To	Match	Bytes	What
Mega Man `audio-control`	Mega Man 2 `audio-control`	changed	565	Mega Man 2's sound engine entry and channel setup are Mega Man's, with two changes: `_music_fade_in_out` no longer ignores a new fade while one is running, and where Mega Man steps X with INX, four operands use an address plus 1 instead and one writes `SQ1_SWEEP` plus X. The engine starts at $8000 instead of $9000, so its jump and call addresses differ too.
Mega Man `audio-music-reader`	Mega Man 2 `audio-music-reader`	relocated	705	Mega Man 2's song data reader is Mega Man's, instruction for instruction and with the same RAM, so the two games read the same note and command format. It sits $100C lower: only its jump and call addresses, its command table, and the address of the note table differ.
Mega Man `audio-processing`	Mega Man 2 `audio-processing`	changed	824	Mega Man 2's per-frame channel update is Mega Man's, except that `_break_frame` and the end of `_pitch_envelope_common` address the next APU register as `SQ1_SWEEP` plus X, where Mega Man steps X with INX and writes `SQ1_VOL` plus X. The code sits $100A lower, so its jump and call addresses differ too.
Mega Man `audio-sfx-reader`	Mega Man 2 `audio-sfx-reader`	relocated	327	Mega Man 2's sound effect reader is Mega Man's, instruction for instruction and with the same RAM, moved $100C lower: only its jump and call addresses and the addresses in its command table differ.
Mega Man `audio-tables`	Mega Man 2 `audio-tables`	changed	219	Mega Man 2's note length and pitch tables are Mega Man's but for one pitch: the period of the note the disassembly names `nEb1` drops from $059E to $0594, about 12 cents higher (computed). The region also ends with 3 bytes of $FF filler instead of 7.
Mega Man `b0-menu-font-tiles`	Mega Man 2 `stage-common-tiles`	identical	96	Mega Man 2's six menu border tiles, the end of its common stage tiles, are Mega Man's six menu tiles, byte for byte.
Mega Man `b0-menu-font-tiles`	Mega Man 2 `ready-font-tiles`	changed	80	Mega Man 2's five READY letter tiles have Mega Man's letter shapes, row for row, but in each tile's second bit plane instead of its first, so the letters draw in color 2 of their palette where Mega Man's draw in color 1.
Mega Man `bankswitch`	Mega Man 2 `bankswitch`	rewritten	81	Both games' bank switch routines map a PRG bank at $8000, but Mega Man 2's is new code for a different board: Mega Man writes the bank number once, to its own byte of a bank table (the disassembly's `uxrom_prg_bank`), and Mega Man 2 writes it to MMC1 one bit at a time, then runs any sound an NMI put off during the switch.
Mega Man `create-explosion`	Mega Man 2 `create-explosion`	identical	60	Mega Man 2's death explosion takes its twelve pieces' x and y speeds and facing flags from five 12-byte tables identical to Mega Man's explosion tables. The code around them is new: Mega Man's `_create_explosion_object` sets up one piece per call, and Mega Man 2's `_create_explosion` loops over all twelve.
Mega Man `cutman-wily1-map`	Mega Man 2 `metalman-map`	identical	1,024	The last 16 screens of Metal Man's map, $1C to $2B (1,024 bytes), are byte for byte the last 16 of Mega Man's Cut Man and Wily stage 1 map: Cut Man's screens $0C to $0F and Wily stage 1's $10 to $1B. Metal Man's screens $18 to $1B repeat four of them, Wily stage 1's $18 to $1B.
Mega Man `joy`	Mega Man 2 `joy`	relocated	30	Mega Man 2's `_joy` is Mega Man's, line for line; only the two button bytes it writes moved in zero page, from $14 and $18 to $23 and $27.
Mega Man `nmi-wait`	Mega Man 2 `nmi-wait`	changed	129	Mega Man 2's `_nmi_wait_0e` and `_nmi_wait_0d` keep the steps of Mega Man's `_nmi_wait`: save the last buttons, wait for the NMI, call `_joy`, and mark the newly pressed buttons. The two differ only in the bank they map at the end, and each first calls `_background_palette`. Mega Man 2 drops the path for buttons the game forces and moves the water frame into `_nmi_wait_water`.
Mega Man `object-tiles`	Mega Man 2 `object-tiles-update`	changed	26	Mega Man 2's `_object_tiles_update` is the loop Mega Man enters at `_init_object_tiles`, which copies the tile buffer to CHR RAM, with its RAM at new addresses. Mega Man 2 drops the test in front of it and the `_object_tiles_update_yellow_devil` path, which writes two bytes at each of several PPU addresses, a row ($20) apart.
Mega Man `scrolling`	Mega Man 2 `scrolling`	changed	246	Mega Man 2's `_scrolling_vertical` follows Mega Man's `_scrolling_up_down`: the same name table and attribute address math and the same loop writing four 8x8 tiles per 16x16 quarter. Mega Man 2 computes the 32x32 block's address from the screen number, where Mega Man looks the screen up in a pointer table and checks `_special_blockset_collision` for a block the disassembly labels removed; some of its RAM moved too. The rest of each region is different code.
Mega Man `stage-loop`	Mega Man 2 `stage-start-main-loop`	rewritten	273	Both games' stage loops run a frame of play and wait for the NMI, but Mega Man 2's is new code: it calls its own routines in its own order, opens the menu on Start with no Select pause, and waits an extra frame now and then in water. Its region also starts the stage before the loop.
Mega Man `title-tiles`	Mega Man 2 `opening-title-tiles`	identical	1,344	Tiles 1 to 84 of Mega Man 2's title screen patterns (1,344 bytes) are byte for byte tiles 1 to 84 of Mega Man's.
Mega Man 2 `airman-ai`	Mega Man 3 `doc-air`	identical	155	Doc Robot's Air Man fight in Mega Man 3 uses Air Man's tornado tables from Mega Man 2 byte for byte (155 bytes): the five delays between rounds, then five patterns of six tornadoes each, with their Y and X speeds (whole and fraction) and how long each flies.
Mega Man 2 `audio-control`	Mega Man 3 `sound-driver-entry`	rewritten	108	Both games run their sound driver from the NMI, but Mega Man 3's is new code with a new layout. Mega Man 2 keeps the driver and its songs together in bank 12, queues up to 16 tracks, and works out a note's length as a table value times its channel's tempo byte. Mega Man 3 keeps the code in bank 22 and the data in bank 23, reading bank 24 for data addresses from $C000; it takes sound IDs from an eight-entry ring buffer in the fixed bank, and refuses a sound whose priority byte is lower than the one playing.
Mega Man 2 `bankswitch`	Mega Man 3 `select-prg-banks`	rewritten	37	Both games flag a bank switch in progress and catch up on the frame's sound afterward if the NMI arrived during it, but Mega Man 3's switch is new code for a different board: Mega Man 2 maps one 16 KB bank at $8000 by writing its number to MMC1 one bit at a time, and Mega Man 3 writes two 8 KB banks, at $8000 and $A000, to the MMC3 as whole bytes.
Mega Man 2 `divide`	Mega Man 3 `divide`	changed	103	Mega Man 3's `divide_8bit` is Mega Man 2's `_divide_mod` with its zero-page operands one byte lower ($00-$03 for $01-$04). Its 16-bit division is Mega Man 2's `_divide_fraction` with its RAM moved and two changes: Mega Man 3 saves and restores X around the loop, and stores the low byte of each successful subtraction back in the remainder ($01), where Mega Man 2 writes it to $09, outside its shift chain.
Mega Man 2 `enemy-collide-and-move`	Mega Man 3 `gravity-mover`	rewritten	132	Both games move an object each frame by a speed with a fraction and change its Y speed by gravity, but Mega Man 3's movers are new code that Mega Man and the enemies share. Mega Man 2's enemy routine, left undecoded by its disassembly, checks the object's hits, moves it by its Y speed, subtracts gravity from that speed when a flag bit asks for it, moves it by its X speed in the way it faces, and removes it once it leaves the screen; walls and floors are a separate routine, and Mega Man moves with his own code. Mega Man 3's `move_vertical_gravity` and `move_right_collide` serve slot 0, the player, and every enemy alike, and run the tile check inside each move, snapping the object to the floor, ceiling, or wall it reaches.
Mega Man 2 `find-objects`	Mega Man 3 `enemy-spawn-check`	changed	128	Mega Man 3's `check_new_enemies` is the enemy half of Mega Man 2's `_find_objects`, instruction for instruction, with new RAM and table addresses: both take the screen's left and right edges, then on the side the screen moves toward spawn each placement that comes into range and on the other side move a second cursor past placements left behind. Mega Man 3 drops Mega Man 2's matching walk over a separate item list and the switch to the stage bank around it. The spawn routine each calls starts the same way, skipping a placement already in a slot and taking a free one, and then differs: Mega Man 2 fills the slot from per-type tables in its fixed bank, and Mega Man 3 skips a placement marked defeated and copies the type's properties from bank 0.
Mega Man 2 `font-3`	Mega Man 3 `chr-wily-background-b`	identical	160	Mega Man 3's background CHR bank $66, mapped for Wily stage 6, holds 27 of the 31 non-blank tiles of Mega Man 2's third font set (the disassembly's `font_3.chr`), the longest aligned run 10 tiles (160 bytes).
Mega Man 2 `heatman-wily1-sprite-tiles-l11`	Mega Man 3 `chr-player-and-weapon-sprites`	identical	384	Mega Man 3's sprite CHR banks $00-$01, mapped at sprite tiles $00-$7F throughout play, start from Mega Man 2's first 128 sprite tiles (the disassembly's `megaman_capsule_e_tank_bullet_mega_buster.chr`): 84 of the 127 non-blank tiles are the same at the same numbers, the longest run tiles $20-$37 (384 bytes).
Mega Man 2 `heatman-wily1-sprite-tiles-l11`	Mega Man 3 `chr-stage-sprites`	identical	336	The first 32 tiles of 17 of Mega Man 3's sprite CHR banks ($08, $0A, $0C, $0F, $11, $13, $15, $1D, $20, $24, $26, $27, $2A, $2C, $2E, $32, and $3C) are Mega Man 2's sprite tiles $60-$7F, from the same set as Mega Man's own: 29 of the 32 are the same at the same numbers, the longest run tiles $0B-$1F (336 bytes).
Mega Man 2 `joy`	Mega Man 3 `read-controllers`	rewritten	88	Both games strobe the controllers and merge each port's two data bits, but Mega Man 3's routine is new code. Mega Man 2's `_joy` reads one pad after the other and leaves the newly pressed buttons to the frame wait that calls it; Mega Man 3's `read_controllers` reads both pads in one loop, works out the new presses itself, and clears the d-pad when opposite directions are held together.
Mega Man 2 `metalman-sprite-tiles-l199`	Mega Man 3 `chr-doc-robot-sprites`	identical	144	Mega Man 3's sprite CHR bank $22 holds 17 tiles of Mega Man 2's boss sets, 9 from Wood Man's and 8 from Heat Man's, and bank $21 holds 4 of Crash Man's; the longest run is 9 of Wood Man's tiles (144 bytes).
Mega Man 2 `nmi`	Mega Man 3 `nmi`	rewritten	231	Both games' NMI handlers copy the sprites by DMA, write the queued screen and palette updates, set the scroll, and run the sound driver, but Mega Man 3's handler is new code. Mega Man 2's offsets the scroll for the Mecha Dragon and puts the sound off when the NMI interrupts a bank switch; Mega Man 3's also loads the MMC3's scanline counter for the frame's split-screen interrupt and picks the interrupt handler for the screen mode.
Mega Man 2 `nmi-wait`	Mega Man 3 `task-scheduler`	rewritten	146	Both games run a stage a frame at a time in step with the NMI, but Mega Man 3's frame loop is new code built on a task scheduler. Mega Man 2's stage loop calls its routines in turn and then spins in `_nmi_wait_0e` until the NMI sets a flag, reading the pads after it. Mega Man 3 runs up to four tasks, each resumed from its own saved stack pointer; `gameplay_frame_loop` gives up the CPU for a frame through the scheduler, which reads the controllers only when it resumes task 0.
Mega Man 2 `opening-title-tiles`	Mega Man 3 `chr-title-background`	identical	256	Mega Man 3's title screen background tiles (CHR banks $76-$77) are largely Mega Man 2's title set (`title.chr`, loaded at `_load_title_chr`), moved a few tile numbers: 102 of their 128 non-blank tiles appear in it, 96 different ones, in runs of up to 16 tiles (256 bytes).
Mega Man 2 `stage-select`	Mega Man 3 `stage-select-input`	rewritten	298	Both games' stage selects move a cursor over the bosses' portraits and start the chosen stage, but Mega Man 3's is new code. Mega Man 2's `_stage_select` blanks a beaten boss's portrait by writing empty tiles to the name table, and on a d-pad press calls `_stage_select_set` to move the cursor; Mega Man 3 keeps the cursor's column and row apart, moves each by a table offset and ignores a move off its 3 by 3 grid, redraws the six sprites of Mega Man's eyes in the center portrait for the cursor's position, and confirms on A as well as Start.
Mega Man 2 `tsa-collision`	Mega Man 3 `tile-check-vertical`	rewritten	333	Both games find the 32-pixel block at a point in the screen's layout and then its 16-pixel quarter, but Mega Man 3's tile check is new code with a new type format. Mega Man 2's `_tsa_collision` tests one point a call and takes its type from the quarter byte's top two bits, which a per-stage table remaps; Mega Man 3's `check_tile_collision` tests a list of points from a hitbox table in one call, clamps them to the screen, takes each type from the upper four bits of the tile's entry in a table at $BF00 in the stage bank, and ORs the types together.
Mega Man 2 `wily-sprite-tiles-b8`	Mega Man 3 `chr-screen-sprites`	identical	96	Mega Man 3's sprite CHR bank $3C holds 13 of the 23 non-blank tiles of Mega Man 2's set of Dr. Wily bowing down (the disassembly's `dogeza.chr`), six of them in a run (96 bytes).
Mega Man 3 `boss-door-close`	Mega Man 4 `boss-door-animation`	changed	207	Mega Man 4's first boss door routine follows Mega Man 3's `close_boss_door` step for step: the door sound, then four 16x16 blocks of tiles and attributes through the same buffer, one every 4 frames. Mega Man 4 runs it from the fixed bank, with the stage's bank mapped at $A000, and reads the door's addresses and tiles from fixed places in that bank ($B570-$B57B), where Mega Man 3 indexes tables in its door bank by the door's number.
Mega Man 3 `boss-door-open`	Mega Man 4 `boss-door-animation`	changed	195	Mega Man 4's second boss door routine follows Mega Man 3's `open_boss_door` the same way, with the same changes: it runs from the fixed bank and reads its door's data from $B57C-$B587 in the stage's bank.
Mega Man 3 `chr-password-background`	Mega Man 4 `chr-wily1-background`	identical	416	Mega Man 4 has Mega Man 3's 26 letter tiles, A to Z, byte for byte (416 bytes), in its bank 19 at $9800. Mega Man 3 has two copies, in its password screen tiles (after its digits 0 to 9) and in its stage start sprite tiles; Mega Man 4's digits before them differ.
Mega Man 3 `chr-player-and-weapon-sprites`	Mega Man 4 `chr-common-sprites`	identical	912	The first 57 sprite tiles ($00-$38) of the set Mega Man 4 shares across its stages (912 bytes) are byte for byte the first 57 tiles of Mega Man 3's sprite CHR banks $00-$01, the set it maps throughout play. Of the first 128 tiles, 96 are the same at the same numbers.
Mega Man 3 `chr-title-background`	Mega Man 4 `chr-menu-and-cossack-map-background`	changed	2,048	Mega Man 4's bank 20 holds, at $8800-$8FFF, Mega Man 3's 128 title screen background tiles (CHR banks $76-$77), the same in all but two: tiles $20 and $2F, which in Mega Man 4 are plain outlined squares.
Mega Man 3 `collide-movers`	Mega Man 4 `entity-movers`	changed	248	Mega Man 4's four routines that move an entity by its speed and stop it at a wall, floor, or ceiling follow Mega Man 3's `move_right_collide`, `move_left_collide`, `move_down_collide`, and `move_up_collide` step for step. Each saves the player's position before the move, checks for a platform, pushes the player off it, and on a push that crosses a screen retries with the opposite side's tile check. Two things changed. Each tile check is one call, where Mega Man 3 calls its tile check and then `update_collision_flags`. And when the right mover hits a solid tile, Mega Man 4 first copies $45 to $3F for the player, which its disassembly reads as the ground tile type. Two of the screen-crossing tests also test their two flags in the other order, to the same effect.
Mega Man 3 `divide`	Mega Man 4 `entity-aim`	identical	103	Mega Man 4's 8-bit and 16-bit division routines, used to aim enemies, are Mega Man 3's `divide_8bit` and its 16-bit version, byte for byte (103 bytes), at $FC14 in its fixed bank where Mega Man 3 has them at $FCEB.
Mega Man 3 `drain-ppu-buffer`	Mega Man 4 `nametable-flush-ppu-control`	identical	37	Mega Man 4's name table buffer flush is Mega Man 3's `drain_ppu_buffer`, byte for byte (37 bytes). Mega Man 4 follows it with four short routines: two that change PPUCTRL and two that turn rendering off and on.
Mega Man 3 `enemy-spawn-check`	Mega Man 4 `spawn-engine`	relocated	128	Mega Man 4's enemy spawn engine is Mega Man 3's `check_new_enemies` instruction for instruction, moved from bank 26 at $9C00 to bank 56 at $8000; only the addresses of the stage's placement tables and one zero-page variable ($2E in Mega Man 3, $2F in Mega Man 4) differ.
Mega Man 3 `fill-nametable`	Mega Man 4 `fill-nametable`	identical	76	Mega Man 4's routine that fills a name table and its attributes with one value is Mega Man 3's `fill_nametable`, byte for byte.
Mega Man 3 `frequency-output`	Mega Man 4 `frequency-output`	identical	224	Mega Man 4's code that writes each channel's pitch to the APU, with vibrato, detune, and slides, is Mega Man 3's, byte for byte at the same address.
Mega Man 3 `music-parser`	Mega Man 4 `sfx-stream`	identical	321	Mega Man 4's sound effect reader is Mega Man 3's (labeled `parse_music_data` there), byte for byte at the same address.
Mega Man 3 `note-frequency`	Mega Man 4 `note-frequency`	identical	220	Mega Man 4's note-to-pitch routines are Mega Man 3's, byte for byte at the same address.
Mega Man 3 `plain-movers`	Mega Man 4 `plain-movers`	changed	258	Mega Man 4's routines that move an entity by its speed without checking tiles, and apply gravity, follow Mega Man 3's with the entity arrays moved, and with four changes. Mega Man 4 drops Mega Man 3's routine that sets a behind-the-background flag from the tile hit. Its gravity tests one flag at $43 first, where Mega Man 3 tests for the player and then a flag at $B9. It drops Mega Man 3's exemption, for one animation ($13), from the cap on falling speed. And when gravity resets, it sets one speed ($FF00) for every entity, where Mega Man 3 sets $FFC0 for the player and $FFAB for the rest.
Mega Man 3 `play-sound`	Mega Man 4 `play-sound`	identical	340	Mega Man 4's routine that starts a song or an effect, and takes the stop, pause, fade, and transpose commands, is Mega Man 3's, byte for byte at the same address.
Mega Man 3 `read-controllers`	Mega Man 4 `read-controllers`	identical	88	Mega Man 4's controller read, which works out the new presses and cancels opposite directions, is Mega Man 3's `read_controllers`, byte for byte.
Mega Man 3 `rendering-on-off`	Mega Man 4 `nametable-flush-ppu-control`	relocated	40	Mega Man 4's four routines after its name table buffer flush, two that reset or set bits of PPUCTRL and two that turn rendering off and on, are Mega Man 3's `disable_nmi`, `dead_code_enable_nmi`, `rendering_off`, and `rendering_on` instruction for instruction; only the zero-page counter the last two step differs ($EE in Mega Man 3, $EA in Mega Man 4).
Mega Man 3 `sfx-channel`	Mega Man 4 `music-track-reader`	identical	587	Mega Man 4's music track reader is Mega Man 3's (labeled `process_sfx_channel` there), byte for byte at the same address, so the two games read the same track format.
Mega Man 3 `sound-driver-entry`	Mega Man 4 `sound-driver-entry`	changed	108	Mega Man 4's sound bank opens with Mega Man 3's entry jumps, multiply, and sound-data read, at the same addresses; only the two bank numbers the read maps differ: the overflow data bank, $18 in Mega Man 3 and $1D in Mega Man 4, and the data bank it restores, $17 and $1F.
Mega Man 3 `sound-driver-tables`	Mega Man 4 `sound-driver-tables`	changed	299	Mega Man 4's sound driver tables, through the note period table, are Mega Man 3's at the same addresses; the 37 bytes after it ($8A1B-$8A3F), all zero in Mega Man 3, hold data in Mega Man 4.
Mega Man 3 `sound-driver-update`	Mega Man 4 `sound-driver-update`	identical	146	Mega Man 4's per-frame sound tick is Mega Man 3's `sound_driver_update`, byte for byte at the same address.
Mega Man 3 `sprite-offsets-default`	Mega Man 4 `anim-0c-player-sprite-data`	identical	304	304 bytes of Mega Man 3's default sprite position offsets, $A078-$A1A7 of its bank $19, are byte for byte in Mega Man 4's player animation bank $0C at $97BE-$98ED. They are position sets $08-$17 in both games' pointer tables: sixteen lists of signed Y and X offsets, one pair per tile, 4 to 12 tiles each.
Mega Man 3 `task-scheduler`	Mega Man 4 `task-scheduler`	relocated	146	Mega Man 4's cooperative task scheduler, with its routines to start, kill, and yield tasks, is Mega Man 3's `task_scheduler` instruction for instruction; it sits 5 bytes lower, and only its jump and call addresses differ.
Mega Man 3 `volume-envelope`	Mega Man 4 `volume-envelope`	identical	379	Mega Man 4's volume envelope and fade code is Mega Man 3's, byte for byte at the same address.
Mega Man 3 `wall-snap`	Mega Man 4 `tile-alignment`	relocated	102	Mega Man 4's four routines that push an entity out of a wall, ceiling, or floor after a tile hit are Mega Man 3's `snap_x_to_wall_right`, `snap_x_to_wall_left`, `snap_y_to_ceil`, and `snap_y_to_floor` instruction for instruction; only the addresses of the entity position arrays differ. Mega Man 3 follows them with two calls into its boss door bank, which Mega Man 4 doesn't have there.
Mega Man 4 `bank-switch-apply`	Mega Man 5 `bank-switching`	identical	37	Mega Man 5's routine that maps the two switchable PRG banks from their shadows, and then runs a sound request that arrived while it was busy, is Mega Man 4's, byte for byte (37 bytes). Mega Man 5 enters it through 6 new bytes that set both shadows from one bank number, the bank and the one after it.
Mega Man 4 `bank24-tail`	Mega Man 5 `chr-bank-18`	identical	832	52 tiles of Mega Man 4's font in bank 36 ($BB00-$BE3F), which look like Japanese kana when drawn out, are byte for byte tiles in Mega Man 5's CHR at $30300-$3063F (832 bytes).
Mega Man 4 `chr-menu-and-cossack-map-background`	Mega Man 5 `chr-bank-18`	identical	2,048	Mega Man 5's CHR at $31800-$31FFF holds the 128 background tiles of Mega Man 4's bank 20 at $8800-$8FFF, byte for byte (2,048 bytes): the block Mega Man 4 took from Mega Man 3's title screen tiles, with Mega Man 4's two changed tiles.
Mega Man 4 `chr-wily1-background`	Mega Man 5 `chr-bank-19`	identical	416	Mega Man 5 has the 26 letter tiles, A to Z, that Mega Man 4 took from Mega Man 3, byte for byte (416 bytes), in its CHR at $32410.
Mega Man 4 `distance-and-direction`	Mega Man 5 `distance-and-direction`	changed	181	Mega Man 5's routines for an object's distance to the player on each axis, and the direction to him in 16 steps, are Mega Man 4's, with two changes. It adds two routines that measure the same two distances to another slot's object. And its direction routine starts by setting Y to 0, the player's slot, and falls into the copy of slot Y's position, where Mega Man 4 has a separate entry that copies the player's position and jumps on. The rest is byte for byte, except the address of the 48-byte direction table, which is the same in both and follows the code directly in Mega Man 5.
Mega Man 4 `entity-aim`	Mega Man 5 `aim-and-divide`	identical	103	Mega Man 5's 8-bit and 16-bit division routines are Mega Man 4's, which are Mega Man 3's, byte for byte (103 bytes), at $F207 in its fixed bank.
Mega Man 4 `entity-movers`	Mega Man 5 `entity-movers`	changed	240	Mega Man 5's routines that move an object right, left, down, or up and then check tiles, and for the player the platforms it stands on, follow Mega Man 4's with three changes besides addresses. The facing flag they set or clear is bit 5 of the object's flags, where Mega Man 4 uses bit 6. A right-wall hit no longer copies the player's ground tile type from $45 to $3F. And before a vertical move, Mega Man 5 saves the player's vertical screen in $03, where Mega Man 4 saves its horizontal screen.
Mega Man 4 `fill-nametable`	Mega Man 5 `fill-and-clear`	identical	76	Mega Man 5's routine that fills a name table and its attributes with one value is Mega Man 4's, byte for byte; Mega Man 5 follows it with routines that clear the sprite buffer and the object slots.
Mega Man 4 `frequency-output`	Mega Man 5 `frequency-output`	identical	224	Mega Man 5's code that writes each channel's pitch to the APU, with vibrato, detune, and slides, is Mega Man 4's, byte for byte at the same address.
Mega Man 4 `music-track-reader`	Mega Man 5 `music-track-reader`	identical	587	Mega Man 5's music track reader is Mega Man 4's, byte for byte at the same address.
Mega Man 4 `nametable-flush-ppu-control`	Mega Man 5 `nametable-flush-ppu-control`	relocated	77	Mega Man 5's name table buffer flush and the four PPU routines after it are Mega Man 4's instruction for instruction; only the zero-page counter the rendering switches step differs ($EA in Mega Man 4, $F0 in Mega Man 5).
Mega Man 4 `note-frequency`	Mega Man 5 `note-frequency`	identical	220	Mega Man 5's note-to-pitch routines is Mega Man 4's, byte for byte at the same address.
Mega Man 4 `plain-movers`	Mega Man 5 `entity-collide-movers`	changed	345	Mega Man 5's routines that move an object by its speed without checking tiles, and apply gravity, follow Mega Man 4's, with the gravity amount at $A1 instead of $99 and these changes. Eight bytes before the left mover clear the facing bit and fall into it. The player's gravity is skipped whenever a flag at $52 is set, where Mega Man 4 skips it only while a timer at $43 counts down. And Mega Man 5 adds four routines after them, one of which adds gravity to the vertical speed instead of subtracting it, capped at 7 pixels a frame.
Mega Man 4 `platform-collision`	Mega Man 5 `platform-collision`	changed	288	Mega Man 5's two checks for a platform object that the player meets moving vertically or horizontally, and their two distance helpers, follow Mega Man 4's test for test. Both walk the slots down from $17 and skip empty, off-screen, and non-solid ones. A one-way platform only catches a falling player, and the push is capped at 8 pixels. The changes: both checks also give up unless the moving object's own Y screen is 0. The horizontal check skips objects of type $02. The helper reads both of the shape's sizes from two tables through X, which it then sets to 0, the player's slot, where Mega Man 4 looks up the second size in the vertical check itself. The smaller box for a sliding player is chosen by `player_state` $02, where Mega Man 4 tests the player's sub-type for $10. And the horizontal distance helper no longer masks the screen difference to one bit. The four routines that push the player off a platform, which close Mega Man 4's region, sit after the position nudges in Mega Man 5.
Mega Man 4 `play-sound`	Mega Man 5 `play-sound`	identical	340	Mega Man 5's routine that starts a song or an effect, and takes the stop, pause, fade, and transpose commands, is Mega Man 4's, byte for byte at the same address.
Mega Man 4 `queue-sound`	Mega Man 5 `queue-sound`	identical	27	Mega Man 5's fixed-bank routine that adds a sound to the queue is Mega Man 4's, byte for byte (27 bytes), at $EC5B where Mega Man 4 has it at $F6BC.
Mega Man 4 `read-controllers`	Mega Man 5 `read-controllers`	changed	94	Mega Man 5's controller read is Mega Man 4's, byte for byte, with one addition: before it returns, it zeroes controller 2's new presses and held buttons ($15 and $17).
Mega Man 4 `reset`	Mega Man 5 `reset`	identical	98	Mega Man 5's reset begins with Mega Man 4's first 98 bytes, byte for byte at the same address ($FE00-$FE61): the interrupt, sound, and rendering shutdown, the wait through four vblanks, the PPU address precharge, the RAM clear, the sound queue's empty markers, and the PPU mask shadow. From the mapper setup on, the two differ.
Mega Man 4 `sfx-stream`	Mega Man 5 `sfx-stream`	identical	321	Mega Man 5's sound effect reader is Mega Man 4's, byte for byte at the same address.
Mega Man 4 `sound-driver-entry`	Mega Man 5 `sound-driver-entry`	changed	108	Mega Man 5's sound bank, bank $18, opens with Mega Man 4's entry jumps, multiply, and sound-data read at the same addresses; only the two bank numbers the read maps differ: the overflow data bank, $1D in Mega Man 4 and $1A in Mega Man 5, and the data bank it restores, $1F and $19.
Mega Man 4 `sound-driver-tables`	Mega Man 5 `sound-driver-tables`	changed	299	Mega Man 5's sound driver tables, through the note period table, are Mega Man 4's at the same addresses. The 37 bytes after it ($8A1B-$8A3F), which hold data in Mega Man 4, are all zero in Mega Man 5, as in Mega Man 3.
Mega Man 4 `sound-driver-update`	Mega Man 5 `sound-driver-update`	identical	146	Mega Man 5's per-frame sound tick is Mega Man 4's, byte for byte at the same address.
Mega Man 4 `spawn-engine`	Mega Man 5 `spawn-engine`	relocated	128	Mega Man 5's spawn engine walks its stage's spawn list ahead of and behind the camera with Mega Man 4's code, instruction for instruction; only the addresses differ: the stage's placement tables, the two list cursors ($9E and $9F in Mega Man 4, $AD and $AE in Mega Man 5), the scroll direction flag ($2F, $AC), and the four window temporaries, two bytes higher.
Mega Man 4 `spawn-entry`	Mega Man 5 `spawn-enemy`	changed	173	Mega Man 5's routine that spawns an enemy from a spawn list entry follows Mega Man 4's step for step: the same checks for a live copy and the no-respawn bitmap, and the same slot fill from the entry's position and the parameter tables for its code, with the tables and temporaries at other addresses. It changes two things: it keeps the spawn code in the object's $0510 byte, which Mega Man 4 clears, and it masks bit 7 off the flags parameter and, when that bit is clear, ends by calling `entity_facing_to_flags`.
Mega Man 4 `task-scheduler`	Mega Man 5 `task-scheduler`	relocated	146	Mega Man 5's cooperative task scheduler is Mega Man 4's instruction for instruction; it sits 6 bytes higher, and only its jump and call addresses differ.
Mega Man 4 `tile-alignment`	Mega Man 5 `position-nudges`	changed	216	Mega Man 5's four routines that push an object out of a wall, ceiling, or floor after a tile hit are Mega Man 4's, byte for byte but for one instruction: after a ceiling hit, Mega Man 5 clears the carry before adding where Mega Man 4 sets it, so the object ends one pixel higher than in Mega Man 4. Mega Man 5 follows them with four new routines that move an object along X or Y by the amount in $10 or $11 and compare its position with one saved in $02-$03.
Mega Man 4 `volume-envelope`	Mega Man 5 `volume-envelope`	identical	379	Mega Man 5's volume envelope and fade code is Mega Man 4's, byte for byte at the same address.
Mega Man 5 `aim-and-divide`	Mega Man 6 `divide-16`	relocated	65	Mega Man 6's 16-bit division at $CC70 is Mega Man 5's `div16` at $F22D, except that it saves X in $08 instead of $09.
Mega Man 5 `chr-bank-00`	Mega Man 6 `tiles-bank-00`	identical	176	116 of the 157 non-blank sprite tiles in Mega Man 6's bank $00 at $8000-$89FF (115 distinct) appear in Mega Man 5's sprite CHR at $00000-$01FFF, rearranged: the longest stretch that matches tile for tile is 11 tiles (176 bytes), Mega Man 5's tiles $0A-$14 as Mega Man 6's $0B-$15.
Mega Man 5 `chr-bank-18`	Mega Man 6 `tiles-bank-10`	changed	2,064	Mega Man 6's bank $10 holds, at $8800-$900F, the 129 tiles of Mega Man 5's CHR at $31800-$3200F (2,064 bytes), the title screen block of claim mm4-mm5-title-tiles plus one tile, with one tile changed: the 33rd ($8A00), a hollow square in Mega Man 5 and a circled R in Mega Man 6.
Mega Man 5 `chr-bank-19`	Mega Man 6 `tiles-bank-11`	changed	416	Mega Man 6's bank $11 holds, at $82B0-$844F, Mega Man 5's 26 letter tiles, A to Z, from its CHR at $32410 (416 bytes), with the J redrawn: its hook reaches a pixel further left.
Mega Man 5 `chr-bank-19`	Mega Man 6 `tiles-bank-11`	identical	160	Mega Man 6's background bank $11 has 83 different tiles of Mega Man 5's background CHR at $32000-$33FFF. Besides the 26 letters (claim mm5-mm6-letter-tiles), the ten tiles right before them, at $8200-$829F, are byte for byte Mega Man 5's ten tiles at $32300 (160 bytes); the rest come in stretches of up to 10 tiles.
Mega Man 5 `frequency-output`	Mega Man 6 `frequency-output`	changed	232	Mega Man 6's period output is Mega Man 5's with one step added: after adding the channel's signed offset at $0714 to the period, a period of zero becomes 1. The added 8 bytes push the sound tables seven bytes higher, and the routine's table operands follow.
Mega Man 5 `music-track-reader`	Mega Man 6 `music-track-reader`	relocated	587	Mega Man 6's music track reader is Mega Man 5's, one byte lower ($8392 against $8393); only its call and jump targets, jump-table entries, and the addresses of the tables it reads differ.
Mega Man 5 `note-frequency`	Mega Man 6 `note-frequency`	relocated	220	Mega Man 6's note-to-period lookup is Mega Man 5's, one byte lower; the only differences are the two operands that address the period table, which sits seven bytes higher in Mega Man 6 ($8960 against $8959).
Mega Man 5 `play-sound`	Mega Man 6 `play-sound`	changed	339	Mega Man 6's sound command routine is Mega Man 5's with one change: where Mega Man 5 steps the sound's data pointer by incrementing $C1 and, on a carry, $C2 before copying it to $D0 and $D1, Mega Man 6 carries into X instead, so $C2 is left as it was, and the routine is a byte shorter. Code after it sits one byte lower, and its jumps, calls, and jump-table entries follow.
Mega Man 5 `sfx-stream`	Mega Man 6 `sfx-stream`	relocated	321	Mega Man 6's sound effect stream reader is Mega Man 5's, one byte lower ($8251 against $8252); only its call and jump targets and jump-table entries differ.
Mega Man 5 `sound-data-bank1a`	Mega Man 6 `sound-data-bank36`	changed	875	Mega Man 6's sounds $23-$3C, the first 26 after its music, at $B758-$BAC2 of bank $36, are 22 of Mega Man 5's sounds from $1A to $3E plus four new ones ($2A-$2D). The 22 keep Mega Man 5's order, except that its $3E comes in as $2E. Seventeen are byte for byte. In the other five only addresses differ, each moved as far as the sound: one address inside each of four effects, and the four track pointers of $39, a sound with music's priority $00 (Mega Man 5's $30). Mega Man 6 leaves out 12 of Mega Man 5's $1A-$3A: $1F, $21, $23, $2B, $2F, $31-$34, and $36-$38. The Mega Man 5 disassembly's notes name two of the carried sounds, the ricochet ($1E, Mega Man 6's $27) and the hit ($2A, Mega Man 6's $35); the kill sound ($2B) is one of those left out.
Mega Man 5 `sound-data-bank1a`	Mega Man 6 `sound-data-bank36`	identical	79	Mega Man 6's sound effects $61 and $62, at $BE99-$BEE7 of bank $36, are byte for byte Mega Man 5's $17 and $18, the first two effects after its music.
Mega Man 5 `sound-data-bank1a`	Mega Man 6 `sound-data-bank36`	relocated	116	Mega Man 6's music $13, 116 bytes at $A19B-$A20E of bank $36, is Mega Man 5's music $11 moved. Only the four track pointers in its header differ, each $625 lower, as far as the song's start moved.
Mega Man 5 `sound-directory-and-instruments`	Mega Man 6 `sound-directory-and-instruments`	changed	568	Mega Man 6's instrument table, 71 instruments of 8 bytes at $8B0F, has as many instruments as Mega Man 5's at $8ADB, but only 27 are the same under the same number. The longest such run is nine instruments, $3D-$45 (72 bytes). One more of Mega Man 6's is in Mega Man 5's table under another number.
Mega Man 5 `sound-driver-entry`	Mega Man 6 `sound-driver-entry`	changed	108	Mega Man 6's sound bank, bank $34, opens with Mega Man 5's entry jumps, multiply, and sound-data read at the same addresses; only the two bank numbers the read maps differ: the overflow data bank, $1A in Mega Man 5 and $36 in Mega Man 6, and the data bank it restores, $19 and $35.
Mega Man 5 `sound-driver-tables`	Mega Man 6 `sound-driver-tables`	identical	292	Mega Man 6's sound tables (note lengths, octave offsets, envelope steps, octave thresholds, and the period table) are Mega Man 5's byte for byte, seven bytes higher at $891C; the zero padding after them, up to the song directory at $8A40, is seven bytes shorter.
Mega Man 5 `sound-driver-update`	Mega Man 6 `sound-driver-update`	relocated	146	Mega Man 6's per-frame sound tick is Mega Man 5's at the same address; three call targets differ, because the stream readers they call sit one byte lower in Mega Man 6.
Mega Man 5 `spawn-engine`	Mega Man 6 `stage-spawner`	rewritten	663	Both games walk a stage's sorted spawn list with two cursors, one for each side of the screen, comparing the scroll position with each entry's screen and X position, but Mega Man 6's spawner is new code. Mega Man 5 reads fixed tables in the stage bank ($A9FF, $AA7F, $AB80), keeps its cursors in $AD and $AE, and treats codes from $C0 up as palette and CHR commands; Mega Man 6 reaches each stage's lists through pointers it sets in $74-$7F from tables in bank $3A, keeps its cursors in $0649 and $064A, and skips entries whose bit in $0650 marks them used.
Mega Man 5 `vertical-section-transition`	Mega Man 6 `vertical-section-transition`	rewritten	442	Both games slide the screen to a new section when Mega Man leaves by the top or bottom, but Mega Man 6's is new code. Mega Man 5 tests the player's Y ($0378) against $08 and $E8 inside its per-frame scroll update, reads the section layout from the stage bank at $A950, and steps the slide 4 pixels a frame from there; Mega Man 6's transitions are separate routines that clear the object slots, reset the spawner, and run their own loop of 120 frames for a vertical move, drawing and waiting a frame each time.
Mega Man 5 `volume-envelope`	Mega Man 6 `volume-envelope`	relocated	379	Mega Man 6's volume envelope code is Mega Man 5's, one byte lower; only its jump-table entries, call targets, and the address of the envelope step table, seven bytes higher, differ.

References

^Mega Man chooses which of six Robot Masters to fight from a menu, in any order; they are Cut Man, Guts Man, Ice Man, Bomb Man, Fire Man, and Elec Man.ManualMega Man NES manual · GameSpot, History of Mega Man
How we know
Player selects the character he chooses to challenge
p. 9 (PDF 5), How to Play · archived copy ↗
any one of six stages of your choice - Bomb Man, Fire Man, Ice Man, Guts Man, Elec Man, or Cut Man.
1987, Mega Man (Rockman in Japan), Gameplay · archived copy ↗
The quote matches our archived copy.
Checked by a second AI model, 2026-10-27.
In the claim ledger
^Each Robot Master Mega Man beats gives him a new weapon.ManualMega Man NES manual
How we know
acquires new firepower he will need
p. 5 (PDF 3), Helpful Game-Playing Hints · archived copy ↗
The quote matches our archived copy.
Checked by a second AI model, 2026-10-27.
In the claim ledger
^Mega Man 2 kept the free choice of boss and the weapon taken from each one, used against another boss's weakness.MagazineNintendo Power 219
How we know
Like its predecessor, Mega Man 2 … to exploit another boss's weakness
p. 82, Playback: Mega Man 2 · archived copy ↗
The quote matches our archived copy.
In the claim ledger
^Retrospectives credit the free stage order and the stolen weapons with the series' long run.WebGameSpot, History of Mega Man · 1UP, Mega Man retrospective
How we know
the innovative idea of stealing the weapons of defeated bosses were what earmarked this series for longevity
1987, Mega Man (Rockman in Japan), Gameplay · archived copy ↗
Rockman allowed players to conquer levels in any order they wished.
p. 1 · archived copy ↗
The quote matches our archived copy.
In the claim ledger

^Off ice, Mega Man never accelerates. Each frame his animation picks a speed from special_object_xcoord_speed_table, 0 standing, 0.125 px/frame on the first step, 1.375 running, 0.5 sliding to a stop, 0 landing, and 0.5625 when hit; any other animation, such as the jump, moves at 1.3125 with a direction held and 0 without.Codelsmmega/mm1revised

How we know

1_ice_tsa_move:
2	LDY #$00
3	LDA aobject_pointer
4	LDX #$08
⋮
6@loop:
7	CMP @special_object_id_table, X
8	BEQ @yes
9	DEX
10	BPL @loop
11	LDA z:zjoy1_pressed
12	AND #left_button | right_button
13	BEQ @regular
⋮

engine/ice_tsa.asm lines 1–22 at b606a84 · upstream ↗

146@special_object_id_table:
147	.BYTE $00
148	.BYTE $03
149	.BYTE $06
150	.BYTE $0C
151	.BYTE $0F
152	.BYTE $12
153	.BYTE $13
154	.BYTE $14
155	.BYTE $6E
⋮
157@special_object_id_index_xcoord_speed_table:
158	.BYTE $00
⋮

engine/ice_tsa.asm lines 146–166 at b606a84 · upstream ↗

1special_object_xcoord_speed_table:
2;fraction, integer
3	.BYTE $00 | $00
4	.BYTE $00 | $20
5	.BYTE $01 | $20
6	.BYTE $00 | $80
7	.BYTE $01 | $00
8	.BYTE $04 | $00
9	.BYTE $05 | $10
10	.BYTE $01 | $50
11	.BYTE $01 | $60
12	.BYTE $00 | $90

data/special_xcoord_speed_table.asm lines 1–12 at b606a84 · upstream ↗

22_write_special_object_xcoord_speed_continue:
23	LDA special_object_xcoord_speed_table, Y
24	PHA
25	AND #%11110000
26	STA aobject_xcoord_speed_fraction, X
27	PLA
28	AND #%00001111
29	STA aobject_xcoord_speed, X

home/write_special_object_xcoord_speed.asm lines 22–29 at b606a84 · upstream ↗

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

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

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

In the claim ledger

^Mega Man's ordinary-floor movement differs from Mega Man 2's, measured in Mesen at the start of Bomb Man's stage and of Heat Man's. The first difference: holding Right from a standstill, Mega Man is still in his first step on the 8th frame, moving 0.125 px, where Mega Man 2 runs at 1.375. After it: a slide of 13 frames, not 8; two frames at the ground speed after a jump press, not one; a landing that runs only with a direction held on the landing frame, not the frame before; 0.125 px/frame on a fresh press in mid-air; −0.75 px/frame on the ground, not −0.25, so a walk-off and a ceiling hit fall faster; and a wall push that keeps the X fraction.Verifiedlsmmega/mm1 · lsmmega/mm2revised

How we know

203	CMP #$03
204	BNE @skip
205	LDA aobject_frameset_timer
206	CMP #$22
207	BNE @skip

engine/run_megaman.asm lines 203–207 at b606a84 · upstream ↗

125	LDA aobject_frameset_upper_timer
126	CMP #$01

engine/run_megaman.asm lines 125–129 at 94f0bf3 · upstream ↗

89oam_frameset_0c:
90	.BYTE 6 | (@end - @start - 1) << 4

sprites/oam_frameset.asm lines 89–90 at b606a84 · upstream ↗

258	LDA aobject_frameset_upper_timer
259	CMP #$02
260	BNE @nz
261	LDA #$03
262	STA z:zmegaman_status

engine/run_megaman.asm lines 258–262 at 94f0bf3 · upstream ↗

216@start_jump_up:
217	LDA #$04
218	STA aobject_ycoord_speed
219	LDA #$DF
220	STA aobject_ycoord_speed_fraction
221	RTS
⋮
223@jump_up:
224	LDA #$09
225	STA aobject_pointer

engine/run_megaman.asm lines 216–227 at b606a84 · upstream ↗

94_run_megaman_landing_common_1:
95	LDA z:zjoy1_pressed_bits
96	AND #a_button
97	BEQ @not_pressed
98	LDA z:zjump_speed_fraction
99	STA aobject_ycoord_speed_fraction
100	LDA z:zjump_speed
101	STA aobject_ycoord_speed
102	LDA #$06
103	STA z:zmegaman_status

engine/run_megaman.asm lines 94–103 at 94f0bf3 · upstream ↗

163	LDA aobject_flag
164	AND #%10000000
165	BNE @running

engine/run_megaman.asm lines 163–165 at b606a84 · upstream ↗

230	LDX #$05
231	LDA z:zjoy1_pressed_frame
232	AND #left_button | right_button
233	BNE @horizontal_jump_down
234	LDX #$08
⋮
236@horizontal_jump_down:
237	STX z:zmegaman_status

engine/run_megaman.asm lines 230–237 at 94f0bf3 · upstream ↗

53	LDA z:zjoy1_pressed_frame
54	AND #left_button | right_button
55	BNE @change_first
56	LDA #$03
57	STA aobject_pointer
58	LDA #$00
59	STA aobject_frameset_timer

engine/run_megaman.asm lines 53–59 at b606a84 · upstream ↗

160_run_megaman_jumping:
161	JSR _check_shoot_on_ladder
162	LDA #$00
163	STA aobject_xcoord_speed_fraction
164	STA aobject_xcoord_speed
165	LDA z:zjoy1_pressed
166	AND #left_button | right_button
167	BNE @horizontal_jumping

engine/run_megaman.asm lines 160–167 at 94f0bf3 · upstream ↗

80@done:
81	LDA #$FF
82	STA aobject_ycoord_speed, X
83	LDA #$40
84	STA aobject_ycoord_speed_fraction, X

engine/objects_vertical.asm lines 80–84 at b606a84 · upstream ↗

68@mainloop:
69	LDA #$00
70	STA aobject_ycoord_speed_fraction
71	STA aobject_ycoord_speed
⋮
77	STA aobject_ycoord_speed_fraction
78	LDA aobject_ycoord_speed
79	SBC z:zobject_ycoord_speed_accelerate
80	STA aobject_ycoord_speed

engine/check_object_vertical_move.asm lines 68–80 at 94f0bf3 · upstream ↗

54	LDA z:zobject_in_process_xcoord_speed
55	STA aobject_xcoord_fraction, X

engine/objects_screen.asm lines 54–55 at b606a84 · upstream ↗

39	JSR _check_horizontal_collision
40	LDA z:z00
41	BEQ @air_1
42	LDA #$00
43	STA aobject_xcoord_fraction

engine/check_object_horizontal_move.asm lines 39–43 at 94f0bf3 · upstream ↗

Measured by a script in MesenCE 2.2.1 (build 4b8a196), on . It fails if the result disagrees with the claim.

The numbers come from the run; its author, an AI model, checked the script measures what the claim says, 2026-10-26.

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

In the claim ledger

^Mega Man 3's ordinary-floor movement differs from Mega Man 2's from the first frame of a walk: Right held from a standstill moves him 1.30 px, then nothing for 5 frames, then 1.30 px a frame, where Mega Man 2 moves 0.125 px a frame for 7 frames, then 1.375. A jump differs from its press frame, which lifts him 4.89 px where Mega Man 2 lifts him 0. Letting go of A mid-rise starts the fall at once, where Mega Man 2 cuts a rise of 2 px/frame or more to 1, and falls cap at 7 px/frame instead of 12. He keeps Mega Man 2's gravity, floor and ceiling corners, and 16 px tiles, and adds the slide.Codeplasticsmoke/megaman3-disassembly-ca65 · lsmmega/mm2revised

How we know

115player_ground_turning_anim:  lda     #$0D ; OAM $0D = turning animation
116        jsr     reset_sprite_anim       ; set turning animation
117        lda     shoot_anim_timer               ; check if shooting
118        beq     player_ground_move_facing ; not shooting, move facing
119        jsr     shoot_oam_advance_variant ; update shoot animation variant
120player_ground_move_facing:  lda     player_facing ; move in facing direction
121        jmp     player_ground_move_horizontal ; move in facing direction

src/fixed/player_ground.asm lines 115–121 at 58ca1c3 · upstream ↗

642prelude_reset_walk_speed:  lda     #$4C ; reset walk speed to $01.4C
643        sta     ent_xvel_sub            ; store walk sub-pixel speed
644        lda     #$01                    ; walk speed whole = $01
645        sta     ent_xvel                ; store walk whole speed

src/fixed/game_loop.asm lines 642–645 at 58ca1c3 · upstream ↗

208	LDA z:zjoy1_pressed
209	AND #a_button
210	BNE @skip
211	LDA aobject_ycoord_speed
212	BMI @skip
213	CMP #$01
214	BCC @skip
215	BEQ @skip
216	LDA #$01
217	STA aobject_ycoord_speed
218	LDA #$00
219	STA aobject_ycoord_speed_fraction

engine/run_megaman.asm lines 208–219 at 94f0bf3 · upstream ↗

71player_ground_normal_jump:  lda     joy2_held ; P2 held buttons
72        and     #$01                    ; bit 0 = Right held?
73        bne     player_ground_super_jump ; yes → debug super jump
74        lda     #$E5                    ; normal jump: Y vel = $04.E5
75        sta     ent_yvel_sub,x          ; store Y velocity sub-pixel
76        lda     #$04                    ; Y velocity whole = $04
77        sta     ent_yvel,x              ; store Y velocity whole
78        jmp     player_airborne         ; enter airborne state

src/fixed/player_ground.asm lines 71–78 at 58ca1c3 · upstream ↗

260player_airborne:  lda     ent_yvel      ; check Y velocity sign
261        bmi     player_airborne_variable_jump ; negative (falling) → skip to clear flag
262        lda     force_full_jump         ; check force-full-jump flag
263        bne     player_airborne_wall_check ; nonzero → skip variable jump
264        lda     joy1_held               ; check if A button held
265        and     #BTN_A                  ; A button mask
266        bne     player_airborne_variable_jump ; held → keep rising (variable jump)
267        jsr     reset_gravity           ; A released → clamp Y speed to 0 (variable jump)

src/fixed/player_ground.asm lines 260–267 at 58ca1c3 · upstream ↗

393apply_gravity_player_check:  lda     ent_yvel_sub,x ; Y sub velocity -= gravity
394        sec                             ; prepare for subtraction
395        sbc     gravity                 ; subtract gravity value
396        sta     ent_yvel_sub,x          ; store new Y sub velocity
397        lda     ent_yvel,x              ; Y velocity -= borrow
398        sbc     #$00                    ; propagate borrow to whole byte
399        sta     ent_yvel,x              ; store new Y velocity
400        bpl     apply_gravity_exit      ; still positive (rising)? done
401        cmp     #$F9                    ; check against terminal velocity $F9
402        bcs     apply_gravity_exit      ; within limit (-7 to -1)? done

src/fixed/movement.asm lines 393–402 at 58ca1c3 · upstream ↗

84	JSR _megaman_status_parameter
85	JSR _check_object_horizontal_move
86	JSR _check_object_vertical_move
87	LDA z:z00
88	BNE _run_megaman_landing_common_1

engine/run_megaman.asm lines 84–88 at 94f0bf3 · upstream ↗

81	BPL @skip
82	CMP #$F4
83	BCS @skip
84	LDA #$00
85	STA aobject_ycoord_speed_fraction
86	LDA #$F4
87	STA aobject_ycoord_speed

engine/check_object_vertical_move.asm lines 81–87 at 94f0bf3 · upstream ↗

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

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

In the claim ledger

^Mega Man 4's movement on ordinary floor differs from Mega Man 3's in five numbers. The first is the jump's take-off speed: 5 px/frame ($05.$00) against Mega Man 3's 4.89 ($04.$E5). The second is the speed on the ground and after a landing: -1 px/frame ($FF.$00) against -0.25 ($FF.$C0). Third, a release cuts a rise to 0, where Mega Man 3 sets the same -0.25. Fourth, the slide timer starts at 26 ($1A) against 20 ($14), so the slide moves on 26 frames against 21 (slide-line, mega-man-3/slide). Fifth, Mega Man 4 tests for the jump out of a slide on every slide frame, where Mega Man 3 skips the test while the timer is 12 ($0C) or more, so the earliest jump out comes on the 3rd frame against the 9th.Codeplasticsmoke/megaman4-disassembly-ca65 · plasticsmoke/megaman3-disassembly-ca65revised

How we know

186    LDA #$00                            ; zero sub-velocity
187    STA ent_yvel_sub                    ; Y velocity sub = 0
188    LDA #$05                            ; jump speed 5 px/frame
189    STA ent_yvel                        ; Y velocity = +5 (up)

src/bank3C.asm lines 186–189 at a63bb6e · upstream ↗

74        lda     #$E5                    ; normal jump: Y vel = $04.E5
75        sta     ent_yvel_sub,x          ; store Y velocity sub-pixel
76        lda     #$04                    ; Y velocity whole = $04
77        sta     ent_yvel,x              ; store Y velocity whole

src/fixed/player_ground.asm lines 74–77 at 58ca1c3 · upstream ↗

648L_F324:
649    LDA #$00                    ; zero
650    STA ent_yvel_sub,X          ; clear vert velocity sub-pixel
651    LDA #$FF                    ; $FF = stopped / minimal
652    STA ent_yvel,X              ; set vert velocity pixel

src/fixed/fixed_entity_physics.asm lines 648–652 at a63bb6e · upstream ↗

203gravity_snap_floor:  jsr     snap_y_to_floor ; snap to tile boundary (down)
204gravity_reset_vel:  jsr     reset_gravity ; reset velocity to rest value

src/fixed/movement.asm lines 203–204 at 58ca1c3 · upstream ↗

424reset_gravity_player:  lda     #$C0     ; player rest vel sub = $C0
425        sta     ent_yvel_sub,x          ; store Y sub velocity
426        lda     #$FF                    ; player rest vel = $FF ($FFC0 = -0.25)
427        sta     ent_yvel,x              ; store Y velocity whole byte
428        rts                             ; player rest vel = $FFC0

src/fixed/movement.asm lines 424–428 at 58ca1c3 · upstream ↗

425    LDA joy1_held                       ; held buttons
426    AND #$80                            ; A still held?
427    BNE L_8338                          ; held: full jump
428    LDA #$00                            ; zero
429    STA ent_yvel_sub                    ; cut jump: Y vel sub = 0
430    STA ent_yvel                        ; cut jump: Y vel = 0

src/bank3C.asm lines 425–430 at a63bb6e · upstream ↗

264        lda     joy1_held               ; check if A button held
265        and     #BTN_A                  ; A button mask
266        bne     player_airborne_variable_jump ; held → keep rising (variable jump)
267        jsr     reset_gravity           ; A released → clamp Y speed to 0 (variable jump)

src/fixed/player_ground.asm lines 264–267 at 58ca1c3 · upstream ↗

217    LDA #$1A                            ; slide duration 26 frames
218    STA $34                             ; set slide timer

src/bank3C.asm lines 217–218 at a63bb6e · upstream ↗

288        lda     #$14                    ; slide timer = 20 frames
289        sta     $33                     ; store slide timer

src/fixed/player_states.asm lines 288–289 at 58ca1c3 · upstream ↗

473L_8368:
474    LDA joy1_press                      ; newly pressed
475    AND #$80                            ; A button?
476    BEQ L_839D                          ; no jump: steering
477    LDA joy1_held                       ; held buttons
478    AND #$04                            ; Down held?

src/bank3C.asm lines 473–478 at a63bb6e · upstream ↗

349        dec     $33                     ; decrement timer
350        lda     $33                     ; check slide timer phase
351        cmp     #$0C                    ; >= $0C? (uncancellable phase)
352        bcs     slide_continue_moving   ; yes → uncancellable, keep sliding
353        lda     joy1_press              ; A button pressed? (cancellable phase)
354        and     #BTN_A                  ; check A button
355        bne     slide_end_ground_check  ; yes → cancel into slide jump

src/fixed/player_states.asm lines 349–355 at 58ca1c3 · upstream ↗

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

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

In the claim ledger

^Mega Man 5's ordinary-floor movement differs from Mega Man 4's, though the walk, the step pose, the jump, gravity, the fall cap, air control, and the slide's speed, length, and start are the same. The first difference on flat ground: on a slide's last frame Mega Man 5 raises his center the 2 px the slide lowered it and sets −0.25 px/frame, where Mega Man 4 leaves it 2 px low at −1 px/frame, so for that frame Mega Man 5 stands 2 px higher, and each of its slides adds $40 to his Y fraction. Against blocks, Mega Man 5's ceiling points are 10 px above his center (Mega Man 4's 9) and his wall points 9 px above it (Mega Man 4's 8); its slide's wall points are 5 px above and 9 px below the slide's center (Mega Man 4's level and 9 below), and its slide's ceiling points 8 px above it (Mega Man 4's level with it).Codeplasticsmoke/megaman5-disassembly-ca65 · plasticsmoke/megaman4-disassembly-ca65revised
How we know
ldy $AF lda $0378 sec sbc ynudge_tbl,y sta $0378
src/bank1B.asm#L424-L428 · upstream ↗
```
525L_83D3:
```
src/bank3C.asm lines 525–539 at a63bb6e · upstream ↗
```
648L_F324:
⋮
653L_F32E:
```
src/fixed/fixed_entity_physics.asm lines 648–654 at a63bb6e · upstream ↗
```
2039ynudge_tbl:
⋮
2042slide_yvel_sub:
⋮
2044slide_yvel_px:
```
src/bank1B.asm lines 2039–2045 at 7fd6512 · upstream ↗
```
1428    .byte $F9,$07,$07
1429    .byte $01,$F7
1430    .byte $F9,$0E,$00
```
src/fixed/fixed_tile_collision.asm lines 1426–1430 at a63bb6e · upstream ↗
```
1700    .byte $F8
1701    .byte $08
```
src/fixed/fixed_tile_collision.asm lines 1699–1702 at a63bb6e · upstream ↗
```
1301    .byte $1E,$23,$27
1302    .byte $2A
```
src/fixed/fixed_tile_collision.asm lines 1301–1304 at a63bb6e · upstream ↗
```
1439    .byte $0E,$0E,$02
1440    .byte $00
⋮
1442    .byte $0E,$0E,$02
```
src/fixed/fixed_tile_collision.asm lines 1439–1442 at a63bb6e · upstream ↗
```
1592    .byte $88
1593    .byte $8D,$92,$92
```
src/fixed/fixed_tile_collision.asm lines 1592–1595 at a63bb6e · upstream ↗
```
1711    .byte $05,$01
⋮
1713    .byte $00
1714    .byte $09,$01
```
src/fixed/fixed_tile_collision.asm lines 1711–1714 at a63bb6e · upstream ↗
.byte $F9,$07,$07,$01,$F6,$F9,$0E,$02,$F2,$F2,$0E,$0E,$02,$0C,$F2,$0E .byte $0E,$02,$0A,$F2,$0E,$0E,$02,$F8,$F2,$0E,$0E
src/fixed_bank.asm#L1259-L1260 · upstream ↗
.byte $F7,$09,$0B .byte $05,$0B,$01,$0F,$FB,$0E
src/fixed_bank.asm#L1279-L1280 · upstream ↗
Checked against the evidence by its author, an AI model, 2026-10-26.
Revised after a check by a second AI model, 2026-10-26.
In the claim ledger
^Mega Man 6's ordinary-floor movement isn't Mega Man 5's: the first difference is a jump's take-off. Mega Man 6 sets his vertical speed to $FA.$CC, 5.20 px/frame up; Mega Man 5 sets its whole byte $03F0 to $05 and its fraction $03D8 to $00, 5 px/frame (jump-speed). Letting go of A sets only the whole byte to 0 in Mega Man 6 and both bytes in Mega Man 5 (release-cut), and Mega Man 5 tests for headroom before a slide where Mega Man 6 doesn't (jump-under-ceiling). The two run different code: Mega Man 5's player is a state machine dispatched each frame from $30, Mega Man 6's a coroutine of loops (coroutine-scheduler).Coderefreshing-lemonade/megaman6-disassembly · plasticsmoke/megaman5-disassembly-ca65revised
How we know
```
105loc_700D7:
⋮
112loc_700E5:
⋮
115loc_700EA:
116code_3880EA:
```
bank38_3F.asm lines 105–118 at f0763c4 · upstream ↗
L80A4: lda $AF bne L80B5 lda #$00 sta $03D8 lda #$05 sta $03F0
src/bank1B.asm#L122-L128 · upstream ↗
lda $03D8,x clc adc #$10 sta $03D8,x lda $03F0,x adc #$00 sta $03F0,x
src/bank0A.asm#L612-L618 · upstream ↗
LDA $40 AND #$80 BNE loc_70143 LDA $05C8 BPL loc_70143 … LDA #$00 STA $05C8
bank38_3F.asm#L146-L162 · upstream ↗
L8259: lda $03F0 bmi L8283 L825E: lda $16 and #$80 bne L8283 lda #$00 sta $03D8 sta $03F0
src/bank1B.asm#L335-L343 · upstream ↗
L80D9: lda $08 lsr a clc adc #$08 tay jsr probe_vert lda L0010 and #$10 bne L814A
src/bank1B.asm#L149-L157 · upstream ↗
L8025: ldx #$00 stx $37 ldy $30 lda player_state_lo,y sta L0000 lda player_state_hi,y sta $01 jmp (L0000)
src/bank1B.asm#L77-L84 · upstream ↗
Checked against the evidence by its author, an AI model, 2026-10-26.
Revised after a check by a second AI model, 2026-10-26.
In the claim ledger
^A press of A without Down ends Mega Man 6's slide but doesn't jump: the slide hands over to the standing loop, which looks for a jump only in a later frame's fresh press ($9A). In Mega Man 5 the same press jumps out of the slide when there is headroom. Measured in Mesen from power-on, at the start of Tomahawk Man's stage, an A press on a slide's 8th frame with Down let go ended the slide that frame, and A held for the next 6 frames left him on the floor.Verifiedrefreshing-lemonade/megaman6-disassembly · plasticsmoke/megaman5-disassembly-ca65revised
How we know
```
382loc_702E3:
```
bank38_3F.asm lines 382–395 at f0763c4 · upstream ↗
```
423loc_70332:
⋮
435loc_7034B:
```
bank38_3F.asm lines 423–436 at f0763c4 · upstream ↗
```
30loc_7004F:
```
bank38_3F.asm lines 27–33 at f0763c4 · upstream ↗
```
20043code_3FE41C:
```
bank38_3F.asm lines 20043–20051 at f0763c4 · upstream ↗
lda $14 and #$80 beq L82C8 lda $16 and #$04 bne L82C8 … jmp L80A4
src/bank1B.asm#L377-L393 · upstream ↗
Measured by a script in MesenCE 2.2.1 (build 4b8a196), on . It fails if the result disagrees with the claim.
The numbers come from the run; its author, an AI model, checked the script measures what the claim says, 2026-10-25.
Revised after a check by a second AI model, 2026-10-25.
In the claim ledger

Sources

Code

lsmmega. 2026. “mm1: Mega Man disassembly (lsmmega/mm1).” Commit b606a84. lsmmega/mm1 @ b606a84 · licence, all uses
lsmmega. 2026. “mm2: Mega Man 2 disassembly (lsmmega/mm2).” Commit 94f0bf3. lsmmega/mm2 @ 94f0bf3 · licence, all uses
plasticsmoke. 2026. “Mega Man 3 (U), annotated ca65 disassembly (plasticsmoke).” Commit 58ca1c3. plasticsmoke/megaman3-disassembly-ca65 @ 58ca1c3 · licence, all uses
plasticsmoke. 2026. “Mega Man 4 (U), annotated ca65 disassembly (plasticsmoke).” Commit a63bb6e. plasticsmoke/megaman4-disassembly-ca65 @ a63bb6e · licence, all uses
plasticsmoke. 2026. “Mega Man 5 (U), annotated ca65 disassembly (plasticsmoke).” Commit 7fd6512. plasticsmoke/megaman5-disassembly-ca65 @ 7fd6512 · licence, all uses
Raidenthequick. 2020. “Mega Man 6 (NES) disassembly (refreshing-lemonade/megaman6-disassembly).” Commit f0763c4. refreshing-lemonade/megaman6-disassembly @ f0763c4 · licence, all uses

Primary

U.S.A., Capcom. 1987. “Mega Man Instruction Booklet (NES, North America).” Capcom U.S.A. original · archived · licence, all uses

Secondary

Christian, Nutt, and Speer, Justin. 2003. “The History of Mega Man.” original · archived · licence, all uses
Chris, Hoffman, and Nintendo Power editors. 2007. “Nintendo Power, issue 219 (2007-09).” Nintendo Power, vol. 219. Nintendo of America. original · archived · licence, all uses
Nadia, Oxford,. 2007. “Mega Man Retrospective: Get Equipped with 20 Years.” original · archived · licence, all uses