Skip to main content

Ludum Dare 24 Results

The voting has finally finished and the Ludum Dare 24 results are finally out. My game, frankly, did a lot better than I expected:

  • Humour #36
  • Fun #239
  • Mood #296
  • Overall #417
  • Graphics #600
  • Innovation #603
  • Audio #615
  • Theme #672

There were 1006 entries in the 48 hour competition. I'd been hoping to finish in the top half of the rankings this time after a poor showing last time and that's what I managed: 417th overall.

The big surprise was the humour score: wow! I was worried that the humour might be a bit too straight-faced for people, or that I'd be the only one who found it funny. Being wrong has rarely been a happier experience!

I was also really pleased with the Fun score. To me that's the most important category after Overall. It means I made something that people enjoyed playing and that's a really rewarding feeling.

It was nice to get a decent score for the mood category too, but I've never really understood what it means exactly. The other scores were more or less what I expected, except for audio: I didn't have any, so ranking above 391 others was a bit of a surprise!

I think if these results tell me anything, it's not to give up. It's still possible to make a decent game, even when you're starting over with less than 24 hours remaining in the competition. Also: the Ludum Dare community is awesome!


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.