What the word clouds show are very generic words like “space” or “super”, the number two (a game series is more likely to be two than three games long) and multiple word phrases which usually are popular game series, clichés (Foobar of Doom) or games with many versions or expansion packs. It is interesting that the generic words tend to be the same across 30 years — all generations of gamers seem to love dragons. Another point of interest is that a phrase from a 1980s game title is much less likely an established brand as it most likely is in the 1990s. Also, in the 1990s is became common that a game title has the release year attached to it, since EA et al started to churn out minor updates to their sports games as brand new releases.

30 years of games. Find your favorites!

Additionally, you can get a better understanding of how fast a page gets indexed by search engines and how fast it gets reindexed after you have modified the page. I found it interesting to note what’s the general strategy of different bots, now I know Yahoo really keeps visiting the pages and GoogleBot just very rarely visits older pages (but indexes new pages really quickly).

The plugin uses some simple heuristics to decide if a visiting user agent is a bot and puts it in a list of suspected bots (along with data of which pages it visited and when). You can then remove all the user agents that are not bots. Basically, This means you don’t need to manually add any bots at all, you simply weed out the false alerts. Of course, you can explicitly specify bots by their user agent string or host address.

Installing and using Seen

After installing the plugin (extract the zip file in wp-content/plugins/ and activate the plugin) data will be automatically recorded. You can monitor what is happening directly from on the Dashboard (there will be two new widgets, a list of bots on the watchlist and a list of unindexed pages). Also, if you go to Dashboard > Seen you can see more detailed lists and also the suspected bots list. I think it’s all quite self-explaining. Hint: you can click the star to add bots to the watchlist — clicking the yellow star will remove them.

In the options you can combine bots (i.e. when two or more entries have a differing user agent string but really are the same bot), delete them and edit them. The different categories are there so you can e.g. put Technorati bot in “Search engine (blogs)” which makes Seen not care if the bot has seen the latest comments. You can also categorize bots as “Browser” which means their data will be hidden as it probably won’t interest you.

Download: Seen 0.5.1 (Supports WP 2.7 thru 2.8)

What’s new in 0.5.1

See comment #2 below.

Note: This is not yet 1.0 quality but it should work OK. By downloading and installing the plugin, you acknowledge no responsibility lays on the plugin author.

My goals, as always with OS installs, were to minimize reinstalling of apps and data so that I can pretty much pick up where I left. Even though it’s common for even experienced or otherwise sane people to advocate a simple reformat of the hard drive and installing everything yet again, it’s just magical thinking to me (although it does make things simpler, but more laborous). In my experience, it takes just a bit of planning to avoid that. A tiny bit. What I did was taking backups of the most vital data (emails, most cherished boobie picture bookmarks and such) but I knew beforehands that’s not a part of plan B, even.

Then, I just installed the new OS. After some waiting and a reboot or two, the following is a list of what went through my head:

• I was worried about if old programs still work. Most programs you used to use in 32-bit XP should work OK. You simply drop them in C:\Program Files (x86). Generally, I think you should not have trouble with common (non-game) programs because they are not native 64-bit code but see below.
• Windows 7 didn’t remove my C:\Documents and Settings, even though for a short moment I thought it did. It’s simply relocated to C:\Windows.old, as are the Program Files folder and of course C:\Windows is there too in case you need it.
• The Application Data and the Local Settings\Application Data folders that previously were right under the user directory are now in C:\Users\kometbomb\AppData\ and C:\Users\kometbomb\AppData\Local\, respectively. I just dropped the Firefox and Thunderbird profile folders in there and here I am again with the same setup.
• I immediately noticed the way I set Viewer2 as the default program for image files no longer works in Windows 7, so this might be a minor annoyance in case someone else does it the way I do. In the Control Panel there’s a working way to change the default programs manually, although I would hate to do it for more than the 4 different extensions Viewer2 needs. It seems you have to click every extension through and select the program you want to open them. Stuff like this probably is avoided if the program is done exactly as the MS specs tell etc. but the reality is that not everyone did that.
• You will have trouble with file permissions if you were using NTFS (especially if this is your first time with more restrictive permissions), but this has always been the case if you move files around inside the same OS and the file owner is different (i.e. you but under a different OS etc.). Currently, I have had an interesting problem which causes some files being unable to open even though the folder has the permissions set as they should be. Even Explorer shows the files without the modification date and most programs report they can’t find the file (which in reality means they can’t open it even though the file is there).

  Found a solution: some (seemingly random) files are recognized as coming from another computer (i.e. my previous OS) and they have to manually be unblocked (file properties -> Unblock). I don’t know why 99% files that are in the same directory work without a question…

  Personally, I think they could have done without this kind of stuff somehow. Yeah, big boys’ OS’s have that kind of stuff but it’s just confusing if you really don’t want to know about that. After all, it’s the computer that should do the work. It’s kind of interesting how otherwise the interface is very much like something your mom would use after a bit of practice but if you just right click a file and go in the properties, there be dragons there.

After a week of use, here’s the problems I have encountered:

• A total of two BSOD’s in a few weeks. Both times occured when I played a video (in Windows Media Player, I mostly use Media Player Classic and there has been no problems with it). The crash happened when the video card tried to reboot itself but failed to do so (crash happened in atikmdag.sys which is responsible of the reboot stuff). Good news: I think this is related to the AVIVO technology my card uses since I have had no problems except with WMP (because I am guessing MPC won’t utilize AVIVO — this is very much a thin, optimistic hunch, though).
• It is not possible to mix and match 32-bit and 64-bit binaries freely. That is, a 32-bit program can’t use a 64-bit library and vice versa. Some examples when this is something that is the user’s problem, too:
  • A 64-bit media player can’t use the old 32-bit codecs. So, for some videos you’ll be using the 32-bit version of, say, Media Player Classic.
  • Let’s imagine you compile your hobby project as a 64-bit app for fun. Oops, all the libraries you are used to use are 32-bit and you for some reason can’t/don’t bother to compile them as 64-bit DLL’s. Solution: You revert back to 32-bit code.
  • Shell extensions (e.g. WinRAR’s “Extract to here…” when you right click a file and such things) of 32-bit programs that otherwise work perfectly won’t work anymore (since the extensions are DLL’s with 32-bit code in them and they can’t be used by Explorer which is not 32-bit). Solution: Use a 64-bit version of the program (which often still need you to double click on a .reg file to enable the extensions).
• Almost constant high CPU use when nothing of value is happening. The culprit was WMPNetworkSvc (I really like the new Performance Monitor that shows an average of used resources and not just the current level of use — makes it easier to catch those processes that use tons of power except when you are looking). I disabled the service in Control Panel\System and Security\Administrative Tools\Services as it sounded like it’s not useful for me (the label on the tin says it shares media across UPnP devices, whatever that means).

More to follow…

For example, there’s a new tag cloud view, a more traditional grid based thumbnail list and an improved version (or, a total rewrite) of the light table view which was the only view available until now (with more physical image groups that can contain other subgroups — in fact you can view a directory tree this way popping open the directories). Overall, it’s pretty sweet.

No estimates when it will be done, except for the infamous “when it’s done.”

However, since I upgraded to the maximum amount of memory Windows XP supports, and switched memory paging completely off, I’ve noticed some programs will silently fail when the system runs out of memory. And this isn’t that uncommon since I develop software and the crap programmer I am, silly mistakes are and always will be made that cause huge memory usage (and there’s also the rest of the software running on the computer). I have noticed at least Firefox simply disappears, while some software die with an error message.

For a game this wouldn’t be an issue (or a web browser even) but there are tons of programs downloading stuff or just hanging there that you’ll never notice missing. But it’s annoying to notice everything isn’t as you left it.

So, in case you haven’t thought of allocation failing, you probably should do something about it. When there’s no free memory left, even a malloc(sizeof(char)) will invariably fail. A lazy way out would be wrapping the allocation with something that checks if the allocation succeeded and if not, displaying a message box will halt the program until the user does something (kills the offending app reserving all that memory or frees some disk space for the page file) and then clicks “Retry” and then the wrapper simply tries to allocate again. In C++, the new operator can be overloaded.

Just my 2 cents (Euro).

Example code

C

void * my_alloc(size_t bytes)
{
  if (NULL == (ptr = malloc(bytes)))
  {
    // malloc failed, do something about it!
  }
  return ptr;
}

C++

This uses the function from above C code.

void * operator new(size_t bytes)
{
  return my_malloc(bytes);
}

My approach is closer to the Google Search calculator feature in that the program only has two text fields, one for the expression and one for the result. It also does conversions and has user-definable functions, constants and whatnot.

Currently, the software is in alpha state (which means it works but is not finished) which I hope will not be perpetual. It is already very much usable, though.

What is left to do is that currently the software does only 80-bit floating point arithmetics (the best precision offered by x87) and displaying the result is double precision (thanks to the fact MinGW uses Windows libraries for printing floats, which have support only up to double precision). I also plan adding simple graphical features for graphing functions.

You can find Calculon (a placeholder name) on its own project page.

Links

• Seven Warning Signs of Bogus Science by Robert L. Park, Ph.D.

1. Introduction
2. Description
   1. Determining objects that need to be tested
   2. Drawing objects
3. Caveats
4. Appendix A. Source code for OpenGL
5. Links

Introduction

Here we describe a method for checking collisions between arbitrary objects drawn by the GPU. The objects are not limited to any shape, complexity or orientation. The objects that are checked for collisions can be the same objects that are drawn on the screen. The algorithm is pixel perfect but without further refining is limited to 2D collisions.

Description

The algorithm can be divided in three separate steps:

1. Determine which objects need testing
2. Set up the GPU buffers and draw the first object so the stencil buffer is set
3. Make an occlusion query using the and using the stencil from the previous buffer

If the occlusion query returns any pixels were drawn, the two objects overlap.

Determining objects that need to be tested

Figure 1.

To speed up the algorithm, we need to eliminate object pairs that can’t overlap. This can be done by projecting the object bounding volumes in screen space. Then, we can quickly check which 2D polygons overlap and do further checking. Choosing the shape of the bounding volumes/polygons is not relevant. In this document we will use rectangles for the simplicity.

The example case in figure 1 shows two colliding objects (overlapping bounding rectangles shown red), one near hit (green overlap) and one object with no collisions or bounding rectangle overlap. To determine the collisions (and non-collisions) we need checks for every bounding rectangle (15 checks) and two checks using the GPU¹. Without the use of the bounding rectangles, we would need 13 more checks on the GPU.

The bounding rectangles in the example can be generated by finding the maximum and minimum coordinates and using them as the corner points of the rectangle. Since the algorithm finds collisions as seen from the camera, we need first project the object coordinates (or the object bounding volume coordinates) on the screen and find the minima and maxima using those coordinates. Most 3D frameworks provide functions for projecting a 3D point to screen coordinates using the same transformations as seen on screen².

Drawing objects

Before we start drawing the objects on the graphics buffer, we need to clear the stencil buffer. After that, the GPU should be set to draw only to the stencil buffer, that is we don’t need the color buffer or depth buffer to be updated.

Now, the first object can be drawn. After that, we will draw the second object. Before we start we need to set up the occlusion query to count the drawn pixels. We also need to use the stencil buffer created in the previous step and set the GPU to draw only if the stencil buffer is non-zero. We don’t need to update any buffers at this point.

After the second object is drawn, the pixel count returned by the occlusion query tells how many pixels overlap. For most purposes, we can assume a non-zero value means the two objects collide³.

Figure 2.

Figure 3.

Figure 4.

Consider the above example. Figure 2 shows two objects as seen on screen. Figure 3 shows the stencil derived by drawing only the green (right) object. Figure 4 shows what will be drawn of the red (left) object if we limit the rendering to drawing on the stencil (the occlusion query will tell us six pixels were drawn).

Caveats

Most of all, doing collision detection with occlusion queries is a curiosity. There are many, many ways to do collisions faster and most likely with less technicalities. On top of it, the algorithm is a bottleneck as it needs full control of the GPU.

This is inherently a 2D algorithm. The GPU sees any situations in which two objects overlap as a collision, as seen from the location of the camera. This if fine for side-scrollers et cetera, which also benefit from pixel perfect (fair, predictable) collisions, and other situations in which all the objects to be tested are on the same plane. Multiple depth levels (e.g. foreground objects never collide with background items) improve the situation and so does drawing only the parts of the objects that are between specified depth levels⁴.

Another possible problem is that the screen resolution may be different between systems, which makes the algorithm have different levels of accuracy. This can be avoided by doing the checks in a fixed resolution. Limiting the collision buffer resolution also improves the algorithm speed in cases the GPU fillrate acts as a bottleneck.

Finally, some older systems may not support occlusion queries or stencil buffers. As of 2008, this is increasingly rare but should be taken into consideration.

Appendix A. Source code for OpenGL

The following is source code extracted from a proof of a concept/prototype game written in C++ using OpenGL. The source code should be self explanatory.

The following builds the bounding rectangle for a object:

BoundBox box=object->GetBoundingBox();

object->DoObjectTranslations();

glGetDoublev(GL_MODELVIEW_MATRIX, modelViewMatrix);
glGetDoublev(GL_PROJECTION_MATRIX, projectionMatrix);
glGetIntegerv(GL_VIEWPORT, viewport);

for (int i=0;i<8;i++)
{
    GLdouble screenX, screenY, screenZ;

    vec3 c=box.Corner(i);

    gluProject(c.x(), c.y(), c.z(),
        modelViewMatrix, projectionMatrix, viewport,
        &screenX, &screenY, &screenZ);

    maxX=max((int)screenX,maxY);
    maxY=max((int)screenY,maxY);
    minX=min((int)screenX,minX);
    minY=min((int)screenY,minY);
}

rect = Rect(minX,minY,maxX-minX, maxY-minY);

The following can be used to set the rendering mode before drawing the object on the screen, on the stencil buffer or when making the occlusion query (note how we disable most of the rendering when drawing something that will not be visible to the player, also notice how the stencil buffer is cleared if we enable stencil drawing mode — using scissor makes this efficient):

void GfxManager::SetRenderMode(RenderMode mode) {
  if (mode==STENCIL) {
    glDepthFunc(GL_ALWAYS);
    glDisable(GL_LIGHTING);
    glClear(GL_STENCIL_BUFFER_BIT);
    glEnable(GL_STENCIL_TEST);
    glDisable(GL_DEPTH_TEST);
    glStencilFunc(GL_ALWAYS, 1, 1);
    glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
    glColorMask(0,0,0,0);
  } else if (mode==OCCLUSION) {
    glDepthFunc(GL_ALWAYS);
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_LIGHTING);
    glEnable(GL_SCISSOR_TEST);
    glEnable(GL_STENCIL_TEST);
    glStencilFunc(GL_EQUAL, 1, 1);
    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
    glColorMask(0,0,0,0);
    glBeginQueryARB(GL_SAMPLES_PASSED_ARB, m_OccId);
  } else {
    // Set normal rendering mode here (enable lighting etc.)
  }
}

Similarly, the following is used to end drawing (specifically to end the collision testing, at which the function returns the number of pixels drawn)…

int GfxManager::FinishRenderMode(RenderMode mode) {
  if (mode==OCCLUSION) {
    glEndQueryARB( GL_SAMPLES_PASSED_ARB );
    GLuint occ=0;
    glGetQueryObjectuivARB( m_OccId, GL_QUERY_RESULT_ARB, &occ);
    return (int)occ;
  } else {
    return 0;
  }
}

… using something like this:

int GfxManager::DrawObject(int oid,vec3 pos,vec3 rot,RenderMode mode) {
  SetRenderMode(mode);
  Draw3DObject(oid, pos, rot);
  return FinishRenderMode(mode);
}

This is from the main loop, it simply goes through all objects in the game. Notice how we first prepare the collision checking for the first object to be tested (i.e. create the stencil as in step 2 of the algorithm).

for (unsigned int a=0;a<m_Objects.size();a++) {
  m_Objects[a]->PrepareCollide();
  for (unsigned int b=a+1;b<m_Objects.size();b++) {
    if (m_Objects[a]->TestCollide(m_Objects[b])) {
      // We have a collision
    }
  }
  m_Objects[a]->FinishCollide();
}

Note that DrawObject is the same method as we use to draw the visible object on the screen. The only thing that differs is that the drawing mode is set to stencil or occlusion query. Also worth noting is how we use the rectangle to set the scissor to further reduce the workload.

void GfxObject::PrepareCollide() {
  GetGfxManager()->SetScissor(this->GetBoundingRect());
  GetGfxManager()->DrawObject(m_GfxId,GetPosition(),GetRotation(),STENCIL);
}

void GfxObject::FinishCollide() {
  // We simply reset the scissor
  GetGfxManager()->SetScissor();
}

int GfxObject::DrawCollide() {
  // We could set the scissor here to even smaller area, the overlapping area
  return GetGfxManager()->DrawObject(m_GfxId,GetPosition(),GetRotation(),OCCLUSION);
}

bool GfxObject::TestCollide(Object *obj) {
  Rect a=GetBoundingRect();
  Rect b=obj->GetBoundingRect();

  // No need for further collision testing if the rectangles
  // don't overlap
  if (!a.TestCollide(b)) return false;

  // We have a collision if any pixels were drawn
  return obj->DrawCollide() > 0;
}

Links

• Shawn Hargreaves Blog: Pixel perfect collision detection using GPU occlusion queries – seems to be exactly the same idea but this time using XNA

News should never be speculative and if that is the case, it has to be explicitly stated where the line between fact and fiction goes. Some news are meant to be taken as entertainment but that style of writing should not bleed to potentially important news items. At least I expect to get information from news, even if I just casually pick the interesting sounding ones.

I hereby give away another priceless idea: one-sentence news. That is, you do not need to read the full article after you have read the descriptive, 5-15 word headline. Maybe that’ll cut into the advertising profit for there are less visitors to your site from feed readers etc. but not providing full articles in a feed is yesterday. And if you really only write 20 words per article, well, I guess that could make it profitable if you divide your income by the amount of text you write.

Here’s an example: Popular Science reports “Genetic Material Found on Meteorite“. What went wrong? Take a guess. At the very least I expect to read about scientists finding very discriminating evidence on a meteorite with a blacklight, kinda like how they do it with dead hookers in CSI.

Even the subtitle right below the main title already downplays the sensational title and states “A meteorite in Australia has been found to contain component molecules of DNA”. And if you take the time to read the article, you’ll learn similar molecules that make up DNA are found on a meteorite (I bet a rather large percent of the molecules in your DNA most likely are entirely made on Earth). That’s like reporting there are organic molecules in space (look it up), and not explaining what “organic” actually means. Except in the end, right below the ad banner.

How could that be reported in one sentence and what are the benefits? First, you’ll deliver the exact same amount of information but quicker. “Similar Molecules as in Your DNA Found on a Meteorite”. “The Birth of DNA Molecules Could Have Been Helped by Completely Uninteresting Stuff on Meteorites Billions of Years Ago”. Hell, I don’t care if it’s a haiku. Just make it terse, informative and less stupid.

Here are some of the games I consider the best examples of this genre.

Thrust (1986)

What I think Thrust does that makes it so much better than Asteroids and other household names is that it takes the simple rule of motion and inertia, and adds another basic concept, counterforce. In Thrust, you not only maneuver the ship through narrow caves but you also have to lift a heavy load (a “klystron pod”) that swings under the ship. And, in most cases the roles are reversed when the heavy pod transfers its excess kinetic energy to your stationary ship, sending you both spinning towards the nearest wall. However, the whole gameplay doesn’t feel as random as it is with many modern physics based games that often require luck or endless trial and error. You are always in charge of the physics, if you are a good enough pilot.

Thrust on the BBC Micro.

Another thing that I like about Thrust is that the player is easily able to skip a few levels by activating the self-destruct sequence of the planet by shooting the power plant a few too many times. Why I like it is that in a way you feel like you cheated the game (although, you also lost a lot of bonus points). However, without a doubt this was added to make it easier to quickly get to and practice the later levels, it’s a very nice touch it’s built in the game world. It is also possible to get hefty bonus if you manage to both fetch the pod and also destroy the power plant.

Thrust has a reputation for being hard but I can’t really agree with that. The game has a handful of levels and the regular levels are quite easy to finish when you get the hang of it. However, after that the gravity is reversed and the levels loop from the beginning and after a successful completion, the walls turn invisible. And then I guess the game goes reversed-invisible¹.

Another proof of the game’s excellence is that it’s probably one of the most ported (officially or not) games, when it comes to radically different platforms. There are equally playable versions for the BBC (also the original version), the C64 (with a rocking Hubbard tune), the 8 and 16-bit Ataris and unofficial ports for Vectrex and Atari VCS². There also is a C rewrite of the game engine that is open source, which I guess ensures the game can be ported to any semi-modern platform.

There apparently was a sequel, that wasn’t so well received (proving more does not equal better) and I have never seen it.

Gravitar (1982)

Gravitar, on the other hand, does much of the same. Thrust (1986) was obviously very influenced by Gravitar (1982)³, which was probably influenced by Asteroids (1979) and Lunar Lander (1973, 1979). Both Thrust and Gravitar have planets to visit, fuel to be beamed up, enemy bunkers that shoot back and, of course, gravity. But to me, Gravitar doesn’t have as crystallized gameplay as Thrust. Thrust is as solid as, uh, Gravitar’s vectors are, umm, sharp.

Gravitar. The graphics are so sharp you can’t see crap on Youtube videos.

What’s pretty neat in Gravitar is that you can select in which order you play the levels, the levels are simply presented as planets in a solar system and you have to fly the ship avoiding the star that is in the center of the solar system. This also gives another challenge (or a possibility to optimize your gameplay) since the star’s gravity can be exploited to save fuel. Each level also is quite different from the other levels.

Oids (1987)

Oids on the Atari ST.

Another game I really liked was Oids. It combines yet more favorites of mine with Thrust: Choplifter and Space Taxi, both outside the strictest requirements of the thrustlike genre. In Oids, the klystron pods are replaced with little guys (android slaves, or ‘oids) that you have to pick up, first of course having to land the ship carefully, and take up to the mothership. Oids is so loved that the Atari ST emulator Oidemu was made just to run the game, which wouldn’t run on other emulators — and Oidemu subsequently didn’t bother supporting any other games.

The saving the little guys idea is lifted from Choplifter (get it?) in which you use a chopper to demolish prisons and then land nearby and wait for the little men to climb aboard, making multiple runs as the chopper can carry a limited amount of men. The gameplay is much speedier in Oids, you constantly have to dodge incoming bullets and homing missiles and the levels generally are much more open than in Thrust or Gravitar. In all, Oids feels like very natural progression from Thrust.

Maybe one factor that made the game so special was the fact it shipped with a level editor.

Space Taxi (1984)

Hey, taxi!

If we bend the rules what makes a thrustlike, Space Taxi is more than a worthy addition to the genre. Especially so, if you think Lunar Lander fits in the genre — both games have similar controls (thrust up, down and to the sides) and also the common goal of landing quickly yet safely.

There was a nice clone of Space Taxi on the Amiga featuring a caveman flying a stone-age version of a helicopter (think Flintstones). The game was called Ugh! and it was later ported to the PC (it’s great) and C64 (it’s crap).

While Ugh! looks gorgeous and is fun to play, what Space Taxi does infinitely better is that every level in Space Taxi is very different from the other levels, and that is not just the layout that changes (on top of that Ugh! uses the same tiles over and over, however nicely pixeled they might be). The rules of the game are often deviated slightly. For example, one level has a beanstalk that slowly grows leaves on which you can land (and the passengers start appearing on) and others simply have disappearing walls or teleports. I guess that still makes the game quite unique, since even now games rarely have radically different levels.

There also is Space Taxi 2, which is a legit sequel but the tiny voice in my head says it can’t possibly measure up. It’s worth a check, though, as it has the same level designs as the original.

Solar Jetman: Hunt for the Golden Warpship (1990)

Solar Jetman: Hunt for the Golden Warpship is pretty much exactly what Thrust was years earlier but with updated graphics. The only difference is that in each level you have to find a different object, each being a part of the Golden Warpship and various other items which upgrade the ship you pilot around. There’s also a bit of Oids in the game, as it features more shooting and has enemies that follow you around the level.

Solar Jetman: Hunt for the Golden Warpship on the NES.

The game provides welcome variation to NES games and I can see why it wasn’t a success among the younger gamers despite the great graphics (got to love the smooth rotation of the ship). The controls are smooth but as all games of this genre, Solar Jetman can be a handful. Especially, if you are looking for more straight-forward action.

The game is the successor to Lunar Jetman (which shares only half of the name and virtually no gameplay elements, except for the little spaceman that you have to get back to the mothership when your probe is destroyed, see above video) — Solar Jetman was developed by Rare who in fact were called Ultimate Play The Game who developed Lunar Jetman for the Speccy (and loads of other very successful games). Solar Jetman was also going to be released for most of the home computers of the time but the ports were canceled and only the C64 port is available to the public.

“Caveflyers”

In the mid-1990s there was a boom for so called caveflyers (from Finnish “luolalentely”) here in Finland. The caveflyer genre probably owes more to Spacewar as it’s mainly about blowing up the other players. There were dozens of similar games that all featured hotseat multiplayer action (some even had computer controlled), various weapons and levels and most importantly destructible environments.

There had been a lot of similar games by hobbyists before the boom, the single game that started it all probably was Gravity Force on the Amiga. However, I think the flood of cavefliers (in Finland, at least) was triggered by Auts and Turboraketti on the PC. I am very sure different areas had a bit different ideas what was the hottest game but at least to me, Auts was it. After that more and more clones started appearing with constantly improving quality and broadening weapon arsenal. My favorite probably was Kaboom. On the Amiga, there was a bit older similar game called Mayhem (1993) which we played a lot. There’s an abandoned PC conversion that you can find in the linked thread.

This subgenre is still alive and there are many modern caveflyers that have Internet multiplayer features and so on.

3D thrustlikes and other oddities

Virus on the Speccy

There have been various Zarch (1987) on the Acorn Archimedes (ported later in 1998 as Virus for the Amiga, Atari ST, ZX Spectrum and PC) features similar controls for the player ship except that there now are two rotation axes. The gameplay however features minimal interaction with the landscape as there are no caves. Later in 1999, Psygnosis released Lander for the PC that featured closed levels, cargo hauling and teleporting fuel on the lander. So, Lander pretty much is Thrust in 3D.

—

So, were there any games I left out that you think should be here? Do leave a comment. Also, I’d like to thank the people who uploaded gameplay videos of Thrust, Gravitar and Oids to Youtube. I had only a NES emulator with AVI output handy.

Links

• Dan Coogan’s Gravitar page a lot of stuff from the world champion
• More Lunar Lander clones you will ever need (including Flash games)
• Zarch for Linux
• Zarch for Windows
• More about caveflyers
• A lot of caveflyers (reviews in Finnish)