Holiday Direction

The updates have been fairly sparse recently, but as Christmas (or equivalent) approaches everyone gets pretty busy. Fortunately, a few of the things I’ve been very busy with are Piemaster-related: I’m breaking some new ground with Forgbook and Buffex, and exploring a couple of other potential projects on the side.

Forgbook has received a lot of competition lately, as numerous development teams small and large have release highly polished task management applications, such as and Orchestra. Many of these have a strong emphasis placed on collaboration across tasks, but still none offer the ability to arbitrarily break down tasks into subtasks. This seems like a pretty fundamental thing to want to be able to do, and is of course the cornerstone of Forgbook.

However all of these applications do offer very slick user interfaces, and to at least be competitive, I’ve realised that Forgbook requires a modern makeover. As such, I’ve finally taken on learning some JavaScript properly, because against my wishes it has undoubtedly become the modern web’s lingua franca. I’ve been mocking up a few single-page AJAX applications with the very handy Backbone.js library, which drastically simplifies (or at least provides structure to) the MVC design of the user interface. It’s quite reminiscent of my time with Adobe Flex, minus the constant annoyances of Flash, and I’m hoping to write a bit about it once I’m a little more comfortable.

On that note, I’ve been approaching Buffex from a more modern perspective as well. I noticed I haven’t mentioned Buffex in a post before, and indeed the project page has been a rather misleading “Coming soon.” for the past year or so, but you’ll hear a lot more about it soon. Since the minimum viable product (MVP) incarnation of Buffex is relatively simple, I’ve decided to focus my efforts on that for the time being before pressing on with Forgbook (which is looking much slicker than it used to, but has a lot of work to go). I’ll be taking a Backbone approach to Buffex too, to try and have nice, snappy interface and keep everything nice and simple.

That’s more or less where my head is at the moment. Those couple of other ideas I mentioned will get some more attention next year, but I can say that one of them has been born out of my recent fascination with gardening. If there are any gardeners out there, let me know! I’m trying to bring a rather unorthodox approach to it, and would love to discuss it with others. Techies tend not to be very enthusiastic garderners however, which is both a good thing and a bad thing in some sense. Regardless, I know I’m looking forward to it.

Jario Update: Sounds and Semi-Passability!

Yes, thank you Chrome, only one of those is a word, and yet Jario now has both! Sounds were ridiculously easy to add through a generic SoundSystem with a handful of static sounds (courtesy of and a static queue-push method, and then the single-line calls were peppered throughout the systems as required. The result is a game which is a lot more fun to play! Despite still being about 60 seconds long.

Go ahead, try it out!   Launch Java Web Start button

The issue of passability is a more technical one. Previously, all detected collisions were handled directly by each of the colliding entities. This is great for many cases, but there are some times when you don’t want to handle a collision, or when you want to not handle it under certain conditions, and for which adding in a bunch of conditional guards is ugly and inefficient.

My solution was to sneak an extra layer into my collision handling hierarchy (which I’ll talk more about when it’s a little more polished), right up the top, to manage collision persistence. In this context, persistence means that when two entities collide, all future collisions that are detected until they stop colliding can be grouped into a single collision, and handled only once at the beginning. This is important for a number of gameplay mechanics.

For example, the two cases I added just now were semi-passable platforms and improved handling of player recovery. Semi-passable platforms are those ones that you can jump through from below, as well as stand on top of. One way to get this behaviour is to say “if the collision is not from the top edge, do nothing, otherwise block the entity”. This may work, depending on your collision detection mechanism, but for the time being mine is very basic, and detects the edge of the collision based on the X and Y distance the two entities are overlapping by. The result is that if you jump through from the bottom, a bunch of collisions will occur for the handful of frames you’re passing through, and as you are about to exit from the top, one of those collisions will be detected as “top edge”, and the default behaviour is to place the player on top of the platform. The behaviour we want is for the player to keep jumping, eventually fall back down, and then be placed on the platform.

My solution is a little more complex than perhaps it needs to be, but it’s a good starting point. When a collision occurs, the handling systems can register the collision as a “passing through” case, after which future collisions will not be handled by the entity that is passing through (the ‘passer’) until the entities separate. However, the entity being passed through (the ‘passable’) will continue to receive handling calls in case the circumstances of its passability change. It can therefore also check whether the colliding entity has been previously registered as a passer. All of this handling is contained in PersistentEntityHandlingSystem class, which all current collision handlers extend.

In the case of the platforms, this is straightforward. On the first collision, if the player collides with a non-top edge of the platform, the platform registers the player as a passer, and the player continues unhindered. Once the player exits at the top, they are unregistered from the platform, and the next collision will be handled appropriately on the top edge.

Player recovery is a little trickier. By “recovery” I mean the period of invulnerability you get after being damaged with >1 health. During this time, you shouldn’t be able to stomp enemies from inside (i.e. walk into them from the left, then jump and kill them on the way out). So for this case, when the player collides with an enemy, he first checks whether he’s in recovery mode, and if so, if the enemy is not already registered as passing through, then the registration occurs. The enemy passing through the player means that the enemy is oblivious to the collisions (and so can’t die until the player leaves and comes back), but the player’s handler is still called each frame. Therefore when the test for recovery fails (i.e. recovery time has expired), then the enemy is unregistered as a passer, and the collision can be handled normally.

But wait, there’s more. It’s possible for recovery to expire while the player is standing right in the middle of the enemy, and if the position is right, it will register as a top-edge collision, and “handling normally” means the enemy will get stomped. This is not the desired behaviour – if the the player is standing inside the enemy when recovery expires, the player should get stomped instead. To work around this, I added a parallel map that records which passable-passer relationships should be unregistered in the next frame. This gives the player collision handler a chance to handle the collision manually and correctly (take damage) before unregistering. If the player manually takes damage AND unregisters in that frame, by the time the enemy handles the collision it will appear unregistered, and the potential top-edge problem persists. By delaying it one frame, the player’s damage will have been fully accounted for, and the enemy collision will not occur at all.

Problem solved! You can see all that in PlayerHandlingSystem if you like. Like I said, it’s quite complex and I’d like to simplify it a bit, but it’s a start. By experimenting with this approach, I’ve gained even more of an appreciation of the Artemis framework. You really can tackle your problems one at a time, in isolation. Even in the case of a two-entity collision, the collision handling of the two entities can be neatly decoupled. The future is looking bright!

Jario Update: Kinda Working!

I’ve just pushed an update to Jario with some pretty nice changes since I last mentioned it. As usual, you can check out the source if you’re interested or just Launch Java Web Start button!

I’ll be quick:


  • All the important items – coins, mushrooms, fire flowers and stars.
  • Goombas, Koopas and even empt shells, with the ‘proper’ graphics and animations.
  • Vastly improved input and collision handling.
  • Added a marginally more satisfying ending, though it still doesn’t do anything.
  • Fixed many, many bugs (but not the intermittent collision mesh one yet).


  • Cleaned up collision handling systems into a hierarchy of similar handlers for increasingly concrete entity types. I’ve found it to be very flexible and reusable so far, which is nice, since the logic of a game is little more than input and collisions.
  • Refactored image and animation spatials into a hierarchy of intermediate abstract classes, and added a SpatialComposer to group the different spatials of individual entity types and handle different states.
  • Inserted a hierarchy layer for spatial effect handling. Currently only processes changes in rendering alpha value, but does so quite nicely.
  • Played around with a TimerSystem to be used in conjunction with a Timer component, allowing systems to easily register callbacks with individual entities to be executed after a given delay. Makes it very easy to add temporary properties to entities. For instance, giving the player X seconds of invulnerability (hurt with >1 health, or press I) reduces to a single static function call. Still need to play with Artemis’ DelayedEntityProcessingSystem to see if that does a similar thing.

That’s all the significant bits so far. Still plenty more to go, though! Some of the above will need to change in order to support a complete level, which will be interesting. I also need some better game state transitions, though that’s nothing to do with Artemis. I’ll talk a little bit about some of the more interesting points soon, such as the collision handling and spatials, since those two are key to getting a game working smoothly.

Forgbook Progress Report

As you can see, there has not been any Forgbook updates for quite some time (a month), despite my resolve to post some. This is for a few reasons, some more interesting than others.

The least interesting is that I’m back at university, which doesn’t leave me quite as much time to work on things, though I’ve been giving what time I can.

More interestingly, I’ve recently stumbled across Pinax, a very smart extension of the Django application framework that offers a bunch of links to reusable Django applications, allowing the user to create the generic skeleton of a web site in a single line, along the lines of pinax-admin setup_project mysite. This provides you with a standard project layout and a collection of full-featured applications for basic capabilities such as user account management, notifications and wikis. Succinctly enough, “Pinax takes care of the things that many sites have in common so you can focus on what makes your site different”.

So I’ve been working on developing a reusable application for activity management within the Pinax environment, and have actually made considerable progress. It’s currently in a usable state where activities can be created, edited, viewed, deleted, completed (various amounts), paused, cancelled, and scored, and these operations propagate through the activity hierarchy. Relatively more advanced features such as categories, tagging, friendships, messaging, commenting, and email notifications are not implemented, but the beautiful thing is that reusable Pinax apps for these tasks exist already, and it should just be a matter of plugging them in with a little configuration. More Forgbook-specific features such as privileges and JavaScript-driven views will take a bit of work, but really Forgbook can function quite happily without them.

Having made that progress, I turned to investigating where such an application could be deployed and hosted so I could start testing it as a legitimate user. The traditional option is just to host all the files on a regular Web server, and connect the Python framework via WSGI. This is not going to be compatible with my current host NearlyFreeSpeech however, because of the rather idiosyncratic nature of their shared hosting setup. Furthermore, a basic Pinax project by itself typically sits in a virtual environment and weighs in at about 50MB, making it unwieldy to just copy, paste and host.

There are a few other options, but I was attracted to Google App Engine, because it’s Google (<3), and it’s pretty much free until the application gets particularly popular. The trouble is that the database used at the backend is a non-relational database, which is a new-fangled way of saying it’s not compatible with every other database. As such, Django is very difficult to support, and Pinax is even more divergent. There are few attempts at workarounds (django-nonrel seemingly the most promising), but it’s otherwise developer hell even attempting to monkey-patch the systems together.

Those remaining options then are a little more pricey but seem as though they will take most of the pain out of Django hosting. There are a few start-ups (Gondor, and Djangy, all in private beta) specialising in Django hosting which I’m keeping an eye on, as well as a few hosts that are friendly to Django, such as WebFaction (detailed as supporting Pinax too).

Currently the plan is to wait until a couple more of these are available (hopefully sneak into a beta or two) and see what cheap options can be had. In the meantime, development will continue, though maybe not as rapidly with uni in full swing. There are few other interesting activities and possibilities in the air as well, but I’ll discuss those a little later.

In summary, Forgbook is alive and well and even usable, but can’t really come out and show off until it finds a home. Hopefully that won’t be too far away.

Where Is Forgbook Going?

Of my large (and still growing) handful of projects that I’d like to be working on right now, Forgbook is taking up most of my attention. Hopefully I can get some kind of super-early release out in a few weeks, but until then it’s worth noting a few shifts in focus and philosophy.

As much as I love the Web, I find it hard to submerge myself in Web development due to the chronic pains of browser incompatibility, and perhaps the need to be constantly responding to user experience. Once a product is released, I feel an obligation to keep it updated, which can at times conflict with a desire to put a project to the side for a while. It’s much safer in term of user response to work on a project privately until it’s complete and polished before releasing it rather than releasing pre-alpha kind of work and iterating consistently all the way through to a final release. I guess I value my flexibility pretty highly, because after all this work is effectively my free time.

Forgbook is (or will be) my largest, most ambitious project in functionality terms, and I believe it will be of the most value to myself and others, so I want to get it right. I’ve been thinking about what I want it to offer for some time now, and I’ll be updating the project page with more details as I solidify them. From a technology perspective however, the interesting decision I’ve made is that I’ll be switching from a relatively unambitious attempt to combine Flex and PHP to a Web-native Django application leveraging the Dojo JavaScript toolkit for the more flashy UI components. This means however that I have to familiarise myself with the environment Django offers; it’s immediately clear that it’s extremely powerful and scalable, but the decoupling that is its strength results in a variety of idiosyncratic idioms that will take some time to adjust to.

Why the switch? One of the requirements I’ve come to be very passionate about is making Forgbook accessible from any common device – PC, smartphone, tablet, perhaps even consoles – so that it feels more like an encouraging companion rather than a chore you must log into every day. This is best achieved using a native Web interface (HTML, CSS, JS) over something requiring a plugin (Flash, Silverlight), as it should at least be accessible by any device with a Web browser, in the scenario that I don’t/can’t customise an interface for that device. It would be suicide to jump into creating a sophisticated Web application without a framework, and my love for Python (and mere tolerance of PHP) combined with the popularity and support for Django make it a perfect choice. The integration of Dojo via Dojango is a big bonus too.

I’ll document the progress I’m making with Django in the next couple of weeks, and hopefully get a stripped-down-but-working version (basic user and task management) out in the wild before March. From there, I’m hoping the development efforts will feel more rewarding, and I’m sure there will be many more fun things to handle (feedback and reflection followed later by advertising and analytics). I’m looking forward to it as much as ever.

P.S. If anyone can think of a quality name for a sophisticated event/task management application (Forgbook is very much a working title), let me know (comment or contact). If I like it enough that I decide to use it, I’ll be happy to give you free access to pretty much anything I release forever. Hopefully one day that’s worth something significant.

Announcing: RailRunner!

Apparently I felt that I didn’t have enough projects underway yet, so here’s another one: RailRunner! As usual, that’s the working title. You can read (a little) more about it on that page, but in essence it’s Railroad Tycoon 3 made more accessible and actiony/competitive. I’ve got a few ideas that feel like they’re pretty original and they’d work well together, but we’ll wait and see.

In other news, Hario is coming along nicely, and you can pretty much run around the level, jump on enemies and die. There’s all the classic terrain types, though items don’t really affect anything yet. Most of the movement and interaction is there though, so the foundation is solidly down for us to start building on. Despite being a ‘practice’ project, I’m starting to think that maybe it won’t be the worst game ever! It’s a very encouraging feeling, and I’m getting increasingly obsessed with working on it, so expect some decent releases soon!

Happy New Year!

Happy New Year to all and best wishes for 2011!

Why bother posting this when no one except me will read it in any relevant period of time? Because one of my new year’s resolutions is to make significant progress with at least some of my projects, and I’d better bloody well remember that. Tune in for serious updates from February onwards!