Metroid

On this page

How Samus moves
Energy and damage
The blink
The push
Item drops
Health growth
Cartridge
Related
Mechanics
References
Sources

Metroid is Nintendo Research & Development 1’s action-adventure, released for the Famicom Disk System in Japan in August 1986¹. nmikstas’s disassembly reassembles to the US ROM byte for byte². It began from Kent Hansen’s disassembly of the game engine, and much of the collision code still carries his raw labels².

#How Samus moves

Samus’s speeds and positions carry a fraction byte, so they move in 1/256 px steps³. Each frame the game reads the pad first, then moves her up or down, then sideways⁴.

On the ground she speeds up at 0.1875 px/frame² to 1.5 px/frame^5,5. The first frame with a direction held doesn’t move her⁶, and letting go of the d-pad stops her at once⁵. Pressing the other way turns her on that frame but keeps her speed, so she slides on and takes 16 frames to run the other way at full speed⁷. On the frame after a turn, or after landing from a running jump, the game sets her running pose and ignores the pad⁸.

Every jump leaves the ground at 4 px/frame⁹ and slows under 0.09375 px/frame² in a jump^10,10. Letting go of A stops the rise only once she has climbed 32 px¹¹, so the shortest jump is a tall one. Measured in the game, a standing jump peaks at 84 px held, 32 px tapped^12,12. A running jump takes off on the press frame, a standing jump on the frame after¹³.

A running jump caps her speed at 1.125 px/frame, and the d-pad steers it by acceleration¹⁴. At 24 px of rise she somersaults¹⁵. With neither direction held, a jump in the plain jump pose stops dead sideways, while a somersault carries on¹⁴. A standing jump moves 1 px/frame while a direction is held¹⁶.

Walking off a ledge makes her airborne at once¹⁷. Because the pad is read before the floor test, a press on that frame still jumps^4,17; a frame later it doesn’t¹⁸.

Against the level she is an 8 × 30 px¹⁹ box¹⁹, tested against every 8 px tile it spans²⁰. A wall stops her move; on the ground she also stops and stands, while in the air her speed is kept²¹. The code’s comment says a ceiling divides her speed by 2 and reverses it. The shift keeps the sign, though, so her upward speed is only halved, and she presses against the ceiling until gravity turns her²².

#Energy and damage

Samus’s health is binary-coded decimal in tenths of a unit. The full energy tanks sit in the high nibble of HealthHi, above the tens, ones, and tenths digits²³. She starts with 30 units²⁴ and no tanks²⁴.

An enemy’s contact damage doesn’t depend on the enemy. The game charges the base damage of the current area, two bytes in that area’s bank: 8 units in Brinstar²⁵, 10 in Norfair, 20 in Kraid’s hideout, 24 in Ridley’s hideout, and 30 in Tourian²⁵. The Varia suit halves every amount taken²⁶. In the probe, a crawler in Brinstar’s first room takes 8 units with each hit²⁷.

#The blink

A hit sets the blink counter, SamusBlink, to $32, which is 50²⁸. The comment beside it says “Set blink for 32 frames”, reading the hex as decimal²⁸. The counter drops by 1 on every frame of game logic²⁹. While it is above 0, the collision code skips the check between Samus and the enemies³⁰.

In the probe, a crawler held against Samus hurts her every 50 frames²⁷ of game logic²⁷. One of the two gaps also held 2 lag frames, so it took 52 frames of video²⁷.

Lava sets the counter to 50 on every frame. Enemies can’t touch Samus there, but the lava takes 0.7 units twice every 8 frames, or 0.3 units once with the Varia suit³¹.

#The push

A hit gives Samus an upward speed and the hit gravity, and takes a push direction away from the enemy²⁸. On each frame of the blink, the game sets her horizontal speed to the counter divided by 16, so the push fades as the blink runs down. It ends when the counter falls below 16³². Once the counter is below 48, the push yields to the player: any frame with horizontal acceleration skips it³².

on a hit:      blink = 50; vertical speed = up; gravity = hit gravity; push = away from the enemy
every frame:   if blink > 0:
                   d = blink / 16 (rounded down); blink -= 1
                   if d < 3 and Samus is accelerating sideways: skip
                   horizontal speed = d toward push        # 0 once blink < 16

In the probe, with no input, three pushes carried Samus 37–45 px³³ from the enemy³³.

#Item drops

RandomNumber1 gains 25 once per frame, so it steps through all 256 values every 256 frames, and a drop depends on the frame the enemy dies³⁴. A value below 16 drops nothing. Otherwise its low 3 bits pick from an 8-entry table: a missile twice, an energy ball three times, and item $89 three times³⁵.

The table’s comment calls $89 “No item”, but the code drops it for any enemy whose byte in the area’s $968B table has bit 0 set. Samus collects it as 20 units³⁶. A small energy ball gives 5 units and a missile 2 missiles³⁷. A missile drops only after Samus has some missile capacity³⁸.

Each door re-rolls two caps for the next room, 0 to 15 missile drops and 64 to 94 energy drops, and each drop that passes its cap adds to its count, even a $89 the enemy then can’t drop³⁸. The comments give “16 max” and “128 max”, and they call the counts power-ups “collected by Samus”³⁸. Before the first door, both caps are 39, because the start routine stores a mirroring value into them³⁹.

Tourian handles drops its own way. Two of its enemy data indexes drop nothing⁴⁰. For any other kill there, a roll that would drop nothing resets both caps to 1 and rolls again⁴⁰. Tourian’s data indexes 0 and 1 carry a flag that makes their drops worth 30 units or 30 missiles³⁷.

The probe calls the drop code for all 256 values of RandomNumber1 with Brinstar’s bank mapped⁴¹. For an enemy of data index 0, the 256 values give 60 missiles, 90 energy balls, 90 $89 balls, and 16 nothing^41,41. For index 3, whose bit is clear, the 90 $89 rolls drop nothing⁴¹.

#Health growth

An energy tank adds a tank, up to 6, and fills Samus’s health⁴². Health can’t exceed $100 t + 99.9$ ⁴³ units for $t$ tanks⁴³. A missile tank adds 5 to her missile capacity⁴⁴.

Cartridge

Mechanics

Mechanic	Kind	How
Invincibility frames	Frame timer	a 50-frame blink
Knockback	Fading push	a push that fades with the blink
Item drop table	One roll	an 8-entry table read by a frame-stepped byte, capped per room
Damage formula	Fixed table	one contact damage per area
Random number generator	Stepped counter	a byte that steps by 25 every frame, through all 256 values
Health upgrade	Whole containers	energy tanks, each filling Samus's health to the new maximum
Jump	One speed	4 px/frame up for every jump; the High Jump Boots lower the gravity instead
Gravity	One gravity	0.09375 px/frame² in a jump, 0.0703 with the High Jump Boots, held or not
Variable jump height	Release cap	past 32 px of rise, letting go sets the vertical speed to 0, so a tap still rises 32 px
Running	Ramp up	0.1875 px/frame² to 1.5 px/frame after a still first frame, a stop the moment the d-pad is released, and 16 frames to turn at full speed
Air control	Momentum	a running jump steers by acceleration and a somersault keeps its speed; a standing jump moves 1 px/frame only while held
Hitbox	Box	radii from each animation frame, 8 × 30 px against the level, tested at every 8 px tile the box spans
Ammunition	One pool	missiles only, 5 more capacity per missile tank
Morph ball	No jump	the Maru Mari, from the ground only; a jump press unrolls it
Screw Attack	Running jump	a running jump with the item, while it somersaults or still rises
Password and battery save	Password with a check value	24 characters of 6 bits holding 18 bytes, with an 8-bit sum and a random rotation
Coyote time	None	a press on the frame Samus walks off still jumps; after that, a jump press works only in lava
Space Jump	None	the gear byte has no Space Jump bit
Wall jump	None	in the air a jump press works only in lava

Every claim about this game, by concept (57)

general	Metroid's cartridge ROM, counted by part of the game: each stretch of code or data goes to the part the disassembly's labels and comments say it serves, and the value sums the bytes of each part.	Code notes
	Each frame, the handler for Samus's state (standing, running, jumping) reads the pad first and then calls `SetSamusData`, which reaches `LavaAndMoveCheck`. That routine accelerates and moves her vertically (`VertAccelerate`, then one pixel at a time), and then horizontally (`HorzAccelerate`, then one pixel at a time).	Code
	Samus's speeds are 8.8 fixed point: a whole byte, `ObjVertSpeed` or `ObjHorzSpeed`, and a fraction, `VertCntrLinear` or `HorzCntrLinear`. Her position's fraction is one more byte per axis, `VertCntrNonLinr` or `HorzCntrNonLinr`. Each frame the speed's fraction is added to it, and she moves the speed's whole part plus the carry, in pixels. The comments call that byte a counter that grows exponentially; in the code it is the fraction of her position.	Code
	Samus moves one pixel at a time, and a step tests the room's 8 px tiles only when the edge she moves toward lies on a tile boundary: `MoveSamusUp`, `MoveSamusDown`, `MoveSamusLeft`, and `MoveSamusRight` call the crash check only when her center less or plus her radius is a multiple of 8. The check tests the row of tiles above her top or below her bottom, or the column beside her side, across every tile her box spans. On the ground, `VertAccelerate` makes the same test under her each frame.	Code
	A solid tile beside Samus stops her sideways move for the rest of the frame (`CheckStopHorzMvmt`). On the ground (`SamusGravity` 0), and not in the ball, it also calls `StopHorzMovement`, which clears her speed and acceleration and makes her stand. In the air her speed is kept.	Code
	Wikidata lists Nintendo Research & Development 1 as the developer of Metroid and Nintendo as its publisher, and dates its release on the Famicom Disk System in Japan 6 August 1986.	Wikidata
	nmikstas's disassembly of Metroid, assembled with Ophis, equals the PRG ROM of Metroid (USA) byte for byte.	Code
	A missile tank raises Samus's missile capacity by 5.	Code
Air control	A running jump sets the top speed to `$12` (1.125 px/frame). In the air a held direction sets the acceleration toward it; with neither held, a jump still in the plain jump animation loses its horizontal speed, and a somersault keeps its speed and acceleration.	Code
	In a jump from a standstill, `LD055` sets the whole part of Samus's horizontal speed outright every frame, 1 px/frame toward a held direction and 0 with neither held.	Code
	In a running jump, the air branch of the running handler poses Samus by `SamusJmpDsplcmnt`, which a jump sets to 0 and each pixel up adds 1 to and each pixel down takes 1 from. Rising at 24 or more (`cpy #$18`), she somersaults (`an_SamusSalto`) unless she is firing; falling at less than 24, she takes the plain jump pose (`an_SamusJump`), as she does from the running pose. The pose decides whether letting go of the d-pad stops her (`metroid-samus/air-run`).	Code
Coyote time	Once Samus is airborne, the run and jump handlers start a jump only while she is in lava. Walking off a ledge makes her airborne at once: `VertAccelerate` sets the falling gravity on the first frame with nothing below her.	Code
Coyote time	On the ground, `VertAccelerate` sets `SamusHorzSpdMax` to `$18` and tests the tiles under Samus before she moves. With none solid, and no elevator or frozen enemy under her, it sets the falling gravity, `$1A`, and adds it at once, so she is airborne from that frame. The running handler's air branch then turns her running pose into the plain jump pose, so letting go of the d-pad stops her (`metroid-samus/air-run`), and her top speed stays 1.5 px/frame.	Code
Damage formula	When an enemy touches Samus, the game charges her the base damage of the current area, two bytes in that area's bank at `$95CE`, whatever the enemy; Brinstar's is 8 units, Norfair's 10, Kraid's hideout's 20, Ridley's hideout's 24, and Tourian's 30.	Code
Damage formula	With the Varia suit, `SubtractHealth` halves every amount it takes from Samus.	Code
Gravity	Each frame `VertAccelerate` adds `SamusGravity` to the fraction byte of Samus's vertical speed and carries into its whole part, so gravity is `SamusGravity`/256 px/frame²: `$18` (0.09375) in a jump, `$12` with the High Jump Boots, `$1A` after walking off a ledge, and `$38` after a hit (computed: 0.0703125, 0.1015625, 0.21875). A fall is capped at 5 px/frame and a rise at 6.	Code
Health upgrade	Samus's health is binary-coded decimal in tenths of a unit; `HealthHi` holds the full energy tanks in its high nibble and the tens digit in its low nibble, and `HealthLo` holds the ones digit in its high nibble.	Code
	Samus starts with 30 units of energy and no energy tanks.	Code
	An energy tank adds a tank, up to 6, and fills Samus's health to her new maximum.	Code
	Samus's health can't exceed 99.9 units above her tanks, $100 t + 99.9$ units for $t$ tanks, which is 699.9 with all six.	Code
Hitbox	Samus is a box around her center: each animation frame's data sets `ObjRadY` and `ObjRadX`, the distances from her center to her top or bottom and to her sides. The level checks add these radii to her position, and so does the distance check between her and an enemy.	Code
Hitbox	In Brinstar's bank, the frames of Samus's running, standing, jumping, and somersault animations all give the radii `$0F` and `$04`: 15 px from her center to her top or bottom and 4 px to either side, so her box is 30 px tall and 8 wide (computed).	Code
Invincibility frames	A hit sets `SamusBlink` to `$32`, which is 50, gives Samus an upward speed of `$FD` with the hit gravity `$38`, and takes the push direction from the hit; the comment says "Set blink for 32 frames".	Code
	Each frame, the crash detection skips the contact check between Samus and the enemies while `SamusBlink` is above 0.	Code
	`CheckHealthStatus`, which Samus's routines call once per frame, lowers `SamusBlink` by 1 each time, so the blink lasts 50 frames of game logic.	Code
	Measured in the ROM, a crawler held against Samus in Brinstar's first room takes 8 units with each hit, and the next hit lands 50 game frames later; one of the two gaps also held 2 lag frames, for 52 frames of video.	Verified
	In lava, Samus's blink is set to 50 on every frame, so enemies can't touch her, while the lava takes 0.7 units twice every 8 frames without a push; the Varia suit cuts that to once, and `SubtractHealth` halves it to 0.3 units.	Code
Item drop table	When an enemy dies, a `RandomNumber1` below 16 drops nothing; otherwise its low 3 bits pick from `ItemDropTbl`, which holds a missile at 0 and 3, energy at 1, 4, and 6, and `$89` at 2, 5, and 7.	Code
	Item `$89` drops only for an enemy whose byte in the area's table at `$968B` has bit 0 set, and Samus collects it as 20 units of energy; the table's comment calls it "No item".	Code
	Each door re-rolls the room's caps from `RandomNumber1`, 0 to 15 missile drops and 64 to 94 energy drops, and zeroes the counts. A drop that would pass its cap is lost; one that passes the test adds to its count, even a `$89` roll that the enemy then can't drop.	Code
	Until the first door, the caps on missile and energy drops are 39 when the game starts in Brinstar, because `SamusInit` stores the mirroring value `$27` into them, or 47 (`$2F`) elsewhere.	Code
	A small energy ball gives Samus 5 units and a `$89` ball 20; a missile gives 2 missiles; an enemy whose data index carries the 30-unit flag gives 30 units or 30 missiles instead.	Code
	In Tourian, enemies with data index 2 or 4 drop nothing, and any other kill that would drop nothing resets both caps to 1 and both counts to 0 and rolls the same `RandomNumber1` again, skipping the test for 16.	Code
	Called in the ROM for all 256 values of `RandomNumber1`, the drop code gives a Brinstar enemy of data index 0 60 missiles, 90 small energy balls, 90 `$89` balls, and 16 nothing; index 3, whose byte in the table `LF74B` reads (`$968B` + data index, kept in `$00`) has bit 0 clear, gives 106 nothing and no `$89`.	Verified
Jump	Every jump takes off with the whole part of Samus's vertical speed at `$FC`, 4 px/frame up. The High Jump Boots change the gravity, not the speed: `SetSamusJump` sets `SamusGravity` to `$18`, or `$12` with the boots.	Code
	A jump from a standstill starts after the press frame's move: `SamusStand` calls `SetSamusData`, which moves her, and then `SetSamusJump`, so she first rises on the next frame. A running jump's handler calls `SetSamusJump` (`LCD40`) before `SetSamusData`, so she rises on the press frame, and there it sets her top speed for the jump, `SamusHorzSpdMax`, to `$12`.	Code
	Moving down, and not in the ball, Samus stops when `MoveSamusDown` finds a solid tile under her: `StopVertMovement` clears her vertical speed, `SamusGravity` is set to 0, and the frame goes on to her horizontal move. A jump from a standstill ends on the next frame: `SamusJump` finds `SamusGravity` at 0 and calls `StopHorzMovement`, which stops her and makes her stand, so she doesn't move that frame, and a jump press then does nothing, since the jumping handler starts a jump only in lava. In the ball (`sa_Roll`), a landing halves her downward speed and turns it upward, a bounce, until the halved whole speed is 0 and she stops.	Code
	Blocked moving up, Samus's vertical speed, whole byte and fraction, is shifted right one bit with the sign bit set (`sec`, `ror ObjVertSpeed`, `ror VertCntrLinear`). An upward speed is halved and stays upward, though the comment says the shift reverses her direction. The rest of that frame's rise is dropped. Each later frame that would still move her up is blocked and halved again, until gravity turns her speed downward.	Code
Knockback	On each frame of the blink, `CheckHealthStatus` sets Samus's horizontal speed in the push direction to the blink counter divided by 16, so the push ends when the counter falls below 16; below 48, it skips the push on any frame Samus has horizontal acceleration.	Code
Knockback	Measured the same way, with the crawler moved off Samus during each blink, the three pushes carried her 37, 45, and 44 px away from it; two lifted her 19 px and one 2 px.	Verified
Morph ball	Samus rolls into the ball only with the Maru Mari (`gr_MARUMARI`) and only on the ground. In the ball, Up or a jump press unrolls her unless Down is held, and only if she has room to stand.	Code
Password and battery save	Metroid's password holds 18 bytes; bytes 0-7 carry one bit for each of 59 items, doors, and Tourian objects collected, byte 8 the starting area (bits 0-5) and whether Samus wears her suit (bit 7), byte 9 her equipment, byte 10 her missile count, bytes 11-13 her age, byte 15 the Kraid and Ridley statue and defeat bits, byte 14 a copy of the RAM byte after the age, which nmikstas labels unused, byte 16 a scramble count, and byte 17 a check byte.	Code
	Metroid writes the 18 bytes as 24 characters of 6 bits each, three bytes to every four characters, from a 64-symbol set of 0-9, A-Z, a-z, ?, and -; the entry grid's 65th symbol, a space, enters as $FF, all 8 bits set.	Code
	To make a password, Metroid sums bytes 0-16 into byte 17, then rotates bytes 0-15 right as one 128-bit number, one bit at a time, as many times as byte 16 says; byte 16 is the low 4 bits of a random byte, redrawn until it is not 0.	Code
	When the player presses Start, Metroid rebuilds the 18 bytes from the 24 characters, rotates bytes 0-15 back left by byte 16's count, and compares their sum with byte 17; on a mismatch it plays the wrong-password sound and shows ERROR TRY AGAIN for 120 frames, and on a match it starts the game; nothing else in the password is checked.	Code
	Metroid compares the first 16 characters entered with NARPASSWORD00000 before anything else and, on a match, sets a flag and ignores the rest; while that flag is set, the game engine writes $03 to Samus's health high byte, $FF to her equipment byte, and 5 to her missile count, every frame.	Code
	If Mother Brain has been destroyed when Metroid makes a password, it clears her bit and every Tourian bit in bytes 6 and 7, so the password brings back Mother Brain, the zebetites, and Tourian's missile doors.	Code
	Computed from the decoder's lines, the password JUSTIN BAILEY ------ ------ passes; after 255 rotations, its bytes 0-16 sum to $FF mod 256, which equals its check byte, byte 17, and byte 8's bit 7 is set, which the game loads as Samus without her suit.	Code
Random number generator	The main loop calls `RandomNumbers` once per frame, after the frame's work; it adds 5 to `RandomNumber1` five times, 25 in all, so the byte steps through all 256 values every 256 frames.	Code
Running	On the ground Samus accelerates at `$30`/256 (0.1875) px/frame² toward `SamusHorzSpdMax`/16 px/frame, which `VertAccelerate` sets to `$18` (1.5 px/frame) while she is grounded. With no direction held, `StopHorzMovement` clears her horizontal speed at once.	Code
	From a standstill, the first frame with Left or Right held doesn't move Samus. `SamusStand` picks the running state, calls `SetSamusData`, which moves her at her speed of 0, and only then calls `SetSamusRun`, which sets her acceleration. Her speed rises from the next frame.	Code
	Running on the ground, Left or Right against Samus's facing turns her and sets the acceleration toward the new side on that frame, through `SetSamusRun`, but leaves her speed as it is. She slows by 0.1875 px/frame each frame, passes 0, and speeds up the other way: from 1.5 px/frame, 16 frames to 1.5 px/frame the other way (computed).	Code
	On the ground, the running handler checks Samus's animation before it reads A or the d-pad (`LCDBF`). Unless it is the running animation (or, with Up held, running and aiming up), it sets that animation and skips the rest of the handler for the frame. A jump press or a released d-pad on that frame is ignored, and she accelerates toward her facing. That happens on her first frame on the ground after a running jump or a fall, and on the frame after a turn: `SetSamusRun` gives Samus the running animation only if her animation was standing (`an_SamusStand`), and otherwise the running-and-aiming-up animation (`an_SamusRunPntUp`).	Code
Screw Attack	`IsScrewAttackActive` counts the Screw Attack as on only in the running state with the item: in a somersault, or in the plain jump animation while Samus still rises. The Samus-enemy crash code at `LF282` calls it.	Code
Space Jump	Samus's gear byte, `SamusGear`, has one bit each for the bombs, High Jump, Long Beam, Screw Attack, Maru Mari, Varia, Wave Beam, and Ice Beam: all eight bits, none for a Space Jump.	Code
Variable jump height	Once a jump has carried Samus 32 px up (`SamusJmpDsplcmnt` at `$20`), letting go of jump while she still rises calls `StopVertMovement`, which sets her vertical speed to 0. The running-jump handler does the same past 32 px.	Code
Variable jump height	Measured in the game, Samus's jump from a standstill peaks at 32 px on frame 10 when A is tapped or held up to 10 frames, and at 84 px on frame 41 when A is held to the top, landing on frames 36 and 86. A running jump, which rises on its press frame, peaks and lands a frame sooner at the same heights.	Verified

References

^Wikidata lists Nintendo Research & Development 1 as the developer of Metroid and Nintendo as its publisher, and dates its release on the Famicom Disk System in Japan 6 August 1986.WikidataWikidata
How we know
+1986-08-06T00:00:00Z … +1987-08-15T00:00:00Z … +1987-08-00T00:00:00Z
Q2530723, P178 developer, P123 publisher, and P577 publication date qualified by P291 place and P400 platform · archived copy ↗
The quote matches our archived copy.
Checked by a second AI model, 2026-10-21.
In the claim ledger
^ a bnmikstas's disassembly of Metroid, assembled with Ophis, equals the PRG ROM of Metroid (USA) byte for byte.Code“Metroid (USA)” · nmikstas/metroid-disassembly
How we know
In the cartridge (“Metroid (USA)”): bank 7 $C000, RandomNumbers, the first routine of the engine bank. We don't reproduce the bytes.
```
32out00=($(md5sum Output_Files/Bank00.bin))
33org00="8890cbea191c4218a754aa926ca61c9a"
```
build_script lines 32–33 at 4270d57 · upstream ↗
Checked against the evidence by its author, an AI model, 2026-10-20.
Checked by a second AI model, 2026-10-21.
In the claim ledger

^Samus's speeds are 8.8 fixed point: a whole byte, ObjVertSpeed or ObjHorzSpeed, and a fraction, VertCntrLinear or HorzCntrLinear. Her position's fraction is one more byte per axis, VertCntrNonLinr or HorzCntrNonLinr. Each frame the speed's fraction is added to it, and she moves the speed's whole part plus the carry, in pixels. The comments call that byte a counter that grows exponentially; in the code it is the fraction of her position.Codenmikstas/metroid-disassembly

How we know

5637LE3D3:* lda VertCntrNonLinr       ;
5638LE3D6:  clc             ;This function adds itself plus the linear verticle counter
5639LE3D7:  adc VertCntrLinear      ;onto itself every frame.  This causes the non-linear
5640LE3DA:  sta VertCntrNonLinr       ;counter to increase exponentially.  This function will
5641LE3DD:  lda #$00            ;cause Samus to reach maximum speed first in most
5642LE3DF:  adc ObjVertSpeed        ;situations before the linear counter.
5643LE3E2:  sta $00             ;$00 stores temp copy of current verticle speed.

Source_Files/Bank07.asm lines 5637–5643 at 4270d57 · upstream ↗

5691*   lda HorzCntrNonLinr
5692    clc
5693    adc HorzCntrLinear
5694    sta HorzCntrNonLinr
5695    lda #$00
5696    adc ObjHorzSpeed
5697    sta $00             ;$00 stores temp copy of current horizontal speed.

Source_Files/Bank07.asm lines 5691–5697 at 4270d57 · upstream ↗

5471LE2C2:* sta ObjectCounter       ;Store number of pixels to move Samus this frame.
5472LE2C4:* jsr MoveSamusUp         ;($E457)Attempt to move Samus up 1 pixel.

Source_Files/Bank07.asm lines 5471–5472 at 4270d57 · upstream ↗

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

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

#How Samus moves

#Energy and damage

#The blink

#The push

#Item drops

#Health growth

Cartridge

Related

Mentioned in

Mechanics

References

Sources

Code

Secondary