Skip to main content

Project Tethys Post-mortem

Project Tethys was my entry for Ludum Dare 29. Here's the elevator pitch:
Project Tethys is a fast-paced underwater 2D shoot-em up inspired by the likes of Defender and Resogun. You control an advanced combat submarine tasked with defending an underwater research facility against an invading army. If you enjoy classic arcade-style action, this game is for you!
So far the game has been getting pretty good feedback. It's the most polished entry I've ever submitted for a Ludum Dare and the one that I'm most proud of so far. Here's what it looks like in action:

I've carried on working on it since the end of the competition, fixing some of the problems people have commented on and adding more of the features I'd originally planned. Expect another post about that when I'm ready to release it.


  • Unity 4.3 (free version)
  • GarageBand for iPad
  • bxfr
  • Nuke 8.0 (specifically the ModelBuilder node)
  • Paint.NET
  • VLC

What went right

  • Making a game I wanted to play! Helped me stay motivated and to be more critical when testing it, leading to a better game overall.
  • Using Unity. This was my first time using Unity and it was awesome! So much quicker than the hand-rolled javascript framework I'd been using for my previous LD entries. It allowed me to concentrate on the game rather than the tech.
  • Choosing a look that I could handle. The art style & setting only needed simple 3D models with no animation or rigging, which are things I suck at so I was glad to avoid them. Dynamic lighting makes it all look good anyway.
  • Time management. I had something playable by the end of the first day & spent the second day adding content and polishing it. At the end of the second day I stopped working on gameplay elements and started adding the bits around the game (titles, help, high scores, etc.).
  • Music. GarageBand on the iPad is an awesome way to quickly create music for game jams. Also, I've played around with it before so at least had some idea what I was doing.

What went wrong

  • Familiarity with Unity. Because it was my first Unity project I had to spend a fair bit of time watching tutorials and reading docs during the competition. If I already knew all that stuff I'd probably have had time fit in more of the enemy and power-up types I'd planned.
  • The explosions. That was a noob error: I should have ticked the box in Unity to make them 3D sounds, so that the ones further away weren't as loud. Oh well.
  • No radar or minimap. The game really needs one: without it you can't tell where the enemies are approaching from or where the power-ups are falling. I kept putting off doing this during the competition (because I wasn't sure how to do it), but I should have listened to myself.


  • Make a game that you want to play. It's a lot easier going if you do.
  • Keep using Unity!
  • Learn your tools ahead of time, so that you don't waste time learning them during the competition (and don't make noob errors).
  • Day 1 is for gameplay, day 2 is for content & gameplay refinement, the final few hours are for polish and completeness.


Popular posts from this blog

How to outperform std::vector in 1 easy step

Everyone who's familiar with C++ knows that you should avoid resizing a std::vector inside a loop wherever possible. The reasoning's pretty obvious: the memory allocated for the vector doubles in size each time it fills up and that doubling is a costly operation. Have you ever wondered why it's so costly though?

It's tempting to assume that because implementations of the STL have been around for so long that they must be pretty efficient. It turns out that's a bad assumption because the problem, in this case, is the standard itself: specifically, the allocator interface.

The allocator interface provides two methods that obtain and release memory:

allocate allocates uninitialized storage
(public member function)deallocate deallocates storage
(public member function)

(taken from this page).

What's missing is away of growing an existing memory allocation in place. In C this is provided by the realloc function, but there's no equivalent in the std::allocator interfa…

OpenGL ES and occlusion queries

This is a follow-up to my earlier post "WebGL doesn't have query objects".

Since I wrote that post, the situation has changed a bit. It's still true to say that WebGL doesn't have query objects, but the underlying reason - that OpenGL ES doesn't - is no longer true.

For OpenGL ES 2.0, there's an extension which provides basic query functionality: EXT_occlusion_query_boolean (which seems to have been based on ARB_occlusion_query2 from regular OpenGL). For OpenGL ES 3.0, the functionality from that extension appears to have been adopted into the standard. The extension provides two query types, both of which set a boolean value to indicate whether any pixels passed the depth and stencil tests.

While this is progress, unfortunately it's still not sufficient to implement the pixel accurate collision detection method I described in an earlier post. For that purpose it's not enough to know whether any pixels passed the tests; you want to know whether al…

WebGL doesn't have query objects.

WebGL doesn't support query objects yet. There's not even an extension for them. It's a bit of an oversight, but stems from the fact that they aren't in OpenGL ES 2.0 (which WebGL is based on) either.

Queries are useful for a number of things. Timer queries can be used to extract detailed profiling information about your rendering. Occlusion queries can be used for culling objects before they're drawn (especially useful if you have an expensive fragment shader). And so on.

This is a nuisance for me because I was using an occlusion query to perform fast pixel-accurate collision detection for my c++ game Schroedinger's Cat. Now that I'm attempting to port the game to WebGL, I need to find an alternative approach.

I've written a follow-up to this post: OpenGL ES and occlusion queries.