Fairlight was released twice on tape for the 48K Spectrum, and this is Release 2, the later. The disassembly is of that tape, loaded the way a Spectrum loads it: SkoolKit's tap2sna runs the ROM's own LOAD, the tape's BASIC and its loader on a simulated machine, and stops at START, where the loader hands over to the game, before the game has run a single instruction. The loader is the Alkatraz Protection System's. The BASIC program on the tape holds a routine that decrypts itself in layers and loads a second, turbo-speed loader; that one reads the long block, decrypting each byte with a key that changes as it goes, the count left and the address it is stored at. It loads the loading screen a line at a time, in its own order, and then the game in pieces, $5B00 to $DABF and $DD39 to the top of memory, checks a checksum, clears itself and returns to START. The build decrypts the tape's block the loader's way itself, and checks the result is what the snapshot holds. Why Release 2: it is the release Ville Krumlinde's disassembly was made from (see below), so the two maps can be set side by side, address for address. What Release 1 differs in is written up in the notes that go with this disassembly.

Which bytes are code was found by running the game, not by reading it. The build plays it in SkoolKit's simulator -- with the keyboard and with a Kempston joystick; in every room, entered the way a new game enters its first; picking up, using and dropping every thing in every room; walking into every door; to game over; and into the room that ends the quest -- and records every address the processor fetches an instruction from. Recursive descent then follows the branches out of what ran, inventing nothing. The game prints its text through a routine that reads the string from after its own CALL (PRINT); those strings are laid out as the text they are. The rooms (ROOM1) and the parts they are drawn from (PART1), the object table (OBJECTS_TAPE), the object templates (TEMPLATES_TAPE), the font (FONT), the textures (TEXTURES), the sprites and the game's text are laid out a record per entry or per line from the game's own bytes each time the disassembly is built, so the game's design is never written into the repository's files. Each sprite's and texture's picture is drawn from its bytes the way the game's drawing code reads them. Which sprites there are was found the same way as the code: by recording, as the sessions played, the sprite every object in the room showed. The listing reassembles byte for byte with sjasmplus, and the snapshot rebuilt from it is the one the tape made, byte for byte.

Everything from $5B00 to the top of memory, all of it loaded from the tape except the loader's own bytes (LOADER_TABLE to $DD38). A good deal of it is not what the game runs with. The start-up (START) copies the object table and the templates from where the tape has them (OBJECTS_TAPE, TEMPLATES_TAPE) to where the game reads them (OBJECTS, TEMPLATES), and keeps a master copy for new games at MASTER_OBJECTS; on the tape those three places hold leftover text. From the first room on, the loading tune's routine at LOADING_TUNE and everything above it to $DBFF are the game's screen and sprite buffers. Several stretches are leftovers of the machine the game was written on, saved with the game: pieces of Fairlight's own source text (SOURCE_AND_STACK and others), and part of the assembler's symbol table (SYMBOL_TABLE), whose names and values are those of this very release.

Ville Krumlinde's disassembly of Fairlight (github.com/VilleKrumlinde/FairlightZ80), labelled and commented and reassembling to the snapshot it was made from, was read beside this one, and some of the names and facts here were first found by him; he is credited where they are used. It carries no licence, so only facts, addresses and names are taken from it, each checked against the game's own code and against running it, and every word on these pages is this project's own. Where the two disagree, the notes that go with this disassembly say so.