Mercenary

01 · Mod

Targ Traffic: traffic on the roads and in the sky

Targ's roads are empty and its sky nearly so. This mod fills them with cars and craft the game already knows how to draw. Each one belongs to the Palyars or the Mechanoids, and shooting one brings that side's attack ship after you.

What moves

Cars head for the Coach and Horses (15-02), for the other named places, or anywhere on the road network. Every so often it is match day: most of the cars that set off then drive to Bosher Stadium (08-07) and park there until the game is over.

Shooting one

Your missile hits a car or a craft by the rule it hits the attack ship with: within 1,024 units on every axis, tested once a pass. It samples its path every 4,096 units, so a straight shot can pass through a small target, in the mod as in the game. Benson then prints YOU HAVE JUST DESTROYED, A PALYAR CRAFT or A MECHANOID CRAFT, and the owner's line from the landmarks' scripts: PALYAR SHIP ATTACKING or MECHANOID SHIP ATTACK. The game's own attack ship follows.

How it joins the game

• Every vehicle is drawn by the game's object routine, draw_object, through object slot 9: one of the Dart slots among the moving objects that the game never uses. Near ones are wire models turned by the game's 64-step heading, far ones the game's single dots, with the game's own rules for what is too far to see.
• The hit test is the game's missile_hit_test ($8833), run on the borrowed slot.
• The two reprisals are event scripts in the game's own byte code, twelve bytes each: a call to the landmarks' YOU HAVE JUST DESTROYED ($0CC1), a line printed from words in the game's dictionary, then a jump into the landmarks' scripts at $0CC4 or $0CCC, which print the attack line and set $BEF8. They sit at $BC90, in bytes nothing reads, and entries 30 and 31 of the script table point at them while the mod is on.
• The mod keeps its own random numbers, so the game's generator at $ADEF runs the same sequence with the mod on or off. The traffic is not in saved positions: a save is the game's own 1,904 bytes.
• The owners are the mod's choice. The game names no owner for any craft; the mod gives the diamonds and the Darts to the Palyars and the jets and the CHEESE to the Mechanoids, and each car the owner of the square it starts on, or either side on a square that is nobody's.
• The traffic costs the game no time. On a C64 the extra drawing would slow every pass; the port leaves it out of its clock.

02 · The port

Every routine of the game, checked against the original at every pass

Nothing on this page emulates a 6502. The game's 294 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, and puts back the original disk's first message (the listing was made from a copy that says ABC UNLIMITED in the same 26 bytes). From then on the port reads and writes the game's variables where the game keeps them, draws into the game's two bitmaps, and runs the game's event scripts, messages and save files as bytes. Every value the game computes, the port computes with the same arithmetic: its truncating floating point, its sine tables, and the operands its code rewrites in itself.

How it was checked

The original code runs in a 6502 simulator beside the port, from the same saved moment and with the same keys and joystick. At the start of every pass all 64 KB are compared, and the video chip's and sound chip's registers too. Only the stack and three bytes of scratch are left out.

Each group of routines was first tested alone against the game's code: every square of the road table, every entry of the row fills, thousands of random states for each routine that projects, clips or draws.

Where the original depends on its interrupts

The port runs the raster interrupts between the steps of a pass; the C64 runs them wherever they fall. Two routines in the game give different results depending on where, and the port shows the case where the interrupt came after the step.

• A white band for a pass or two. The routine that fills the sky and the ground keeps its fill byte in $06. The interrupt that prints Benson's figures uses $06 too and does not save it. When a figure is printed while the view is being filled, the rest of the fill is left at 0, which the view shows in the background colour: white, on the surface. The session through the door at $AB shows it for two passes, with the lower part of the view white where the port shows the ground (picture below).
• The lift's height. During a lift ride the interrupt moves the ride on, and the main loop reads the ride's step to set your height. The game reads it twice and starts again if it changed in between, so it never takes a torn value, but which of two frames it takes depends on where the interrupt fell. The port's height can be one frame's step behind.

03 · Speed

It runs at the C64's speed, pass for pass

The game moves you a fixed step each pass of its main loop, and a pass takes as long as the drawing does: about four frames in a room, six to ten with the city in view. A port that ran as fast as the browser can would be a different game.

So the page keeps a PAL machine's clock: 312 lines of 63 cycles, 50.12 frames a second, with the raster interrupts on their lines. The port does not execute instructions, so it cannot count their cycles. Instead each routine it calls adds a fixed number of cycles, that routine's own, and each pixel drawn, row filled and far dot plotted adds its cost. The costs were fitted on the original: 69,569 stretches of the main loop from fifteen sessions, timed on the simulator and counted on the port. For a whole pass the fit is within about 1 % nine times in ten, and within 2 % on sessions it was not fitted on.

Smooth motion

The C64 redraws the view once a pass: about twelve times a second in a room, five to eight times with the city in view. With Smooth motion on, the page draws the view at the screen's own rate, 60, 120 or 144 times a second, and the game underneath does not change.

This works because every picture the C64 shows is a pass behind the game. While a picture is on show, the next one is being drawn, from where the game moved you at the end of the pass before. So the page knows where the next picture looks from before it appears. It draws the picture on show from an eye part of the way there, and moves each craft, car and missile part of the way to where the game has already put it. By the time the C64 would flip to the next picture, the view has arrived at it.

How long a picture stays on show depends on how much the next pass draws, so the page cannot know it in advance. It follows the program through its pass and expects the rest to take as long as it did last time. One kind of pass runs much longer: the one that rebuilds the list of roads in view, when you fly into a new square or a new band of height. The page sees that coming from your course and slows the glide for it, where the C64 holds the picture.

What the game changes at once stays sudden: a door, a lift, boarding or leaving a craft. A craft's turn and a building's rotor keep the game's steps, since only positions slide. Without native resolution the page draws the view in the C64's pixels with its own lines and fill, which match the game's bitmaps to within a pixel.

04 · Differences

What differs from a C64

• The disk. There is no loading: the game starts at the countdown. Saves go to the browser's storage, one for each digit, in the game's own 1,904-byte format.
• The screen. The video chip is drawn line by line from the registers the game writes and the line each write lands on, which is how the game splits the screen into the view, the panel and the message window. A register written in the middle of a line takes effect from the next line.
• The sound. The game's writes to the sound chip go to the site's model of the SID, a frame at a time.
• The interrupts. They run between the steps of a pass, not inside them (section 02).
• Smooth motion. A view between two of the game's pictures never appears on a C64. The page draws it from the game's own positions, part of the way from one pass to the next (section 03).
• The keyboard. The arrows are the joystick in port 2, and F or the right Ctrl key fires. The other keys are the C64's by name: the digits set the thrust, T takes and B boards. Esc is CTRL + RETURN, the game's pause.