Indie Game Studio

Powered by Blogger.

The Singularity arrived - grab your clubs!


Folks,

we've been hidden in our bunker for a while (totally focused on overhauling The Journey of Eko's combat system), but once again we rise from darkness, this time to announce our newest micro-game: Singularity!






Our humble new platformer has nothing to do with the time travel fps under the same name (which we didn't even know existed until some minutes ago), nor it is The Journey of Eko. This one Singularity is a simple, hardcore platformer, made by two guys over a weekend to participate in Ludum Dare #24. The objective is simple: go forward and survive through the levels, which progressively become harder and more frantic. But there's a twist: levels are procedurally generated on the fly (the game itself builds them), the difficulty quickly adapts to the player's ability by adding and removing challenges in realtime, and the levels are always different.
Singularity was developed for the 24th edition of Ludum Dare, which took place a couple of weeks ago. Ludum Dare is a game making competition that has hundreds of individuals and teams around the world building a game over a weekend. This time, the theme was "Evolution", and while we did center our game's theme around that, we tried to also incorporate the theme at the gameplay and mechanics, making the game itself evolve as it's played. By the way, that was the perfect excuse, since we've been flirting with the idea of prototyping a procedural level generator for The Journey of Eko for months!

We enjoyed the game as it ended up becoming. In these game jams, time is very short and things have to be cut from the original design. Still, we think our Singularity is pretty fun! Since the levels are always different, at the very minimum us here at Pixel Cows have some sort of masochistic pleasure in (or "are man enough to") speed running our way through the game up to the hardest levels!


Post Mortem

Building Singularity was, unsurprisingly, much harder than we originally thought. When we heard the theme was "Evolution", we thought it was a great opportunity to test this casual action game idea where levels naturally evolve in response to the player's progress. JP (the other half of Pixel Cows) started with a basic platformer engine, while I structured the logic for the procedural level generator. Once those things were done, execution was relatively simple and focused mostly on balancing, implementing new mechanics and creating chunks of levels to be used in the level generator.


Three days production: placeholder graphics were replaced through the weekend


Another screenshot of how it ended up looking


How the level generator works
In fact, it's quite simple! In short, we created a database containing a lot of level 'chunks', each one recorded in an array, and organized the chunks in folders depending on how hard they were and what kind of challenge they contained (one folder has small holes, the other one has big holes, the other one has pterodactyls, etc).
The levels themselves are also tile-based, which means the entire level is a big array too. The level array is created by copying the values of the level chunks' arrays, which are selected by an algorithm that considers the Difficulty that the level is supposed to have, and the gradual introduction of new mechanics (meaning that new groups of chunks start being used as difficulty progresses).
The game starts at Difficulty 1, which rises one point each time the player beats a level. For each Difficulty value, there is a generic list of characteristics that correspond to that difficulty. For example, difficulty 1 is a combination of small holes and connection chunks; level 4 includes bigger holes and spikes as well. The level generator creates a list of the types of chunks it needs to create a level for the current level's difficulty, and proceeds to randomize the actual chunks that will be used. When it needs a "small hole" type of piece, it randomizes one of the arrays contained in the "small holes" folder, and then copies that array's values into the level array.When the last chunk is copied, the generator places the end platform that contains the Monolith, therefore ending the level.
Looking at it now, it's actually a quite simple and somewhat limited technique, but it does manage to keep creating fun levels long enough for a casual experience. If at any point we decide to expand this game or use the technique in another project, we'll consider some potential enhancements:



  • Less linear levels. Singularity only has horizontal levels, which stimulates a 'speed run' gameplay style, very casual and non exploratory in nature (opposite from The Journey of Eko in that matter)
  • Enemies and effects capable of reaching farther parts of the level (for exemple, making cannons work even when outside of the screen). That would make the challenges and effects combine more, generating more varied and unpredictable situations.
  • Code more interations between the existing elements. It's fun and surprising when an ant is blown by the wind of a fan, and it would be awesome if this type of interaction happened more often!

Looking at Singularity specifically as a game for Ludum Dare, we also had some good learning.

What worked

  • The level generation technology works well, and is fun to create and to play!
  • The brainless gameplay summed with infinite levels gave the game a good replay factor, despite its very limited development time.
  • The open, non-content-based design enables us to expand the game more easily, if we want.
  • The ease to test game balancing and incorporate new mechanics in the middle of real levels makes it much easier to balance and prototype new ideas. A new jump height can be tested in an infinite amount of situations, a new kind of cannon can be easily tested in all sorts of level topographies and in the middle of other obstacles.

What could have been different

  • Specifically in the context of Ludum Dare, most players don't play the same game more than once, due to the need of playing many other games. The levels being different at each playthrough isn't something that makes a difference for those particular players.
  • The enormous amount of time spent with technology and playtest left us with a short time for aesthetic polishing. The silhouette based graphics is interesting and easy to create, but we'd need more particles, shaders and color balancing to reach the level of quality that we originally aimed for.
  • The possibility that the level generator could create impassable levels led us to create 'conservative' level chunks and less randomization than we'd like.

Conclusion
Before anything else, a disclaimer: procedural generation isn't always the best way to create a game! Tiny Shard (the game we submitted for Ludum Dare 23) is an example of how manual level design has it's own advantages.
That said, creating a procedural level generator isn't that hard, and that is a very appropriate technique for casual gameplay, where repeating the same experience with small variations is enough to keep the player entertained. In fact, we already believed it was that way. The big surprise and unestimable discovery for us was the technique's usefulness in the context of playtest, and it's very likely that we'll use it to some degree in The Journey of Eko - at the very least, to test new mechanics and enemies!

That's all, folks. If you're man enough, grab your club, dress your jetpack, download Singularity and tell us what you think of it - and how far you were able to get!

Cheers,

Gabriel