Legend of Zelda, The (USA) (Rev 1)

Legend of Zelda, The (USA) (Rev 1) is on a MMC1 board with 131,072 bytes of program. A crawl of 6,400 steps from power-on kept 110 paths that found new code. Played back over 289,730 frames, they executed 14,209 bytes of it, 11 percent.

What the rules named

• The poll: 2
• The idle spin: 1
• The game inside the interrupt: 1
• The jump engine: 1
• The bank switch: 6
• The picture writer: 1
• The palette writers: 1
• The sprite writers: 26
• The scroll writer: 1
• The split: 1
• The sound driver: 1
• The random byte: 1
• Where two things are compared: 6

The 304 routines the runs entered

Every place the game's code was entered, by a call, an interrupt or a jump through a table. The ones a rule named come first, with what the rule saw, and their names in the listing say what they are: a poll, an engine, a drain.

Where it waits

Loops a rule named that sit inside a routine and are not themselves a place the code is entered.

The tables it jumps through

A table of addresses the game picks one from. Some sit right after a call to a jump engine; others are anywhere in the cartridge, and we find them by where the address the game jumped through was loaded from. Some games jump by pushing an address and returning to it, and some keep a table as two, the low bytes of its addresses in one place and the high bytes in another; both are found the same way. An entry is counted as far as the runs saw one taken; the true table may be longer. The last column is the byte of memory whose value picked the entry, where we could follow it: the game's mode, or what one of its objects is doing.

The memory its routines share

1,373 bytes of memory were written by one routine and read by another, and 64 places were reached through an index, which is what a table or a set of object slots in memory looks like.

Reaches through an index: those that hold positions, then the longest

What travels with a position

Arrays that at least two routines step through together with an array of positions, across the same range. That is what a table of the things on the screen looks like in memory: one array for each property, one slot for each thing. We can say which arrays hold positions, which of the others get added into them, which is what a speed does, which pick the way through a jump table, which is what a state or a kind does, and which are only ever counted down, which is what a timer does. What the rest hold is not named yet.

The 24 busiest shared bytes

This page shows none of the game's bytes. The listing these figures were read from stays with the cartridge.

All the games