Or more widely known as Creatures - if you’re not familiar with it (and unfortunately I’d take a bet you’re not), it’s a 2D simulation “artificial-life” game featuring rather odd beings known as Norns and Grendels. I don’t believe it is the first, but it is likely one of the first games to utilize neural networks for simulating some surprisingly complex beings.

Before you read too far into this article, I’d very highly recommend purchasing a copy of Creatures and taking a look at it yourself, as otherwise you’ll be missing a lot of important context!

In late October, I was given permission by EemFoo from Eem Foo’s Archive to take a look at a prototype of Creatures (referred to as Creatures 0 by the community) from March 1994 (it should’ve since been made available for everyone). This is back when the game was called Small Furry Creatures - hence the title of this article - and, at the time, was targeting ol’ MS-DOS as opposed to Microsoft Windows.

Before we begin

The game Creatures was conceived by Steve Grand, who was responsible for a good portion of the programming as well as the particular neural network model employed by the game. Prior to creating Creatures, Steve Grand had designed Rome Pathway to Power and The Adventures of Robin Hood, under the company called Millennium Interactive Ltd.

Both of these games produced by Steve are very different from Creatures, however The Adventures of Robin Hood was perhaps an interesting foot into the door of simulation and features an open-ended design - the player doesn’t necessarily have to complete the main objective and can instead experience/explore the world, all the while the characters in the world individually do their own things.

Just a little over a year after the release of this game, and less than a year after the release of Rome Pathway to Power, Steve proposed his first pitch for what would eventually become Creatures in November 1992. This was then followed by another pitch later in the same month which aligned more closely with the end product.

When development began, Creatures started life under Millennium, before it ultimately became CyberLife Technology Limited in October 1996 (and then Creature Labs Ltd. in 2001). The “game programming division” of the company was then purchased by Sony in July 1997, which then became SCE Studio Cambridge and then Guerrilla Cambridge, before ultimately closing.

Anyway, with that out of the way…

Let’s proceed; a quick nose through the directory

Upon opening the folder containing the prototype, there’s a slew of different files held within - three executable files, 137 ‘spr’ files (sprite sets), a collection of miscellaneous ‘dta’ files (boy I wonder what that extension means), ‘brn’ files (brains, mmm), some ‘pal’ files (not your friends; just a bunch of palettes), a single ‘dat’ file and finally a single ‘bk’ file.

There are three executables here; ‘albia’, ‘brainmap’ and ‘watchdat’. The last two are actually rather complex tools relating to the chemistry and behaviour of the creatures, and the first is the game itself, which we’ll promptly now open in DOSBox.

Oooh, stuff!

The Millennium version indicates that this version was provided to Millennium Interactive Ltd. (the company Steve Grand worked for at the time) on the 22nd of March (this is a UK developer, so none of those nonsensical US dates here).

Beneath that, you probably noticed Maxis version in there too. It seems likely that Maxis were interested in publishing the game at the time, or at least providing distribution in the US. Of course, this didn’t appear to have panned out. Within Steve Grand’s old diary, certain names are omitted but, knowing this now, it seems very likely the mysterious ‘M’ referred to there was Maxis - this would imply that they were involved from at least March 1993 up until April 1994 (a month after this build was produced).

M[axis] have officially cancelled this project! They are still interested in discussing SimSeaWorld later. If they go ahead, Toby or Kev will write this, with me providing neunet code. Millenn will now look for new US distributor for furries.

1994/04/18, Steve Grand’s diary

Of course, there never was a SimSeaWorld.

Move damn you!

Once we’re into the game, you’ll probably notice that our creature looks very different to those in the final game. More bird-like I’d say. Unfortunately we’re also presented with our first problem. Our creature is stupid.

Norn’s (those are the bird-like guys in this prototype) are unsurprisingly a bit less intelligent than those we see in the final game. I’m not smart enough myself to understand the specifics as to why, but I’d say it appears there can sometimes be a lax of drive to motivate them. Initially our Norn will walk back and forth a bit, perplexed by the cursor that’s poking and prodding at it, perhaps interacting with the lift button a little, but nevertheless it will soon determine that the appropriate course of action is… Nothing?

Truly I’ve left this prototype for several hours only to get back and find the norn still stood in place. One does wonder what is going on in that little head of his.

Well, this prototype does actually provide us with a way to find out via a little terminal provided at the bottom centre and by clicking on the buttons to the left of it we can cycle the different available view modes.

Each of these, as you can see, are really nicely animated but from a user perspective, quite overwhelming with obscure information. And regardless, our norn still finds themselves in quite a predicament.

This norn soft-locking seems to occur quite frequently in this prototype though can typically be remedied by a slap on the bottom, and after a bit of training it was eventually possible to coax my norn to just chase the now less-than-friendly cursor forever. Perfect.

The norn itself that we’re actually looking at here is called Adam, as suggested by his ADAM.BRN file which gets updated upon closing the game.

This prototype features a few interactive objects, some of which can be found in this room - a portrait of what I presume is two norns in love, some books, an ink pot and a blackboard that can be used for teaching the norns which is similar to the teaching terminals found in the final game. In other parts of the world there is also a hot air balloon, another norn and a grendel.

Grendels look quite different in this prototype too, though still exhibit some qualities that remained in the final game such as their ugly nature and green appearance.

Welcome, to… Uh, Albia?

You likely noticed that the world here is not at all familiar. If we focus on the background, one particular stand-out is that it’s all pixel art! This wasn’t quite the case in the final product, with the developers instead opting to commission a company called Complete Fabrications to produce a physical diorama instead, which was then cleaned up digitally.

Another stand out here is we can actually see day and night cycles. Stars in the sky followed by a gradual cycle between different colours to indicate the time. Day and night cycles are _technically _still in the final game but not really functional, however they did make a comeback in the sequel (though it’s not really visually represented like it is here.) We’ll discuss how this is accomplished later, but still, very cool.

I chose the particular screenshot above because we can actually see a bit more progress on the background was made prior to it being scrapped.

(Source)

It looks like the artists added a lot more depth to the scene. We can even see another windmill far off into the distance, and it looks like the closer windmill was moved back a bit.

At this point in development, the background was pretty unfinished. There were plans for it to seamlessly wrap around but a good portion of the art isn’t finished here.

Given the age of the game, and it’s low resolution and narrow perspective, we can’t really get a very good look at that background - so like any totally reasonable person, I ended up cobbling together a viewer to solve this problem and to eventually display some additional data about the world (which we’ll see later).

Do ignore the floating heads and text overlay. Some fool put them there. Totally nothing to do with me… Okay I submit.

As you likely noticed, the background is BIG - and this is only the completed area I’m showing here, there’s a mass of empty blocks further along that were intended to eventually wrap around to the other side. In it’s completed form the world would’ve been larger than that featured in both the final game, and it’s sequel, and _technically _Creatures 3 (though the latter is broken into multiple sub-worlds, and collectively I’m not sure if those would be bigger or smaller if they were all joined together, but I digress).

_Blocks _you say? Yes indeed. The background here is made up of 128 blocks; 32 blocks across and 4 blocks down. Each block is made up of 16 sprites. Each sprite for a block is 80 pixels across and 40 pixels tall.

In total size the background is 10,240 pixels wide but only 640 pixels high - that’s pretty decently big!

Behind the background is the BKGND.DTA file, which in this prototype is a key component controlling how the background is displayed. The background being a rather uniform setup, can easily be rendered using a pretty simplistic algorithm (which is how I’ve done it myself), but instead, this file outlines the sprites for each block column by column - this may have been decided to allow for more unusual background setups down the line or for reusing certain tiles or… I don’t know.

For day and night cycles, this build gradually interpolates through five separate palettes depending on the simulated time. The palettes themselves specifically represent dawn, morning, afternoon, evening and night. I don’t really think there’s much more to it beyond that, but it’s certainly effective.

There wasn’t much time for me to study how the stars are done in this prototype but from a glance it appears to use a hard-coded pattern that it attempts to draw over the view, regardless of where the perspective is - which is probably what results in the seemingly stationary pattern the stars use. For each pixel on the screen that uses a particular part/range of the palette, it then draws our star, otherwise it’s discarded… Or something along those lines anyway.

I’m not going to go into too much depth on Albia itself here and the differences within, because I think this demonstrates itself, however I’ve included a few more screenshots below demonstrating my adventures for those that may not be able to run the prototype for any reason.

A little more on Objects

Just like the final game, pretty much all interactive elements are internally, creatively, referred to as ‘Objects’. However, there are very few objects here compared to the final game, and in this prototype, COBs, which are objects that can be inserted into the final version of the game, did not exist here and instead everything is hard-coded.

In addition to that, as far as I can tell, all the object placements in this prototype are also hard-coded which is certainly surprising.

There are a few objects here however that did not make it to the final game. One in particular are boids which are manifested as simple birds (of two types I should add) that fly past now and then in exterior sections, but the name suggests a more complex nature that’s clearly not present here which is a shame.

Any sort of bird didn’t really make a return until Creatures 3 as far as I recall.

The game was also to feature a book that players could pick up and read, which one would assume might’ve been used to provide information on looking after your creatures or lore or some other information. This, as far as I can tell, exists in the prototype, but I’m not sure if it was placed into the world anywhere.

The file TEST.BK provides some text that appears in the book if it’s opened, using a fairly simple markup language.

    |||  A BOOK...
    This is a|left page.
    #00 // test piccie
    This is a page|of text on|three lines.
    And another|page of text|but this time|on four.
    #00 // test piccie again
    There's an|illustration on|the left page|this time.||The End.
    $
    $

Impressively, as you can tell from the text above, it allowed not just for formatting of text but for inserting images as well. | appears to work as a line-break and # to denote an image, however I’m not too sure about the others.

It also looks like this book survived a bit further into development (including it’s sprites) prior to being scrapped, as we can see from the screenshot below with a build running under Windows.

Creatures Alpha Screenshot 2 (Image Credit: Doringo)Source

Another object unique to this build is the hot air balloon which allowed for your norns to go on fun airborne adventures - providing they weren’t scared of heights.

This didn’t survive into the final game.

Another object that’s unique to this prototype is the scanner probe. This small floating device was actually quite cool, and I’m a little disappointed it did not survive development, but it floated beside your active norn - if you wanted to swap to a different creature then you could grab it and drop it beside the other norn, and it then follows them instead. The scanner at the bottom of the screen also provides readings for the norn this little guy is currently following.

The function this provides was partly replaced by the active norn indicator in the final game.

There are many other decorative items that did not make it into the game too of course and essentially none of the sprites here made it into the final game.

Rooms

Rooms are invisible areas that are defined by ROOMS.DTA to indicate whether a space is outside or inside, and the volume that space occupies. These play an important role in determining collisions as well as some other behaviours relative to both the norn and other objects, as the background itself does nothing towards this end on it’s own (the background itself is basically invisible to the norn and objects.)

As a matter of fact, rooms are so important that without any rooms defined our poor norn will not be able to move. Terrible.

Rooms are still a component that exist in the final game and remain, as far as I understand it, the same in their function as they are here.

The format itself is pretty straight forward as well; we first read in a 32-bit integer to get the number of rooms available, and then read in each room following that. Each room is of the following format…

    int16_t x;
    int16_t w;
    int16_t y;
    int16_t h;
    uint16_t type;

Be mindful that while the x and y are absolute, the width and height are relative to the x and y, which initially threw me off a bit here.

When overlayed atop the background in our viewer, we can see the rooms like so.

Ooh, brains

So most of this is a bit beyond me. There’s a fantastic piece written by Alan Zucconi going into how the brains of the creatures work, which may be relevant here, but I’m not going to pretend I understand much of it.

In this particular prototype there are slots for up to 16 drives altogether, just like the final game, but unlike the final game where 14 are in use, only 13 are used here - these creatures have no sex drive at this stage of development, which isn’t surprising given it wasn’t envisioned that breeding would be a feature at the time.


Drives as they appear in the prototype via the scanner.

These are the following…

  • Pain
  • (Need for) pleasure
  • Hunger
  • Coldness
  • Hotness
  • Tiredness
  • Sleepiness
  • Loneliness
  • Overcrowdedness
  • Fear
  • Boredom
  • Anger

When it comes to actions, again, there are slots for up to 16 actions altogether just like the final game, however as far as I can tell it appears that only 10 of these slots are actually used in the prototype, unlike the final game which uses 12.


Actions as they appear in the prototype via the scanner.

I believe in the prototype that they are the following…

  • Quiescent
  • Activate 1
  • Activate 2
  • Deactivate
  • Come
  • Run
  • Get
  • Drop
  • Think
  • Sleep

In the final game there are two additional actions, Left and Right, that are not present here.

Jumping out of the game for a moment, we should take a look at both of the other executables included here, ‘brainmap’ and ‘watchdat’ which mentioned previously are tools.

The first one requires a .brn file in order for it to work (which we fortunately have several of), before it will then provide us with a map of the creatures neural network - which is complex to say the least. The big blue space we see at the top is the concept lobe.

Next is the ‘watchdat’ executable. This allows us to examine the state of the creature as it was during the period of the simulation.

And as you can see, all brain activity eventually ceased. Hm. prods the brain

This piece of software is relatively straight-forward to use with clear instructions provided along the top. That said, it doesn’t seem to indicate what timescale the data is presented in here, though with some fiddling it would probably be relatively easy to figure out.

Let ‘er rip!

Pretty short section here but if you would like to take a little poke through the sprites in this prototype, I’ve packed them all together and made them available here.

The sprite format itself is very simple and the Creatures community already did the work of reversing it for us here.

And in summary

On one hand, there’s a lot here that I’m really surprised to see and play around with. On the other, I’d really like to see a build from a little later into development before this norn design was expelled.

The prototype is pretty rough of course but also given the time in development, relatively impressive.

Unfortunately I did still have some lingering questions that I did not have time to investigate fully.

  • There’s possibly some embedded image data inside the Albia EXE? Doesn’t really look like anything particularly interesting though, so it tumbled down my list of things
  • Wasn’t sure if the book was actually inside the game world somewhere - if it is I certainly could not find it
  • I’m still not entirely sure what GROUND.DTA does. Zeroing it out didn’t break anything obvious - I had assumed it had some relation with the collisions but perhaps not?
  • If ADAM.BRN is zeroed out, it still seems to generate the data again with some concepts already there. Is this pulled from one of the norn brn files?
  • What are SIDE1.BRN and SIDE2.BRN for? Spares?

As usual, if you would like to read some of my notes then I’ve made them available here though they’re a bit incomplete given I’d stopped updating it at some stage.

If you would like to have a look at my “viewer” which fell a bit flat on it’s face when I discovered the object positions appeared to be hard-coded and somewhat lost motivation to live, you can find the code here.

And finally I’d really like to thank EemFoo for providing me with access to the prototype, so I could put this together and also to the Creatures community for keeping at it over all these years. I’ve been registered on Creatures Caves since 2006, and it’s always a joy seeing the community still going after all this time.