Retro Gaming via the Internet

About 20 years ago (shudder) I would often spend a Sunday afternoon playing Spectrum and Amstrad games with my good mate Keith. There was a small selection of games we’d play pretty often including some of the Julian Gollup games – Rebelstar, Rebelstar Raiders, Laser Squad and so on.

Once in a while I’ll spark up an emulator and play some of those old games for a bit of nostalgia and an instant hit of fun. Unfortunately with our lives being what they are, it’s no longer convenient for me to spend all Sunday afternoon at Keiths place, playing Spectrum games.

So I hit upon an idea. Play two player games by sending Spectrum memory snapshots between players via email after each turn. Each player just needs a Spectrum emulator and email setup.

Emulators are available for most platforms, and they all seem to support the .SNA format, so it makes sense to standardise on that. Compressing the image down reduces it by about a half (depending upon the game) so you’re sending less data over your email, although a 48K snapshot isn’t exactly huge.

Here’s the process as I see it.

Prep

• We choose upon a game to play – this time we’re using Rebelstar
• I installed Spectemu for Ubuntu, Keith grabbed Spectaculator for Windows.
• I downloaded tape image of Rebelstar which the author has placed in the public domain, and the instructions .
• Load the tape image into the emulator (I let this run at normal speed for maxmimum nostalgia)
• Save a snapshot (key F2 in Spectemu) and mail it over to Keith for him to test

Playing the game

• Flip a virtual coin to see who goes first.
• Whoever goes first loads the snapshot and takes their turn
• Once the turn is finished, save a new snapshot with a new name and email it over to the other player
• The other player loads the snapshot in his emulator, takes his turn and sends it back to the first player
• Continue until we finish the game!

What could possibly be better!?

Further ideas:-

How about a web based service where people can find others who want to play the same game. They could play it in a browser plugin (java emulator) which at the end of turn would stop the emulation, and send a link to the other player to continue play. Further to that the game or emulator could be patched to detect the end of turn, to prevent/reduce cheating.

Other systems. Other retro gaming systems are available. There’s no reason to limit this to just the Spectrum.

Non strategy games. Clearly strategy games work well for this, as it allows each player to ponder their moves and issue them before ending their turn and sending back. However there’s no reason a non-simultaneous two player shoot-em-up or puzzle game couldn’t also use this system.

Update: A further thought occured to me. Rather than email back and forth (which would be easy but inefficient), we could use a revision control system such as bzr or git, which would centrally hold all versions of the game state. This needs more thought!