Mutant Amoeba Development a peek behind the scenes at the MAD lair


IceBreaker – PostMortem | Ludum Dare

Posted by pentaphobe


IceBreaker is a minimalist free-pause RTS-ish thing (probably better described as an FTL-like, though bearing little similarity) set in a Cyberspace similar to the one portrayed in William Gibson's Neuromancer (a book which changed my adolescent life and is at least partially responsible for my getting into programming). I didn't get much (okay, any) journal-writing done during the weekend, though there's a vague run-down of events in the project's github page. So consider this (rather large) postmortem post-hoc overcompensation. (and apologies in advance for the spam)  

Blender was extremely helpful for rapidly producing the future-retro look very quickly, even the sprites were tiny renderings with wireframes

  You can't quite tell, but it's a stripped-down RTS:
  • no resources or buildings (instead you have gestation periods for replication)
  • since you can't build unit factories, you instead have to replicate (and be vulnerable), but if you're standing still you will heal
  • there /are/ classes, but they are restricted to *strength* (hit amount) and *vitality* (health)
  • it's meant to be broken down into very short levels, generally with you collecting/destroying something which is being protected.


  • Four litres of coffee consumed
  • A whole forest of tobacco
  • 3,617 lines of code
    • That's 60 A4 pages if printed out
    • According to Wolfram Alpha that's:
      • about 17.8 metres ( 58 ft ) tall
      • 6.6 storeys high
      • and about half the diameter of the Hindenberg
    • Very sore wrists (hush, you!)
  • somewhere between 3 and 6 hours of sleep


What went wrong

  1. strong underlying system
    • unlike my last two LudumDare attempts, I knew what I wanted to do very quickly, I wrote about three pages of ideas and then stopped when I realised I'd already made my mind up to do the first one. However I didn't flesh out the details as much as usual and so started building the basic framework while pondering, knowing I could change the details later on. This resulted in a lot of code ( ~60ft worth! ) that, whilst extremely useful was probably not necessary to get the basics of the game done. I remain convinced that it was doable within the alotted time period (the post compo version is only an extra 4 hours work, with the last 3 mostly being unnecesary tweaking)
  2. not enough testing of environment
    • I did more preparation than previously, but I wasted time on a few things which could have been sorted out before the compo:
      • setting up the live stream stole about 1-2 hours, admittedly I was feeling a bit braindead/overwhelmed/uninspired so this was a better utilisation of time than say, nothing. But this should have "Just Worked"
      • Final builds (I'll get to that)
  3. using an unfamiliar framework and language (again)
    • In my first LD, I used AS3/FlashPunk which I'd picked up a couple of hours before the compo. In the second, I used Java/LibGDX and didn't complete - whilst I had familiarity with Java I was very very new to LibGDX and as a result spent wayy too much time googling. This time was a fair bit better (Haxe is quite similar to Java/AS3) but I still had little to now experience with either it, or HaxePunk
    • HaxePunk is quite nice, but unfortunately not quite "there" yet for me, I wrote a disproportionately large amount of patches to the library in order to get basic features to work normally. This stole quite a bit of time, but it was far too late in the project to change ships. I look forward to using it more though.
  4. refactoring at the halfway point
    • despite having most of the system quite well designed in my head, I had to stop and write a vast swathe of code on day 2, partially to undo the odd choices of my sleep-deprived self the night before
  5. sleep (braindead 6+6 hours)
    • I should have done it sooner, and more. I'm quite good without sleep, but I ran rampant on the code-base when I started getting exhausted. Much time was spent rectifying this spaghetti. I'm not sure how long I actually slept (somewhere between 4 and 6 hours), but I easily lost 12 hours to silly choices and then the bleary-headedness upon waking.

      an early screenshot complete with pointless UI and ugly tiles

  6. didn't demonstrate theme clearly enough (despite following it)
    • I had basic gameplay down very early in the project this time, but the sleep-spaghetti resulted in about 10-12 hours of programming which left me (effectively) where I started
  7. planning
    • I actually planned quite well in a lot of ways, but some very fundamental (and rudimentary) aspects were overlooked initially, resulting in much confusion and wasted time
  8. submission process panic!
    • I tested my environment this time to avoid this exact thing. However I discovered (at submission time) that whilst my project ran perfectly in the Flash standalone player, it would silently fail completely in-browser. It turns out all I had to do was add "-web" to the build command, but it took me far too long to discover this!
  9. no end-game detection or automatic level progression
    • despite "shipping" with a few levels, the submission process issues resulted in my missing the 20 minutes that I needed to finalise this important factor of a "short-level based game" and the gameplay suffers for it.

What went right

  1. strong underlying system
    1. Yes, it's a dirty trick having this in both sections. But I maintain that the approach was a good one, early efforts resulted in the tutorial system being a mere 45 minutes to implement, and most new features were added extremely quickly
    2. I used JSON for most of the configuration of the game, allowing rapid prototyping of enemy AI, character attributes, menus and the tutorial system)
  2. using Haxe and SublimeText 2
    1. This was a pretty awesome combination, I look forward to being able to justify the $70 license for SublimeText2 (this was my first real experience with it, and it was wonderful). I have been using (shudder) Eclipse for a while despite my lack of appreciation for IDEs in general so it was nice to have a "real" development environment again. However I've gotten rather dependent on Eclipse's easy mass-refactoring, and you can really tell (names of things changed through the course of the project and thus there are some things named Agents which are actually Actors and so forth)
  3. the game idea
    1. I think this concept is pretty sound, and I enjoyed playtesting it. Definitely building some more levels and a little more "Juice" and thrusting it in the face of anyone who walks by
  4. music and art
    1. There were a few times when my brain completely went on strike, so it was good to change gears and work in Blender or Renoise to build some of the feel, having these elements in game was also fantastic for morale.
    2. The music was made in about 5-15 minutes for each of the two tracks
    3. Art was quite quick too, despite a few false starts
  5. tutorial system
    1. I'm really happy with the tutorial system, which could also double as a mission introduction system. It hooks into game events and each dialog of the tutorial can have a number of events required before it appears, or disappears making it very easy to make a clear (and importantly, responsive) tutorial.

The in-game tutorial system is quite smart, if a little overenthusiastic

Last words

Thanks to everyone for an awesome experience yet again! Project source (github) | Project page | Live stream (twitch) I strongly encourage you to

Play the Jam/Post-compo version Here!

  after you've rated, as it'll be a lot more clear what I was trying to achieve  

LD#25 You Are The Villain

Posted by pentaphobe

I'm still brainstorming 2.5hrs after the theme announcement. This is a tough one!

I have a nine page bullet list of ideas, but choosing is a little harder than it was last time because:

  • My favourite ideas are likely the favourites of many other people
  • My least favourite ideas mostly fall under the following categories:
    • nice concept, but where's the game?
    • how does that differ from the hero version?
    • nice game, but where's the concept

Normally at this point I'd start work on coding up the basic framework and getting the generic skeleton going, but since I'm not sure which game I'm going with I still don't know whether AS3/FlashPunk or Java/LibGDX are going to be more appropriate.

I'm leaning toward FlashPunk again simply because more is covered by the library, but that would instantly limit my chances of doing anything simulation-based as the VM (as far as I know) is not as well suited. Distribution is significantly easier though.

Another caveat if I choose Java/LibGDX is that less people will play the game unless it's embeddable in the browser - outside of Processing I've never attempted this, which could either be deceptively simple or a waste of a few good hours.

More coffee, and standing in the sun before I choose.

I give myself one hour to choose, and a further hour to get whichever dev environment I go for setup and ready to go. If the setup is not yet done by that point I shall switch to a simpler environment.


Sid Meier Keynote and my thoughts on game odds.

Posted by pentaphobe

Interesting talk from Sid Meier - I'm still watching, but this is a note for later.

At around 20 mins in, Sid introduces a conundrum regarding player combat and the discrepancy in player perception of odds.

The example given is of the player accepting that they may occasionally lose a 2:1 battle (approximately 1 in every 3 games) - but has difficulty reconciling the idea that they lost a 20:10 game "I have 10 more!"

Sid points out that this their assumption mathematically unsound and continues to speculate on the psychology of gamers (while the audience chuckle derisively in the background).

This scenario makes perfect sense to me, however.  I understand the basic mathematics of 20:10 == 2:1 (obviously).  However I propose that the two may not be that similar, especially in terms of combat (and other somewhat complex, or emergent) systems.  Instead it should be looked at in terms of combinatorics, possibly considering the average individual's combat capacity, rather than the sum.

See, the reason the player has difficulty with this is that every single player they have in advantage, should also have a (randomish) high chance of fighting well above their capacity.  Ie. just as the disadvantaged player in a 2:1 battle has a chance of winning, every additional unit on the field in a match of equal ratio should have a chance of beating at least 2 (or more) opponents.

What seems logical for a player is the idea that in (say) a 20:10 match, they should be able to be down to their last player with their opponent absolutely slaughtering them, for example 1:9 and there will still be a chance - albeit a small one - of pulling out a victory.  Perhaps the remaining opponents have already been weakened by other (now dead) allies?  Perhaps the survivor has learnt a few things watching their mates getting killed?  There are any number of justifiable (though mathematically 'illogical') reasons to assume this is okay.

I feel this is because rudimentary statistics like those used on horse races are inherently unsatisfactory for modelling higher-level processes like fighting, survival, etc.

So what?

I'm going to give this a little more thought, as it could easily be modeled with an iterative function:

function calculateTeamOddsScalar( teamObject, teamAverageStrength, opponentAverageStrength ) {
   var total = 1;
   for (var i=0; i<teamObject.totalUnits; i++) {
      // results of a simplified combat, > 0 for our winning amount, < 0 for our losing amount
      var diff = random(teamAverageStrength) - random(opponentAverageStrength);
      total += diff;
   return total;

I would, however like to find a more elegant mathematical solution.

No really, so what?

The numbers will more accurately reflect the type of odds we expect in real life, rather than the pure mathematical approach.  We're constantly skirting the odds and statistics are useful for certain types of analysis - however they are limited by their simplicity in common game engines.

Remember that odds make sense generally over very large sample sets, not necessarily on a short time scale.  The fact that I have a higher chance of dieing in a car-crash than an aeroplane crash doesn't in any way reduce my chances of being in an aeroplane crash.  These statistics are only useful when looking at humanity as a whole.  And really only good for proving inane points, or seeming like a smartass.


I'm clever and this is a good idea so poo poo to you you.

Or I'm potentially a complete moron stating the entirely obvious.

I'd give you the odds that each of those statements are true,

but they'd be meaningless.

GDC 2010: Sid Meier Keynote - "Everything You Know is Wrong" - YouTube


Tiles as offset lookups into an arbitrary texture

Posted by pentaphobe


This one's been on my mind for a while now, but after seeing its effective use in Dynamite Jack and Prison Architect it's a go-ahead.

note the ground tiles and how they're not constrained to wall size. This could be achieved with multiple wall-sized tiles, but why bother?

The gist is that instead of using a specific image for each grid point in a map, you instead do a wrapped lookup into that texture so that it can be larger (or smaller) than the grid size itself.  Fairly basic stuff.  Just imagine a texture repeated across the screen and then masked so it only shows on tiles that match. (that's not how you'd implement it, but seems like a clearer image)

However there's an implementation detail which I find interesting: originally I was just going to allow images whose dimensions were a multiple of the tile size, this is easy to code and makes wrapping trivial when using a sprite sheet.  We can also render the tile map by having a fixed grid of points already attached in the graphics card and then simply going through and dynamically changing the UVs for each point whenever the map moves by a whole tile or more.

Dynamite Jack

Again note the ground tiles aren't constrained to wall size. Also note that I'm quietly ignoring how similar our games look. Maybe I shouldn't add that flashlight after all? :)

An nice alternative which would definitely help "break up the grid" is allowing completely arbitrary texture sizes, which would be just as easy to implement if we used a separate texture for every tile, but texture changes are horrendously (and notoriously) slow so that's not an option.  However, using sprite sheets means we can't rely on the hardware to automatically wrap tile images (as it'd simply show adjacent images from within the sheet rather than wrapping at the tile boundary).

The only solution which leaps out at me is to implement the whole tile rendering side of things in a GLSL shader so that we can manually wrap texture coordinates at the appropriate tile boundaries.

Seems simple enough, and it'll mean I finally need to learn how to send arrays to a shader from Java..  Something about IntBuffer objects which seem simple enough but are a little odd.  Not sure why it can't just be a reference to a flat array like in C..

Ho hum!

Hands On: Prison Architect | Rock, Paper, Shotgun.


Grappling with logic systems…

Posted by pentaphobe

So I haven't updated in quite a while due to a conglomeration of factors:

  1. I was away for a bit
  2. The Lady is on holiday and deserves more than watching me code
  3. My brain broke (apparently it felt it deserved more than watching me code too)
  4. I got into a beautiful quagmire of how best to generically represent logic in game systems.

I'm going to talk about item 4 here, though the third may get a mention as it's related.
-- page break --

Logic Systems

For the last couple of years, Entity System design has been the fertile topic of many keynotes, articles and assorted head-scratchings.  In particular, Component Entity Systems are, as they say, "all the rage."

A Quick Review

I personally love the component model, I'd been toying with similar systems for a while but never quite got it down to the logical simplicity that others later did - instead always trying a new implementation each time (iterating) in the hopes of finding a good tradeoff between "elegant" and "efficient" (sometimes these are one and the same, but so far they're at the opposite ends of the scale when it comes to entity systems).

Since these topics have been covered elsewhere (extensively), I'll simply summarise the two main popular approaches to entities:


Katamari of Data
The entity contains all possible interfaces (and common data) for any type of object in the game world, different object types are then sub-classed from this base entity. The main caveat with this model is that data and interfaces specific to certain subclasses often end up needing to be moved to the base class and you also end up with code duplication. (See other articles for a more in-depth description of this)
Component System
In its purest form, the component system works by having Entity objects be simply a unique ID.

Data and behaviour are both stored in Component objects which implement a specific, isolated functionality and contain appropriate data and the associated Entity ID.

Components are in turn stored by their respective Component System objects (one per type of component) which do the actual processing.

Again, I haven't covered this in much detail, but that's the gist. There's also a variation on Component Systems which further breaks components into either Attributes or Behaviours - though this is a little of a strange beast.

It's also the main subject of my brain cycles over the last week.

So many questions..

  1. Attributes are data which needs to be accessed by more than one behaviour, but also has event handling and update functions.  Are there any significant differences in interface between these and behaviours?
  2. Should Attributes be objects which abstract data access, just the data itself, or should the data actually be stored in the associated AttributeSystem?
  3. Behaviours are easy to grok, as they're quite literally the same thing as the classic Component model - however, is there a good reason to rethink this?
  4. Which things should be handled by the system, and which should be handled by methods within the respective Behaviour/Attribute object?
  5. How best to include commonly used interfaces without also tying the code to a particular platform?
    ie. we don't want to use the event system for render() or update() calls as that's a large quantity of pointless cycle waste.  But if I define a render interface then surely it must include information about the current graphics context?  (The actual code can be adapted, but the method prototype will still contain a specific object type)
    nb: probably the best way to handle it would be to only have the render component's system know about the graphic context and provide necessary calls to its child behaviours. 
  6. Which things should I abstract completely, and which should be optimised into either the Entity class or Component classes?
  7. How can I minimise memory usage and call overhead?
    eg. do Components hold a reference to their owner System _and_ owner Entity? (memory)
    do Component interfaces take a reference to their owner System? (one extra variable per call)
    do Components actually contain a static reference to their owner System? (kind of strange, hierarchically. mostly works, but when our game object wants to update all systems, how does it know where to find them? nb: could quite easily leave the static uninitialised and have the ComponentSystemManager initialise them upon registration)

And that's really just the surface of the thing.
Those are mostly quite easily resolved (I've done it dozens of times) it's more a matter of finding that nice balance, which I'm struggling with presently.

The real thing

The main thing I've been doing is attempting to reduce ALL possible behaviours of a game engine into a simple system which can produce broad varieties of behaviour with little to no modification.  Ideally most games should be buildable with nothing more than a definition file and some assets.

Plenty of people have addressed this sort of thing, particularly in production of "GameMaker" type programs - but I've always found them a little convoluted, much like my previous attempts.  In both cases you can tell there's some great engineering at the foundation, but iterations have slowly added complexity more broadly than is ideal - often resulting in pointless amounts of boilerplate definitions and then eventually powerful embedded scripting all of which kind of defeats the purpose of having a simple engine in the first place (often it'd be easier to program in the host language rather than build complex functionality out of a slow embedded scripting language)

So I'm aiming for an extremely high-level model which effectively creates a pluggable development environment much like Stencyl or PureData.

The main difference being that implementations like Stencyl allow you to plug in predefined components, or write code using predefined pluggable blocks of code (effectively just removing the typing from normal scripting) - whereas I'm designing a system where it's less about plugging prefabs together and more just about defining the fundamental logical flow of information through a game system.

In other words this is a designer-oriented system, rather than a make-it-easier-for-designers-to-write-code system.



Long post is long.

More on this as it progresses.