Icemelt Run

I teamed up again with Michael at the Berlin Mini Game Jam on November 2014.  The theme was “winter is coming”.  After some brainstorming, we came up with a basic concept: A bear running around slippery ice, gathering food for the family, while the ice is melting.  In a sense, our interpretation of the theme was rather “summer is coming”.

It’s a completely free game: no ads, no in-app purchases.  It’s a pity that in this day and age I have to give the explanation, just saying “free” doesn’t cut it.  Made for Android using Löve2D, as usual, and available at Google Play for you to try.  High scores are saved on the device, and the level layout is procedurally generated.

Have fun!

Icemelt run


Posted in Android, Berlin Mini Jam, Finished Games, JamGames, Löve2d | Leave a comment

Because this is literally… videos

As you might know, there’s this game I published almost a year ago called “Because this is literally the best we could come up with: retribution“.  Over time, a few youtubers have made videos of the game.  The fact that there’s people out there finding the game interesting enough to feature it in a video is something that makes me proud of what we created.

This post is only a list of links to the videos, so that I have them all collected in a single place.

Posted in Misc | 1 Comment

Day and night

A procedurally generated platformer with 371 levels.

This is the game I made together with Kirill Krysov at the Berlin Mini Game Jam on August 2014.  The theme was “Day and night”, and so is the title of the game.

The first idea was to make a game where the protagonist turns into a werewolf at night and can move faster and jump higher, while during the day, as a human, doesn’t have so much agility but can manipulate objects.  After a bit more brainstorming, we changed the metaphor into a would-be artist: during the night he’s more inspired and can reach further, creatively, while during the day he’s more focused and uses his tools more effectively.  We soon realized that forcing a pre-configured day/night cycle would be limiting to us, so instead we introduced a mechanic where the player can switch between the two states by looking itself in front of a “magic” miror.

The game is a platformer, the goal of each level being collecting all 4 items.  There are no hazards that can harm you, nor is there anything to attack, it’s only about navigating each level and locating the objects (you can use the “shift” key or the gamepad’s shoulder buttons to help you with that).

We spent the jam laying out the basic platforming engine and adding graphics to it, but when it came the time to start designing the levels, we hit a roadblock: none of us two had the energy to do it at the time.  As a solution to that problem, I have spent a few days creating procedurally generated levels.  The layout of the levels is fixed, the game features auto-save (you can continue where you left if you quit the game and launch it again), and a level selector (when you finish a level, another one is unlocked), and there are 371 of them.  Some of them trivially easy to solve, others a bit more laborious.  All of them can be finished, yet if you get stuck at some point you can skip that one and come back to it later.

The game is made with Löve2D and supports gamepads as well as keyboard controls.  The sounds/music can be turned off in the menu, as well as fullscreen/windowed mode.  The song is called “Her name is Cindy“, by Noisy Sundae (CC-BY-NC-SA).  As kind of a joke I wanted to use Comic Sans for the game’s font, but since the copyright of this font is unclear, I’ve used a similar one called “Cecily“, by someshinzz, which is freeware and commercial use is allowed.

Have fun

Day and Night screenshot

Posted in Berlin Mini Jam, Finished Games, JamGames, Löve2d | Leave a comment

Löve2d utils: livecode & vector

These are two small lua utilities that I wrote myself, which I find extremely useful when I’m writing games with Löve2D.  I guess you could call them “libraries”.  I think that they could be useful to other developers, so I’ve decided to share them via Github.  Each one of them is a single lua file that you can include in your project, and they are independent from each other.


This introduces a class called “Vector”, which I use for 2d vector math.  It has a bunch of basic functions like modulus, angle, vector operations (sum, product with scalar, dot product), and some other convenience functions (round, angle with another vector).  Note: all angles are in radians.

It’s briefly documented on the README file, and you can also take a look at the unit tests included.  The library is licensed under the zlib license.



This addresses the problem of tweaking values in a game.  The standard workflow with Löve2D is write some code, run the game, find something that needs to be changed, stop the game, change the number in the code, and launch again.  What this library offers is a faster cycle by loading changes in the code live while it’s running.  This way, once your game is running, you can just tweak values in the source and as soon as the file is saved, the changes are applied.  This can be specially powerful when the changes you’re making in the source affect the game in parts that are not shown at the beginning.  For example, if you were tweaking the values of some boss enemy at the end of a given level, having to restart the game every time you made one such change and reach the boss could take a while.

What this script does is to replace the standard Löve2D main loop, adding the possibility to “watch” changes in the source code while the application is running.  It does by modifying the function love.filesystem.load(): when you load files using that (as opposed to lua’s “require”), livecode starts tracking them internally and reloading them when they change in the filesystem.  It must be said, though, that this is not a perfect solution for all cases: it’s very dependant on the way you use global and local variables within your program.  For example, if you have an update function for a given entity which depends on some new variable that is initiallized when this entity is created, it can happen that already existing instances of such entity do not have said variable, and thus update will fail with them.  In that case, you can restart the game with F5 (which is a shortcut to call love.load() ), and that should fix this.  Moreover, a file that gets re-loaded by livecode is expected to overwrite the global variables/functions, and only them.  So, if you’re defining functions as methods of instances that are created during an explicit call to load, chances are that those functions will not be automatically overwritten (again, depends on your coding style), again you need to reload the game with F5.  Another possible problem is if you’re defining global variables outside of load: these will be overwritten each time you change something.

Fixing issues like that would require a more “intelligent” version of the library that is capable to parse your code, understand it, and decide where to apply changes, making several assumptions in the process that could potentially be wrong.  Not only that, but it would probably require to force a particular coding style upon you in order to make these assumptions valid.  That would be way out of the scope of this library, and I think it’s important how it works internally in order to figure out how to use it effectively and to understand where its limitations come from.  For that, there is a bit of explanation in the included readme file, as well as in the header of the souce code.

One feature that I included and I find extremely useful is that the game doesn’t need to be restarted when there is an error.  The game window shows the error message, on a black background, and subsequent calls to update/draw are skipped until the files change, which means that potentially you have fixed the issue; then the game continues executing from that point.  The black background is intentional, in order to distinguish it from standard errors happening at the Löve2D level (blue background), which means that the game is not able to recover from the error and has to be closed.

I use this for development only.  Once you want to distribute your games, I recomend that you remove the reference to this file.  Livecode does not require any changes in your source code at all, including it is only one line: “require ‘livecode'”.  All files loaded through love.filesystem.load() afterwards will be watched.  There are also a few more advanced features available (for example, watching resource files and calling a user-defined function when they are changed, and the possibility to define a callback function that will be called every time changes are reloaded), but even in its most basic use it’s already quite useful.

Also released under zlib license.

Posted in Löve2d, Misc | Leave a comment

A game of trust

This is one of those that sounded like a better idea in my mind.  There’s not much to say about this game, it’s quite self-explanatory.  It takes something like 5 minutes to play through.  Made with Löve2D.  Originally I wanted to do it in Javascript and put it in a web but at the end I got lazy and went for the easy solution instead.  At some point I wanted to add more “questions” (you’ll see what I mean when you play it), but since the point is made anyway with the current ones, there was never a real need for that.



Posted in Finished Games, Löve2d | Leave a comment

[abandoned] turnbas

This was a little experiment that I did around December 2013, according to the logs.  I was taking a break in-between projects.  I had been playing some Puzzlescript games, which I really enjoyed, and I was also trying to get into roguelikes, a genre that I’ve always felt a bit inaccessible to the uninitated.  Some new games were appearing at the time that took some of the elements of roguelikes but simplified them; some people called these simpler roguelike-inspired games “roguelites”.  On top of that, I was a little bit frustrated with the amount of work that goes into producing the content that a game requires, and I wanted to do something where I could just concentrate in writing code without having to think about content at all.  Interestingly enough I still feel a bit like that these days.

In this context, I started playing around with some basic mechanics of block-pushing, starting with the basic rules for block movement from Sokoban.  I left aside the puzzle part of it, and instead looked at the turn-based nature of roguelikes.  I only spent a couple of days with this project; I would just add mechanics to a basic skeleton and see what would come out of that, as opposed to having a specific goal to achieve with the development process.  In other words, this is a game more for my own entertainment as a programmer than enjoyable to a possible player.  Interestingly enough, the result is not far from a game I used to enjoy a lot when I was a child: Beast.

The time came to go back to “normal work” and leave this little experiment on the side.  I toyed with the idea of introducing some sort of procedural generation for the levels, but never got started with it.  The game as it is now is playable until the end, in the sense that it’s possible to win (by crushing/blowing all the beasts), and it’s possible to lose (by being touched by a beast, blown by a bomb or jumping into lava).  But there isn’t much depth to it.

You will need Löve2D 0.9.x to play the game.


Posted in Abandoned projects, Löve2d | Leave a comment


The theme for the Berlin Mini Game Jam on March 2011 was “colors”.  I teamed up with Volando and we came up with a simple design for a small strategy game that would work similar to a board game.

The game was already fun to play at the jam, we got excited and we thought that we could turn it into a full game.  Unfortunately, there was never time for this.  It needed a huge resedign of the user interface, and on top of that, the fact that there are no instructions available.  The rules, through simple once you’ve figured them out, are a bit obscure on first play.  We never got around to implement a proper tutorial, not even to write a text-based introduction to the game.  It’s been a few years since, and this has become another one of those projects in my hard disk that I’d like to redo from scratch one day but never find time to.

The game can be played between up to 4 players at the same computer, or against the machine.  There are 2-player, 3-player and 4-player modes, and each player can be “human” or “machine”.  There’s also a handful of boards to choose from, and two rulesets; which are basically the same except for one single rule, the one that lets you defend your territories; this one is not present in the “aggresive” mode, turning that one into “the player who plays last wins”.

A brief explanation on the rules: It’s a turn-based game.  In your turn, you place one of your “pieces” in the board.  There are 4 types of pieces: Fire, air, earth and water.  The relationship between the pieces is as follows:  Fire burns air.  Air blows earth.  Earth covers water.  Water extinguishes fire.  Which means that fire and earth do not interact with each other, and air and water are also mutually neutral.  The board might or might not have gaps, you can only place pieces in the non-gap positions.  Once the board is full, the game finishes, and the player with the higher score wins.  The moment you put a piece on the board, it’s compared with its 4 neighbours ( above, below, left and right ).  If the piece “kills” that neighbour, the neighbour is transformed into a copy of your piece; in other words, you “capture” it.  That only happens with pieces from other players: your own pieces cannot capture each other.  The effect then cascades down, evaluating the neighbours of the captured piece.  But, if your piece “loses” against the “enemy” piece, it’s your piece the one that transforms (but does not cascade), you have basically given that piece to your opponent.  Note that sometimes that’s what you want, depending on your strategy.  Now, the difference between the two modes, is that in the “aggressive” mode your piece can still capture enemy pieces before it gets transformed.  In the normal mode, you can only capture pieces if you are not captured yourself, which means that you can strategically locate your pieces so that they defend each other.  At the end of the game, the player with more captured pieces in the board is the winner, the number of captured pieces each player has during the game is shown on the sides of the board.

Anyway, I hope you like it.  I must confess that I did “invest” a lot of time “testing” the game in the 1-human against 3-AI mode: if you know how the game works it’s fun to play again and again.


Posted in Berlin Mini Jam, Finished Games, HTML5, JamGames | Leave a comment