Postmortem – The Speccies

Me and The Speccies goes way back. Well, not that far back – but the game is based on a SNES games called The Brainies (known in Europe as Tiny Skweeks) and me and that game goes way back. I never had a SNES though (in fact – the first console I bought was a Dreamcast) and I only discovered The Brainies through emulation. And I liked it. I wasn’t very good at it…but I liked it anyway. The idea of remaking the game came to me in February 2007. It was basically a tilebased puzzlegame – that should be easy to do, right?

Well, I had big doubts about whether I could make it at all – the whole “automatically rolling and reacting to the tiles below the character” seemed like a very difficult thing to do. Of course, it didn’t make things any easier that I’d decided to make it in 3D (which I’d never done before).

Here’s a screenshot from my 3D WIP version.

WIP version in 3D with temporary graphics. Click to enlarge.

 

I usually start out with temporary graphics when I start a new project and just because this was meant to be in 3D things were no different. I needed something to move around and it was a big hurdle to even make these primitive entities, but I managed and began coding. As far as progress in this version went, you could move the cursor around, select a Brainie (here shown as a man) and move them around anywhere there wasn’t a wall, but that was all. I never got around to code the actual gameplay.

Eventually I was (as usual) distracted by something else so this 3D version was never finished, but the interest in remaking the game has always been at the back of my mind.

We forward to January 2013. By this time it had been almost 1½ year since I’d made my first game, Dingo, for the Spectrum and I was aching to make another Spectrum game, and for some reason I thought that it might be a good idea to resurrect that long abandoned idea of remaking The Brainies. I mean – it’s a tilebased puzzlegame…that’s easy to do, right?…and perhaps I could even knock it out in no time? 😉 …but as it turns out – that was not the case. 😀

I had to do a bit of research first – “would the levels even fit onto the Spectrum screen?” was the most important question, so I found some levelcodes and started looking at levels 10,20,30, and so on – from the SNES version, and as it turned out there were no surprises later on in the game and all the levels would fit onto the screen nicely.

First things first – I had to decide on how to draw the graphics. Since the sprites would pass over other sprites – and in some cases sit on top of them, I decided very quickly that I wanted to write a more advanced spriteroutine than I used in Dingo – one that masked the background to make sure everything was sharp and clear at all times. I also wanted to use a backbuffer to avoid any flickering graphics. Finally on January 25th I began coding.

Simple beginnings.

 

The first version on the 27th didn’t do much – it just drew a level from some data directly on the screen, but as I needed everything to happen on a backbuffer I started working on the code for that afterwards, and a couple of days later I had a version that just used a static background picture (from Xenon) and I worked on getting a cursor to move around and then moving the backscreen to the real screen.

It looked very different early on. 🙂

 

Then it was time to combine everything I’d done so far – so I could draw a level directly on the backbuffer and move it to the screen.

…but it doesn’t always go quite the way you want it to.

 

Eventually things would work though. Notice that I’m using sprites from Dingo early on. I find it better to get the mechanics of a game working first and then worry about the graphics later. There is no movement yet, though – just some static images.

I needed a level editor to build the levels. I’ve extracted leveldata from games before, but I decided that in this case it would probably be a lot faster to just build all the levels in an editor manually. Luckily I’d already made an editor in Blitz3D for the first version I tried to make, so I took that and modified it for the Spectrum version. By this time  I’d found the DOS version of the game and decided that I’d use that for reference instead the SNES version, so over the next month I would take screenshots of all the levels in the game (using the levelcodes) and saving them off to a folder so I could replicate all the levels using them as basis. That actually turned out to be a good decision as I realized later on, that the levels in the SNES version are simplified – there are no switches and the inactive pads are activated from the start.  I’d wonder why.

Big Ted finds himself in a strange looking game.

 

At the beginning of a new project progress is usually very slow as you have build a lot of framework. I would first start making a lot of temporary graphics so I had something to manipulate and move around. Then code a system to animate selected tiles.

I wanted the game to be fast – it’s really annoying if you have to wait too long when things move around, so I set out to write a faster version of the routine that moves the backbuffer to the real screen. As it usually is with the low-powered Spectrum, you can either code for compactness or speed. The first version of this routine was around 120 bytes but too slow for me. The optimized version was much faster…but it took up over 5 KB. That’s 50 times larger – and eating a lot of memory…but it was fast.

Around this time I started LZ compressing the levels to make them all fit into memory. I made my own routine at first but then switched to a ready made one as I found that the decompressor code was more compact than my own.

A little earlier I had mentioned to Craig Stevenson (aka. Redballoon) on Twitter that I’d begun working on this game and he offered to help with the graphics (he’d already helped me out on my remake of Arcadia so we had a working relationship). This was huge since I’m not good at graphics and I knew he was. Perhaps the game would actually  end up looking good after all. He would now drip-feed me graphics over the next couple of months, but the first one he gave me was the animated destination-pad. I used this to get the animation system working. The first animation was 4 frames, but I felt it was too coarse and I asked if he could make the animation 8 frames instead, and he obliged. It looked much better now. Until now the game was still supposed to be called “The Brainies” but Craig also came up with the Spectrum-themed name ‘The Speccies” and then that was settled. 🙂

First piece of final graphics are in – the animated destination-pad.

 

I would code a bit. Then add some graphics (which usually led to changing a lot of code as I tried to find the best way to store the graphics in memory), then build some more levels, so progress was slow. After a while of this I’d eventually rebuilt 40 levels in the editor, and recieved a lot of new graphics from Craig, so I made the last screen one where all the different tiles were visible and the animations could be viewed. There was still not an ounce of gameplay though.

Some of Craigs graphics, and some of my temporary ones.

 

Eventually I’d rebuilt all the levels so the test screen was now level 101. I’d also recieved the final graphics for the player character. At around this time I would make it possible to select a character. Yeah, it may look like a game, but there’s no gameplay yet. Babysteps.

Notice the animation of a Speccie being tested on the right.

 

As this point I was redrawing the whole screen and moving it from the backbuffer to the real screen every frame, which was a bit too slow, so I decided to drop updating the whole screen and only change the tiles that were animated – or had changed – and that gave me the speed boost I was looking for. For a while I struggled with garbage being left on the screen as you moved around, but about 2 months into the project I has the movement working mostly as it should. Slow progress perhaps, but unlike Dingo (which were supposed to debut at the Replay Expo 2011) there was no planned releasedate for this game. Good, then I didn’t have to compromise my TV addiction much. 😉 …it was mostly coded during the late evenings when I was done watching TV, btw.

Since all the levels were now in the game I made a way to select them. As usual I started with something that seemed simple.

Level select screen…populated randomly.

 

To save memory I decided to reuse some of the code I used for building the screen. However, Craig took one look at my graphics and promptly drew some new images. That helped a lot. Combined with new border around the action and his new spiffy font it now looked pretty smart.

Look at those preeeety colours.

 

So, the foundation was there – something to build gameplay on, but at this point you only rolled one tile at the time – and you could roll over anything…even the walls. So I implemented a table of all objects in the game – to be able to tell a solid object from a non-solid object. And I also coded the “automatic-roll” function at this point. Then I made another table that would define the actions of a character if it passed over something – like a teleporter or a joker. More code was needed so tiles were checked before you moved onto them – and once you were actually on them. A good example are the bombs – they’re solid to all characters except one of the same colour, so the program needed to check both before and after a move.

Now, slowly but surely, I began to code all the different actions that could happen during the game. This was the thing I’d feared the most, but I have to say that it all went unexpectedly smooth and with relatively few problems. This can probably be attributed to my very modular and systematic style of code. That is not to say that I didn’t have any problems – I did. Anyone who has coded a game will know that even something that seems simple can end up being very complex and you will always get some sort of unexpected behaviour in a game as you add more and more things to the mix.

I needed a diversion for a bit so I started coding the main menu. I knew I wanted titlelogo at the top, so I just used the logo from Dingo as a placeholder. I also placed a couple of bouncing Speccies on the sides.

First version of the menu had bouncing Speccies on the sides.

 

A couple of days later it was replaced with the first version of the new logo. I wanted to use a rainbow processor to make the logo multicoloured, but decided that I couldn’t spare the room for it – memory was getting too tight for something as wasteful as that. Besides, if it turned out that I had more room to spare at the end of the project I could always implement it then.

Menu, version 2.

 

Okay, so I couldn’t spare the room for a rainbowprocessor, but there was plenty of room for gameplay, and I got back to that – there was still a lot of things to do. By now it was mid-april and I had most things working. There were still a couple of small bugs scattered around…the worst being seemingly randomly appearing tiles – especially when using the teleporters. This was probably the most frustrating time of the development, but eventually I nailed those bugs.

It’s now May 1st and the game was finally beginning to look and play right.

Lots of debug information on the screen to help me.

 

But the more complex something gets the more bugs you get…and I had my share of those, but at least the game was finally beginning to look way it should. I finetuned, and bugfixed, for what seems like forever, but slowly I inched closer to my goal. At this point a Speccie would just sit on it’s destination pad and smile if it was “home”, but it wasn’t clear enough so Craig came up with a grinning animation that I put in too.

On May 23rd the game was basically feature-complete, so I sent a demo to a developer buddy of mine, GreatFlash, and asked what he thought of it so far, and his reply was surprising – he was colourblind so he had problems playing it. Ooh. Now what?

I started looking into something I’d read about – ULAPlus – a new proposed hardware standard for the Spectrum, that would eventually be available as a plugin for the original computer and add some new functions – more colours being just one of them. It’s currently not available as a product though, but a few emulators supports it, so I set out to see if I could figure out how to implement it for people suffering from colour blindness.

…and I could (these are not the final colours, btw).

 

It didn’t take me long to implement, but there was a lot of mails going back and forth to figure out what colours worked best. I prefer the colours in the standard mode – they’re more aesthetic to my eyes, than those in the ULAPlus mode…but those colours aren’t there for my benefit. It’s perfectly playable though…and perhaps some other players also prefer the orange border and the slightly different colours.

At this point I made a “game completed” animation. That was fun. I came up with a pretty juvinile idea and coded it, and it’s a pretty long animation too. I won’t say much…but it gave me a good excuse to use the colour brown (in ULAPlus mode, it’s not in the original Spectrum’s palette).

It was now May 31st and the gameplay itself was basically complete…now it was a matter of working on the presentation and polish. I suggested to Craig the we could use some animated frames to “set the story of the game” at the beginning of the game (like I had in Dingo as well). Memory was getting so tight that we couldn’t make it a thing that ran everytime the game was run, but that 5 KB routine to move the screen was generated automatically when the game was run the first time, so there was basically a 5 KB unused “hole” in the middle of the game when it was loaded the first time. I decided to put the code and graphics for that, there.

I began by looking at the source from Dingo – perhaps I could just take the code for building the frames from there? …but I couldn’t figure out how to make the damn things work, LOL. I had to rewrite it from scratch, but as it usually it – it’s much better, more compact…and much better commented, now. 😉

I used some temporary graphics – from some of Craig’s loading-screens – to test the code.

 

At this point I asked for help with the music on the World of Spectrum forums, and Chris Cowley came to my aid – with not only code for a multichannel tune, but also offering to write it. Lucky, or you would’ve been listening to something akin to tincans being clanged together…if I’d tried to make it myself. 🙂

The timing needed to be very precise for the music to sound good, but unfortunately my two bouncing Speccies on the menu took so much CPU power – which made the music sound terrible – so I had to remove them and think of something else. Remembering the “portraits” on the Dingo menu – that I suggested to Mark – I asked Craig if he could do that too. I made a mockup showing my idea.

A mockup with temporary “portraits”.

 

He thought it was a great idea and made one.  Actually he made two different ones – with different expressions and I put them on the menu. Well, 4 to be precise – one in each corner, but Craig then suggested we could animate their faces. Sure, why not. So he made four different faces and I stored just the one face and the animation strips for their eyes. That worked very well and didn’t affect the music.

Craig really agonized over those animation-panels at the start – “what on Earth should I do?” he said, but I came up with the idea of using simple credits instead. That was also quite fitting as it’s something you only see once anyway, so he went to work and by June 10th the game now had most of what would become the intro.

The intro is placed on top of the loadingscreen once the game has loaded.

 

He also delivered an extra piece of graphic – sort of a portrait. We didn’t really have a use for it, but I thought it was good so I couldn’t let it go to waste…so I put in an extra screen between the credits and the menu.

The fours stars of the game.

 

I wrote some code to fade the screens out to make it seem nicer. I also only stored the image once, but wrote some code to draw it in different colours – that way it would be more “impressive” but not take up too much room.

The game was now complete, but as we’d already decided that we wanted to make – and sell – a very small amount of physical copies on tape we needed to design the artwork, make (some of) the boxes and copy the actual tapes, so we decided to not release the game until after the summer vacation – so we had time to take care of all that. That gave us a couple of months extra.

Three weeks later Monsieur Bobbins mentioned on Twitter that “all games should have a scroller“. Well, he didn’t say it to me, but I saw it and took up the challenge anyway. A couple of days later that was done too.

He was right…every game does need a scroller. 😉

 

The game now sat and did nothing for another two months. During this time I made another game, but that’s another story. 😉

Those months were frustrating though. There was supposed to be some deluxe versions of the game in Ultimate Play the Game style boxes – with custom-made plastic inserts. The plan was to build all the boxes themselves by hand, and I wasn’t going to do that before I had the plastic inlays done – I wouldn’t risk they were too big for the boxes or something, so I postponed making the boxes for a long time. Unfortunately it also took the plastics-guy a long time to get back to me…and when he finally did he told me I couldn’t have them made in the thin plastic that I wanted. Bugger. And by then I’d already spent time and money making the forms for the vaccuforming machine. Delays, delays and…delays.

We finally decided to canibalize some existing games for their plastic inlays – it was only 5 after all, so I went to work making the boxes and shipped them over to Craig in Scotland, where he would take care recording the tapes and putting the artwork on. We decided that – to keep P&P down – that it was better to do the shipping from Scotland instead of Denmark since most of the games probably would be sold to the UK anyway.

Homemade boxes. The top one was the first…that wasn’t so good.

 

Chris had sent me a longer titletune for the menu, so I implemented that at the last minute, and sent it to Craig for duplication. I also sent a copy of the game to my mate Russ so he could try it. Craig had already recorded all the tapes when Russ came back to me and said “The game crashes“. Oh no. And it was bad – it happened every time a game ended. So we thought “Sod it!” and went back to the original version of the game with the shorter tune. Craig began recording the cassettetapes again…but the problem was still there. Strange, I have NO idea when that bug was introduced. But I fixed it. And another one that I found too.

So Craig starting recording the tapes for the third time (well, he didn’t get to redo all of them the second time – but some were recorded three times). Meanwhile all the artwork had been finished and sent to the printers…but some of it was lost in the mail and it was another week before Craig ordered a second batch. That made it to him at least.

We decided to finally release the game on September 16th 2013. One good thing that came from all these delays, though, was that because the game had been finished for almost 3 months I’d been able to send a copy to Retro Gamer Magazine and they actually reviewed the game and scored it 85% in issue 120 which came out just a few days earlier. Awesome. 🙂

Finally the game was out. Released as a free download as well as being available in 3 different sizes of physical copies.

…oh, and there’s a poster too. 🙂

 

…and that is the story of The Speccies – how it was developed, what led to what, and why it looks the way it did.

I hope you like it.