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


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.


Old habits and managing complexity.

Posted by pentaphobe

Often when a project gets beyond a certain level of complexity I'll end up prototyping features in a new project instead of adding to the existing one just to avoid scrambling around fixing or un-breaking things.

This is really good in a lot of cases, as it reduces the fallout from getting carried away adding new stuff  and potentially breaching certain contracts of neatness that you've been fulfilling up until then.  Occasionally though, I have my doubts.