1990 · System 3

Last Ninja Remix: the source

This minisite awaits a maintainer’s check. A model this site has not proven yet worked on it (one whose name was not recorded), so its claims have not been tested against the game (how the check works). It is not complete either: 1 of its 7 parts is analysed, and 99.6 % of that is explained. Clone https://github.com/gamesexplained/gamesexplained and follow kit/START.md to continue games/c64/last-ninja-remix to Silver.

Every routine, table and variable the game uses, with the names and descriptions given to them. Click an operand to follow it; the counter beside a label lists what refers to it. The reference below the fold is rendered from the game's facts file.

This game is in 7 parts, and the same addresses hold something else in each. 1 of them has a listing.

Technical reference: memory map, timing, tables, cheats

Central Park and the engine

Boot (live): first I-TAL disk reaches TSM intro; port 1 fire exits it. Space exits the I+T intro. F7 at the trainer starts the game with unlimited lives and unlimited power both NO. After the Central Park presentation, Space loads the level, and port 2 fire at the credits starts active play. The screenshot is reference/central-park.png.
Initialized machine (live): gameplay processor port $35, DDR $2F; IRQ $0314=$1E06, NMI $0318=$1582. CIA2 port $C7 selects VIC bank $0000; bitmap mode with $D018=$19 selects screen $0400 and bitmap $2000.
Composition differs (byte comparison): of 15,889 imported code bytes, 288 differ in the gameplay snapshot: 286 in $0E00–$0F2B, one at $1F5B, and one at $8A0F. Of 45,809 imported data bytes, 4,247 differ. Source bytes therefore come from gameplay, never the composition.
Overwritten startup (live trace): a store checkpoint over $0E00–$0FFF fires during movement after four frames, immediately after $BF02 stores through pointer $04/$05. Tracing $BEC1 reads eight sprite bases from $169D/$16A5: $0C00,$0C40,…,$0DC0; flag bit 0 adds $0200, selecting the other bank. $BED7/$BEF8 copies decoded sprite masks there. Thus $0C00–$0FFF is runtime sprite output in play, including the composition’s former $0E00 startup code. Stale startup annotations and code typing are removed.

Verification work

Animation, combat, object records and music have traced consumers and bounded native checks below. Complete ordinary-play outcomes remain open. Later disk loads are the game's other parts, and none is analysed.

Record and decoder checks

Main sprite pool (trace and independent decode): $CE54-$CF97 holds 162 little-endian biased pointers; adding $0E54 gives the packed records at $CF98-$E927. The decoder at $BF3F emits literals, escapes a following literal with $68, and emits one to seven zeros for $69-$6F. Every record produces exactly 63 bytes and stops at the next pointer boundary. The interactive sprite browser's encoded and decoded arrays match the fresh gameplay capture independently.
Auxiliary sprites (trace and independent decode): each bank at $E979 and $F1B2 begins with 40 biased relative words. The compositor computes group base plus word minus $C000. All 80 records produce exactly 63 bytes; each stops at the next pointer, and the final records end at $F1B1 and $F91F.
Scene records (trace and boundary checks): 118 words at $4E27-$4F12 resolve against $4DE4, with bit 15 distinguishing leaf records. There are 85 leaves and 33 composites. Each leaf has a size byte followed by ten bytes per cell; every calculated leaf length matches the next record. Composite child commands have three fixed bytes, an optional byte selected by bit 6 of the second byte, and up to three bytes selected by bits 5-6 of the third byte. Each composite ends in $FF; all child indices are within the 118-entry table and all boundaries match. Rendering and reflection behaviour still need gameplay checks.
Frame descriptors (trace): 106 absolute pointers at $C4C2-$C595 select component descriptions. Header bit 7 selects a low-two-bit count plus one; the other path has actor-dependent auxiliary composition. Four-byte components carry sprite selection, X/Y fields and attributes. Some fixed-slot windows extend beyond the next pointer, and trailing bytes in several gaps remain open rather than being silently treated as frame payload.
Clipping alias (trace): $BDFF reads $159D,Y only with $F8-$FF, reaching $1695-$169C, the same mask table read directly at $BDE4. $159D itself lies inside an instruction operand in the text renderer. It is an indexed base alias, not a new routine.
UI leaves (trace and boundary checks): seven consecutive 81-byte images from $FCC2 through $FEF8 and the shared image at $3F40 have size $42, four by two cells. The 17-entry directory at $FCA0 shares these targets. Its last target $FEF9 has zero dimensions and overlaps the start of collision records; no pixel payload is attributed to that target.

Live and complete-table checks

Decoder execution (live): ran the original $BF3F routine on ten independently decoded records: main indices 0, 1, 100, 159, 160, 161 and both endpoints of both auxiliary banks. The routine returned at the injected caller with X=63, Y equal to the packed length, and all 63 cache bytes matching the independent result. RAM-under-I/O records were tested with the compositor's RAM banking. The saved gameplay state was restored after the tests.
Player damage (live and trace): $B54A stores saturated max(health-damage,0). Eight boundary cases include health/damage (10,3),(10,0),(10,10),(10,11),(0,0),(0,3),(255,254),(255,255). Positive remaining health preserves action $6D and death latch $B6. A zero result sets $6D=($69>>1)+$24 and $B6=$FF. Other combat paths can install hit reactions separately; this describes the damage routine's effect.
Projectile collision (live and trace): $B767 returns carry clear exactly for horizontal distance below 6 and vertical distance below 8. Ten test pairs cover zero, accepted limits, rejected limits and their negative counterparts. Coordinates were placed away from wraparound; signed world-wrap behaviour is outside these checks.
Animation format (trace, independent parse and live step): the $C2C4-$C4C1 bank divides into 157 commands across 32 terminated/continued sequences. Every command ends on the next boundary and every frame selector is below 106. Bits 1, 7, 0 and 5 select delay, signed X/Y deltas, event and continuation fields respectively. Executing the first command at $C2C4 stops before composition at $A8C3 with control $1A, delay/reload 4, frame $31 and next pointer $C2C7, agreeing with the parse. All command/event gameplay outcomes are not covered by this one-step check.
Music (live): after 120 requested frames of normal gameplay, SID voice 1 changes frequency 536 to 1012 and pulse width 2056 to 1028; voice 3 changes frequency 9634 to 7217. This observes the active sequencer while dummy audio keeps the run silent. It does not verify every track command.
Mirror lookup tables (complete byte check and trace): $1200-$12FF reverses four two-bit pixel pairs; $1300-$13FF reverses eight individual bits. All 256 entries in each table match these formulas. Renderer/blitter consumers index them with the source pixel byte.
Text rows and glyphs (complete table check and trace): 25 words at $1631 equal $0400+40*row; 25 words at $1663 equal $2000+320*row. The inline renderer masks glyph IDs to six bits and copies eight rows from $1AE8+8*id. A rendered multicolor atlas establishes space, A-Z and digit ordering; punctuation names remain open. All 23 inline text calls in this occupant still call $1583 and their four-field headers and zero terminators are checked.
Final level hand-over (live): stopping at loader EOF return $10F8 captures the complete Central Park replacement before its initializer. $8A0F still contains LDA #$00 there; gameplay contains RTS. The complete scene/frame/sprite directories and record pools, font and reversal tables are explicitly retained in the ledger. Additional unchanged loaded ranges reported by listing.py --entry remain open.

Collision, meter and retained animation checks

Collision compiler (trace, independent decode and live): all 18 lists at $9D8A-$A04D matched the original $B950 compiler byte-for-byte, including 264 six-byte records and two empty lists. The maximum area emits 29 records plus a two-byte zero terminator, through $FFA8. Encoded chains preserve endpoints, slope flags and optional actions; backward segments continue from their start endpoint. The article’s 18 datasets match the native outputs and its area/segment/grid controls were exercised.
Enemy meter (trace and live): $B3D6 reads the 16-bit tick pair $F0:$E2 and saved per-area tick pair $0187,X:$0175,X. It writes min(44,max(0,((now-origin) modulo 65536)//32-2)) into $022A and $3F92,X. Sixteen cases cover the zero floor, increment, cap and counter wrap. $91F4 initializes 30 slots to 44; enemy hit handling can clear the selected slot. This is distinct from the saturating player-health routine. Full player-visible enemy combat outcomes remain open.
Late animations (independent parse and live): eleven streams lie between the frame records at $CD6C-$CDCA, $CE03-$CE13, $CE1E-$CE31 and $CE3C-$CE45. Their command fields and continuation words match the main animation format. Every first command ran to $A8C3 with matching control, delay/reload, frame, event and next pointer. The scripted encounter directory $A379 names interior entries, and object callbacks select $CE2A; these are animation data with concrete consumers.
Object-display continuation (trace and live): $C096-$C0AE contains executable instructions, including undocumented LAX $DC36,Y. For Y=0, native LAX loaded matching A/X from the stopped CIA timer. Four comparison/carry cases all reached $C0AF after writing four through both display pointers. The conditional paths execute optional BIT instructions but all reach the same store value. Their exact raster timing and purpose remain open.
Interaction data (trace): 15 fourteen-byte records at $C0D0-$C1A1 end at sentinel $C1A2. Fields provide area, position bounds, scene/callback pointers, inventory slot, interaction selector and heading. Consumers scan with stride 14 and compare the current area, inventory and coordinates before rendering/calling. Individual object names and puzzle routes remain open.
Retained music data (trace): frequency tables, instrument offsets/records, auxiliary directories, voice playlists and 19 phrase pointers have bounded annotations. The 42-byte ASCII credit at $400C names R. Ouwehand and F. Paul. Pointers can select shared suffixes; table lookup capacity does not prove that every instrument id has an intact record. Every track command and invalid selector outcome remains open.

The whole game

What is true of the game as a whole. Each part's own facts are in parts/<id>/facts.md, where every address is that part's.

Seven parts. The game is played as seven levels, each loaded from disk: Central Park, The Street, Sewers, Basement, Office, Mansion and Final Battle. The level names are as this analysis's notes give them; only Central Park has been loaded and read.
One part is analysed. parts/central-park is the machine in active play in Central Park. Its image holds the engine and the level together, and which addresses the level's load writes is open.

Cheats

No newly tested pokes are published. The Source tab exposes the named state fields and their consumers; modifying them is not evidence of a reachable gameplay state.