Mayhem in Monsterland

01 · The play screen

The screen scrolls without moving a character

Jellyland in play, drawn by this page from one recorded frame of the game. The slider shows the trick behind the scrolling: the same memory, with the video chip told to start reading the screen at another column.

The video chip can shift the picture sideways by up to seven pixels with its fine-scroll register. Past that, the usual way is to copy every character on the screen one place along, a thousand bytes and their colours each time. Mayhem in Monsterland leaves the characters where they are and moves the place where the chip starts reading them.

The chip reads a row of characters on a "bad line", which it recognises when the bottom three bits of the raster line match the vertical-scroll bits of $D011. The handler $2162, set for line $30, waits into line 50 and there writes $12 to $D011, which makes line 50 a bad line from that cycle on, and $1B five cycles later. The chip switches its display on without having fetched the row, and its count of screen positions still moves one place for each fetch cycle left in the line. The earlier the write, the further the count moves, and every row below starts that many places further on: the coarse column $0F. The cells that leave on the left come back one row down on the right.

The timing comes from a run of NOP instructions at $B17A. $2162 patches its own JSR to enter that run at $B182 plus half the column, so a higher column skips more of the two-cycle NOPs; for an odd column the branch at $2194 is not taken, which saves the odd cycle. For the cycle count to mean anything, the interrupt has to start on an exact cycle: $213D, one line earlier, waits inside the same NOP run for it.

The fine scroll $10 still does the pixel steps. When it passes a character, the scroll step $2088 moves $0F one way or the other, round from 0 to 40 scrolling right and from 39 to 0 scrolling left ($20C1), and the map scroller draws one new column of characters into the two screens at $4400 and $4800, of which the chip shows one while the other is drawn. The colour memory cannot be swapped like that; when the column wraps round, the game moves it by a row's length at once ($2482-$2538 scrolling right, $28E1-$297F left).

VSP does not behave the same on every Commodore 64. The late bad line makes the video chip switch its address lines at a moment it was never designed for, and on some machines that can corrupt memory: bytes whose address ends in 7 or F can take the value of another such byte in the same page. Linus Åkesson traced the cause in 2013 ("Safe VSP", linusakesson.net): whether it happens depends on the chip's revision, the temperature, the board, and a phase the machine picks at random when it is switched on, which is why a crash on one evening may not come back the next. Emulators such as VICE do not reproduce it, so nothing on this page could show whether, or how often, Mayhem in Monsterland meets it on real hardware.

Ten raster interrupts share each frame, and each writes the next one's address straight into the processor's vector at $FFFE ($2077), since the game has the KERNAL switched out; the checkbox above marks the line each one is set for. The first, $20F8, places Mayhem, who is sprites 6 and 7 laid over each other at a fixed X of $AC ($E426). The monsters are 15 sprite slots in three bands of five, all shown on sprites 0-4, and the handlers further down move those five sprites from one band to the next, the land choosing which band goes where ($29B0). At line $EE, $18C1 switches to extended colour mode for the panel, whose numbers are drawn into sprites ($389F).

02 · Sad and happy

Turning a land happy loads nothing

A land starts sad and grey. Once Mayhem has taken enough magic dust to Theo's cave, it turns happy: its colours, graphics, monsters and music change, and stars appear. Both versions were in memory from the start.

Each land's file, 22,272 bytes loaded at $5A00, carries two character sets and two colour tables. The video chip always reads the set at $7800, which holds the sad set while the land is sad; the happy one waits at $A900. The colours work the same way, sad at $8900 and happy at $A800, one colour for each character code.

Theo's scene is engine code kept in the memory under the I/O chips, $D100-$D6FF, which is swapped down to $6000 to run. When it ends, $3BCC restarts the stage happy, and $B785 exchanges the two character sets byte for byte and the two colour pages with them. The map does not change: the same tiles now point at different shapes. The same routine swaps bytes 3 and 7 of every object record, which hold each object's sad and happy appearance, and happy objects take their animation scripts from the entry 25 places further on ($E8AE).

Some of the happy land is code switched on. Stars appear only there because $B7C3 writes an RTS over the first byte of the star code ($38C4 and $3AEE) while the land is sad, and puts the real opcodes back when it turns happy. The music changes the same way: the sad tune, $E000, is the same in all five lands, and the happy land plays the land's own three tunes, chosen by markers in its map.

03 · Graphics

Every character and sprite, in the colours the game gives them

Each land brings two character sets and 120 sprite images in its file; Mayhem's 56 images stay in the engine. Everything below is drawn from those bytes and coloured the way the game's code colours it. Pick a land, then sad or happy.

The characters

The playfield uses multicolour character mode, with each character's colour fixed by its code. A colour byte with bit 3 set draws the character four double-width pixels to a row, in the background, the two colours the whole land shares, and the byte's own low three bits. Without bit 3 the character has eight pixels to a row in a single colour.

The character code also decides what Mayhem can stand on. Codes below the land's $9021 are walls, solid even while he jumps up through a platform. Codes from there up to $9020 are platforms, solid only while he walks or falls: each pass, $2AC3-$2AD1 sets the threshold the collision tests compare with to one or the other. The checkbox above marks the two ranges.

Mayhem is two sprites laid over each other

A multicolour sprite has only twelve pixels across, each two wide, which leaves its edges coarse. Mayhem's body is a multicolour sprite, and a second, single-colour sprite at the same position draws his outline at the full 24 pixels. The outline, sprite 6, lies in front of the body, sprite 7, because the video chip always puts the lower-numbered sprite on top. The body uses only two of its three colours: no image of his has a pixel in the third, $D026, which the monsters' bands change down the screen.

Every frame, $EE9E picks the outline image as a base for his facing ($30 right, $4A left, $EF86) plus a step for what he is doing, and $E4A6 shows the next image as the body. Running uses the eight walking images, stepped through faster. A charge is the one exception to the pairing: three outlines take turns over a single body image, $43 or $5D. Two images are edited during play. $EF93 writes one of three versions of three bytes into the jumping outline, for rising, the top of the jump and falling, and $E27B one of two versions into the standing outline. The buttons beside a jumping or standing image show them.

The monsters

Each object is a record of 15 bytes in the land's list at $A000, and the spawner $E75E turns a record into one of 15 object slots as its column scrolls into view. The slot number is the low four bits of byte 0. A slot is also a sprite: the slots come in three bands of five, and each band is shown on sprites 0-4 by its own multiplexer, $C0DC, $C01C or $C07C, which copies the slot's image, colour and position into the video chip and sets the band's multicolour, priority and expansion bits from bytes the spawner filled. Byte 8 bit 0 makes the sprite multicolour, byte 8 bit 1 puts it behind the scenery and byte 5 bit 4 doubles its height. Nothing doubles a living monster's width: the spawner clears that bit for the slot.

A monster bigger than one sprite is several records in a row with the same group number, byte 8 bits 4-6, which the spawner brings in together ($EC72). The record whose byte 3 has bits 6-7 clear is the leader. Each follower names the leader's slot in byte 14 and starts at the leader's X plus an offset from the land's table at $940F, chosen by the low bits of bytes 1 and 2 ($E970-$E981); its Y is its own byte 6. From then on every sprite follows its own record's movement paths. Most followers have their leader's paths, so the group moves as one. The lower-numbered sprite is drawn in front, which lets a group lay a single-colour outline over a multicolour body, the way Mayhem is built. A record whose byte 12 has bit 7 set is a second kind of companion: it waits hidden, is sent out from the position of the slot that byte 12 names, and is sent out again each time its own path starts over ($C56D, $C30D).

Each record's type, byte 3 while sad and byte 7 while happy, selects six animation scripts from the land's tables at $956E: moving up, moving down, moving left, moving right, standing facing left, and standing. $CA8B picks one from the direction of the object's last move, and byte 5 bits 6-7 limit the choice to the vertical pair, the horizontal four, or one script named directly. A defeated monster switches to the script that byte 11 names, and byte 4 bits 5-7 decide how it looks while that runs: double width, double height, and whether it stays multicolour ($C842-$C89A).

A sad land's monsters are all one grey because the spawner never looks at an object's own colour while the land is sad: it takes the land's $903A instead ($EB4C-$EB54). Three kinds of object escape that rule even while sad. A portal takes its colour from its record. The object spawned straight after a portal in the same group comes out white, because the counter at $ECF0 that the portal raised gives the next object colour 1 ($EB2B-$EB37). An object sent out by another, with byte 12 bit 7, steps through a colour list of the land's.

04 · Screens

Every screen is drawn in bands, top to bottom

Each picture is characters, sprites and a chain of raster interrupts that changes the video chip's settings as the beam moves down the screen. Each screen below is one frame recorded in the emulator: memory as the frame began and every write to the video chip during it, drawn again here.

The layers are made by changing the recording before it is drawn. "Characters only" sets the sprite enable register $D015 to 0 at the start of the frame and in every write to it. "Sprites only" sets every byte of the character set to 0, so each cell shows its background colour. The sprite boxes mask bits out of $D015 the same way.

In play and on the title the handlers are chained through the processor's own interrupt vector: each one sets the raster line and the address of the next before it does its work ($2077), and the last one sets the first. The stage card's handlers return the next line and address to a dispatcher instead ($1868). Eight sprites are not enough for a screen of monsters, so in play the sprites are used again further down: band by band, a handler moves sprites 0-4 below the band it has just left and gives them the next five objects.

05 · The title screen

The title screen is happy Jellyland behind 32 sprites

The title has no picture of its own. Its code is in Jellyland's file ($A547), and it shows the land itself, made happy, scrolling one pixel a frame behind the logo. Every word on it is made of sprites.

The loader jumps to $A547 after it has loaded Jellyland at the start of a game, and game over at the first land jumps there too ($3EA7 in the engine). The title turns the land happy if it is not ($A56C), puts back the stars an earlier game took out of the map ($A4B1), and starts the map at column $90 ($A5B5). The play-time interrupt chain does the rest: the same VSP split, the same scroller called from the title's loop ($A612), and the title's own handlers spliced in after the split ($A59B). The object bands are switched off by an RTS written over the first byte of each ($A598), and the panel's handler is replaced by the engine's scene handler $B1AD, which turns the bottom of the screen black and puts up the logo for the next frame.

The top-score line reuses the panel's score sprites. The title copies the top score into the score digits and draws them into the panel's sprite images as in play ($9E54). Images 0 and 1 hold the word SCORE above their digits. The handler at $935A moves sprites 1-3 and their shadows to the left on line 202, between the word and the digits, so the digits sit centred under TOP SCORE.

All of this has to fit the video chip's 16 KB bank, $4000-$7FFF, beside play's screens and sprites:

06 · The front-end character set

Every word between the stages is four characters a letter

The stage card, the loading screen and the stage-complete screen share one character set of their own. The engine keeps it in the 2 KB of RAM under the I/O chips, $D800-$DFFF, where the video chip cannot see it, and swaps it into the bank when one of those screens shows.

A letter is two characters wide and two high, and the glyph map at $B6D5 gives the four codes of each: A to Z, the digits, and ! . , ? :. The printer reads the string as ASCII and turns each byte into a place in the map ($B84C-$B8A8). A space moves one column and draws nothing. I, J, L and the punctuation but ? move one column, so the next letter covers their right half, which is blank; M and W draw a third column after their first two. The font has no lower case: the box above turns what is typed into capitals, and drops anything outside $20-$5F.

Page swaps move the set in and out of the bank. They exchange whole pages byte for byte with every ROM and the I/O banked out ($3F54; swap numbers from its tables at $3F34):

07 · Music

Music: every tune the game stores, played by its own driver

The game keeps 24 tunes: two in the intro, six in the engine, three in each land's file and one in the ending. The player below runs the game's music driver, ported from its code, once a frame through a model of the SID chip.

08 · The map

A land is six rows of tiles, some of them drawn twice

Every land is one strip of map, 24 characters high, built from tiles of four by four characters. Click a cell to see which tile and which character it comes from.

The map is six bands, one above the other, and each band is 256 bytes at $8A00, $8B00 and so on up to $8F00: one byte for each map column. A byte below $D0 names a tile, and a tile is 16 character codes at $8009 plus 16 times its number. Each character code has one colour, from the table at $8900, wherever it appears.

Bytes from $D0 up are markers, and they take no column of their own. $D0-$DF starts a stretch to repeat. At $E0-$EF the scroller jumps back by a length from the land's table at $9000 and draws the stretch again, as many times as the table says ($269F-$27F0 in the engine). Bytes from $F0 up start a tune in the happy land. Jellyland stores 242 columns and draws 349; Spottyland stores 243 and draws 376.

09 · Stars

A star is worth more the faster it spins

All the stars in a happy land spin together, and their speed rises and falls on a fixed cycle. A star pays what the spin is worth at the moment Mayhem touches it, from 500 points at the fastest to nothing at the slowest.

A star is a block of two by two characters, codes $FB-$FE, and every star on the map uses the same four. Spinning them all costs one copy: $3AEE writes the next of the 20 images, 32 bytes, into those four characters of the character set, and every star on the screen turns at once.

Each image stays for one frame more than the current speed, so a turn of 20 images takes 40 frames at speed 1 and 120 at speed 5. After each turn the speed takes the next of 26 steps from the table at $EDF5: 5 4 4 3 3 3 2 2 2 2 2 1 1 1 1 2 2 2 2 2 3 3 3 4 4 5, and round again. The whole cycle is 1,880 frames, about 37.5 seconds, of which the fastest spin lasts 3.2.

When Mayhem touches a star, $38C4 removes it from both screens and from the map, and scores the current speed as a score event ($3901-$3908). Event 1 is 500 points, 2 is 200, 3 is 100 and 4 is 50; speed 5 is skipped, so a star taken at the slowest spin pays nothing, though it still counts towards the quota.

10 · Scoring

Every score is one of 16 fixed awards

The score is nine decimal digits, one to a byte, and every award adds one fixed amount to one of them. A multiplier, collected as a bonus, repeats the award up to five times.

The awards are a pair of tables: the amount, $34E7, and the digit it is added to, $34F7, from 0 for the hundred-millions to 8 for the units. $350B adds the amount to that digit and carries upward one digit at a time. Monsters name their award in their record in the land's file (the low four bits of byte 10, read at $EA2A); the records in the five lands hold events 0 to 11, so no monster is worth more than 20,000 points before the multiplier. Other awards come from fixed places: a bonus item pays 200 or 500 ($BC34), and a star pays by its spin.

The biggest awards come at the end of a stage. Crossing the finish line in the happy land ends it, and while Mayhem skids on, each character he slides over adds one to a two-digit skid count ($1EFD-$1F24, with a rising sound). The stage-complete screen ($F302) then counts each line down into the score ($BE84):

Each million the score passes gives an extra life, but the 100,000 of the SUPER TIME BONUS can carry the score past one without it (Discoveries).

11 · The intro

The intro fades each dinosaur from colour to grey

Side 1 plays an intro before the game: the Mayhem TV ident, the Apex logo, and a roll call of ten characters, each followed by a page of credits. Each page below is drawn by this page from the intro's own bytes, by its own routines ported to JavaScript.

Each page waits 150 frames, then the dinosaur walks in from the left one pixel a frame for 148 frames ($86F9); Mayhem runs in at two and skids to a halt in a cloud of dust ($8740-$87CA). The dinosaur is two or three sprites, doubled in height. Sprites 0-3 are solid black blocks, doubled both ways, over both edges of the landscape: they hide the dinosaur until it has walked into the window. Sprite 7 is the sun, set behind the clouds.

When the dinosaur arrives ($8064) the landscape stops, the scene turns white and then fades to grey over eight steps, and the name scrolls in from the right while the Latin name scrolls in from the left ($8B2E, $8B5C). Both fonts are drawn as holes in black characters. The colour comes from the background register, which a raster interrupt changes on every line behind the text ($8045, colour tables from $9565), so the letters show stripes the characters do not have.

12 · The intro's landscape

The intro's landscape scrolls at three speeds without moving a character

Behind the dinosaurs the clouds, the mountains and the ground move at different speeds. The landscape is drawn once, and nothing on the screen moves: the intro shifts the pixels inside the characters.

The window, rows 7-18 and columns 6-33, is built once per page from the rows at $75B0, and each row repeats a short run of characters across its width: 14 for the clouds, 7 for the mountains, 3 for the ground. Shifting the pixels in that one run moves every copy of it on the screen.

The routines run from the raster interrupts that also set the sky and ground colours, and stop when the dinosaur arrives. The clouds and the mountains take turns, one on odd frames and one on even. A page's set-up takes two frames, and the main loop does not count frames while it runs, so both of them are even: the mountains move twice and the clouds not at all.