• About
  • Gallery of Images
  • Archives
  • Categories
  • Archive for January, 2013


    2013 - 01.31

    As you can tell from my last post, I’ve entered OneGameAMonth, an indie gamejam which probably needs no explanation as to its purpose. I’d highly recommend any indie dev have a look at it, the website is pretty fantastic, gamified in quite an awesome way. At the time of writing, after a month of development, there are currently 784 games uploaded there – which I think is a hell of an amazing achievement. So many ideas and games in one place. It is pretty exciting to say the least.

    I really do like the idea of producing a game a month. I ( like a lot of developers ) tend to get caught up with massive grandiose dreams which very often seem to escape our reach. Having a regular deadline in which you know you must release something I think is incredibly motivating – a month being an ample amount of time to produce a simple game and add polish.

    My first game is up there and you can check my profile out here. Already started jotting down notes for February’s game. Feel free to leave some feedback there if you like ( or hate ) what I’m doing. I’m always up for attention 🙂

    Many thanks to @mcfunkypants and @LZAntal for setting this up, and I am really excited at what will come from it 🙂


    The Tombs of Tutankhamen

    2013 - 01.30

    Introducing …. The Tombs of Tutankhamen


    This, as mentioned in my earlier post, is a remake of an old BBC Microcomputer game I spent far to long as a child playing. I’ve kept as loyal to the original as possible, but brought the movement, controls and scrolling up to what is the ‘norm’ these days. I’ve also added touch screen controls to it, so it is playable on mobile devices. Mobiles controls are not as nice as I want, but I want to re-visit them later and use on-screen buttons.

    It’s powered by the awesome HTML5 – using the very cool impact.js framework. Really enjoyed working with impact, but I’ll talk about that another day. I must admit, I was rather shocked at the speed of the main game loop when dealing with the canvas. Seems browsers are starting to get quite good at this graphical nonsense 🙂 Anyway, without further ado :

    How to Play The Tombs of Tutankhamen

    Story :
    You are Doctor Procman, who has found yourself trapped in the Tombs of Tutankhamen. After deciphering hieroglyphics over an ancient and dusty altar you discover the only way to escape is to collect the 16 crowns and find the exit. Unfortunately, five colour coded doors stand in your way. You must find the keys inside scattered around the tomb to unlock additional areas. To add to the stress, there are boulder traps which will stop you from turning around. Oh and did I mention there are huge giant green spiders that will kill you if you get too close? Yeah, thats right, giant green spiders.

    Controls :
    Arrow keys to move
    R to commit suicide ( in case you get stuck, or just bored with life )
    Mouse click to mute music and change volume

    Notes :
    This game is pretty hard. You won’t complete it on your first game, you will need to learn the rooms. The one-way traps in the original are all present in this version and boy do they hurt 🙂 ‘R’ is your friend there. The spiders move at different speeds, you will need to judge your runs very carefully. There are two easter eggs in the game, one of which may come back to haunt me 🙂 The map itself is made of 16 rooms, you may need to scribble down some routes on a bit of paper. Five coloured keys exist and when you pick them up, the matching door will vanish. You can gain access to the last door fairly simply, but it will not open until you have all 16 crowns.

    The game can be found here : http://www.greenslimegames.com/games/html5/tut/. You will need a modern browser to play it. If you find any bugs feel free to let me know! This is my entry to OneGameAMonth which I shall be talking about tomorrow 🙂 Oh, and my profile there is : http://www.onegameamonth.com/BeeBug_Nic feel free to leave some fan mail <3


    BBC Basic – Storing a level

    2013 - 01.27

    My first computer was a BBC Model B micro-computer.


    Sexy looking thing isn’t it? The baby had 32K of memory, could support 8 colours ( slightly more with various tricks ) and came installed with BBC Basic, my first programming language. In the dreamy days of the 1980s there were a lot of computer magazines – most of which featured source code listings of programs you could type in into your home computer and play with. This was very cool – however, the drawback was a lot of these programs where quite long – and typing them into the computer had all sorts of issues ( no copy and paste for one thing ). So, my Dad, upon seeing a program that he really wanted to type in decided to stick me in front of the computer and get me typing it out for him. I remember him telling Mum that it will teach me how to use a keyboard, which will be a valuable life lesson. How right he was. Personally, however, I think he was just being lazy 😉

    I became fascinated with typing in the programs I found in magazines and how by changing the code I could change the program ( and more often than not break it completely ). This of course started my life long love of coding. Recently, I’ve decided to learn HTML5, a far cry from BBC Basic, but I was feeling nostalgic and decided my first HTML5 game would actually be a remake of the first game I ever played – The Tomb of Tutankhamen. I remember spending many hours with my brother and sister playing this game. As an explorer you had to collect crowns, avoid spiders and escape a 16 room pyramid. Thanks to the wonders of the internet, I managed to find a copy of a magazine which contained the full source code of the game. The magazine was called Beebug ( might see a connection with my twitter name there 😉 ) and was a long running magazine aimed at people with BBC Microcomputers.

    So I sat down one snowy night and decided to try and extract the level data from the source code. After much consulting of very old manuals I managed to decode the game, and lots of it really, really impressed me. Without such structured programming as we have today and with such a small amount of memory, so many neat tricks and techniques were used. The one that I thought was uber cool was how the level data was saved.

    The game has 16 rooms, the code for one the rooms look like this :

    2850 DATA 2,2,2,2,2,6,0,16
    2860 DATA FF09ED21BD01FF01F5C511DD

    The first number, believe it or not, was the line number 🙂 DATA is the command to indicate that you are storing, well, data. Now the first numbers represent things like the colour used to draw the screen, where the enemy was on the screen, things like that. The actual structure of the level was stored in the long hex string.

    By looping through the hex string two at a time, you get the following :


    How does that help us? Well, what if we converted these hex values to decimals ?


    Hmmmmm, still doesn’t look like a level to me – lets try converting it into binary and pad out all strings with 0 where they are not 8 long


    Looks like a bunch of 1’s and 0’s. Here is a screenshot of a page I used as a programming jotter, to check my theory :


    We have a level! 🙂 now, piecing together all these DATA strings gives you a view of the entire map :


    Now, I have no idea why the levels were encoded like this. Maybe it was to protect the level data, maybe it was to save space or memory, maybe it was to stop children from making mistakes typing in long lines of 1s and 0s when they had been sat infront of a computer by their father. But either way, I thought this was a very nifty and cool way of solving the problem of level storage 🙂