Chiller: play

Loading the game's bytes…

Start on

Cheats

← → or Z C walk
↑, Space or Shift jump
? or / swap to the girl and back, on the way home
Any key or Space after GAME OVER starts again

The game's own screen, drawn from the port's memory each frame as the video chip would draw it. Start on begins a new game and takes it to that level the way the game gets there, finishing each level before it in turn with its crosses taken, so the way home finds the five levels as play leaves them. The cheats work on the game's own routines: with Endless energy the routine that takes a step off the energy bar takes nothing, and with Ghosts don't hurt a ghost's touch adds no poison. Skip this level does what taking the last cross does.

01 · The port

Every routine of the game, checked against the original

Nothing on this page emulates a 6502. The game's 188 routines are written out in JavaScript, one function each, named by the listing's labels, and run on the game's own 64 KB of memory.

The page loads that memory from the listing, the same bytes the Source code tab shows. From then on the port reads and writes the game's variables where the game keeps them, draws the levels from the game's own maps, plays the game's own tunes and puts its sprites where the game puts them. The picture is drawn from that memory as the video chip would draw it.

How it was checked

Each routine was first checked alone against the game's code, run in a 6502 simulator: two to four thousand random starting states each, with every instruction the routine can reach reached at least once. Then the whole port ran beside the original, from 366 moments of play saved on all ten levels, with the same random joystick. At the start of every pass of the main loop all 64 KB are compared, and so are colour RAM and the registers the game writes to the video and sound chips. Only the stack is left out.

Sessions	Passes	Result
366 sessions of up to 5,000 passes, 31 to 40 on each level, through deaths, crosses taken, the cards between levels and the game over	1,739,834	identical at every pass in 357; the other 9 left in step at the same interrupt race (below)

A session that reaches the game over ends there, because the random joystick only changes at a pass and the game over waits for fire. The 34 moments that were saved during that wait were left out, since the port starts a session at the main loop.

Where the original depends on its interrupt

The music and the keyboard scan run 60 times a second from a timer interrupt, which on the C64 can fall between any two of the game's instructions. The port runs it between its own steps. Where that changes what the game reads, the check gives the port what the game's code read.

The random numbers. The game makes a random number from its own code bytes and the low byte of the KERNAL's clock, which the interrupt counts up. When a tick falls between two draws, the second draw sees the new clock. The port reads the clock through one function, which the check gives the value the game read.
The collisions. The video chip sets its collision registers while it draws, and the port reads them a little before the game gets there. The check first runs the game alone with the same joystick and gives the port the values it read, in turn.
The wait for line 16. Before it flickers the border while your energy drains, and before it swaps the boy and the girl, the game waits for the raster to reach line 16: it reads the line, compares it with 16 and then checks the ninth bit. Now and then the interrupt falls between the read and the check, and takes 18 lines. The game then leaves the wait on line 34 or 35 instead of 16. The port leaves on line 16, and the check stops there, since the two are no longer at the same moment. Nothing in memory differs at that point. All nine sessions that went out of step did so here.

Speed

The game runs about fifteen passes of its main loop a frame, so a port that ran as fast as the browser can would be a different game. The page keeps a PAL machine's clock, 312 lines of 63 cycles, and each routine the port calls moves it on by that routine's own cycles. The costs were fitted by least squares on the game's timings in 46 of the sessions above, over a million stretches of code between two points of the main loop. On 46 other sessions the fitted cycles came to within 0.14 % of the game's. The interrupt's own time, 1,197 cycles on average, is added where it falls.

From a new game, 400 frames	Passes, original	Passes, this page
The forest, standing	6,179	6,148
The cinema, walking right	5,508	5,502
The graveyard, walking left	6,057	6,078
The house, going home, walking right	5,948	6,099
The forest, going home, standing	6,231	6,155

Over all ten levels, standing still and walking either way, the page's count of passes is within 4 % of the original's.

02 · Differences

What differs from a C64

The loading. There is none: the page starts where the loader hands over, at the title.
The KERNAL. Chiller keeps the C64's ROM switched in and uses three pieces of it: the 50 Hz timer interrupt's own work (the clock and the keyboard scan), the routine that prints a character, which draws the cards between levels, and the one that places the cursor. The page does not carry the ROM. It has those three written out in JavaScript from what they do to memory, and they were checked against the game's run with the real ROM.
The screen. The page draws the picture once a frame from the memory and the video chip's registers as they stand. Chiller changes nothing in the middle of a frame, so this is the picture the C64 shows.
Sprite collisions. The game learns that a ghost has touched you, or that you have walked into a wall, from the video chip's collision registers, which the chip sets as it draws the line where two things overlap. The page works them out line by line on the same clock, from the sprites and characters in memory.
The sound. The game's writes to the sound chip go to the site's model of the SID, with the filter the game sets on the 6581's curve as the reSID emulator measured it from one chip. Real 6581s differ from one another, and they distort, which the model does not.
The interrupt. On the C64 the music and the keyboard scan can interrupt the game between any two instructions; on the page they run between the port's steps. The game reads three bytes the interrupt keeps: the clock, the key held and the SHIFT keys. Where the two runs could read different values, the check gave the port what the game read (section 01). In play, a key or a clock tick can be seen a few hundred cycles later than on a C64, which no one can tell.
Start on. The level buttons are the page's own. They start a new game and finish each level before the one chosen, in the game's own code, as if the crosses had all been taken, so the scores, lives and energy are those of a new game.
The cheats. They are the page's own, not the game's. Running out of energy is the only way Chiller ends, so with Endless energy on the game goes on for ever. The toadstools still poison you with Ghosts don't hurt on; with both on, they only flash the border.
The keys. The arrows or Z and C walk and up or Space jumps, as the joystick in port 2 does. Shift jumps and ? or / swaps the boy and the girl, as it does on the C64, and fire or any key starts a game. On a C64, SHIFT and C= pressed together switch the character set and scramble the picture, because the game leaves the KERNAL's switch unlocked; the page has no C= key, so that cannot happen.