Threaded

This is the game we made at the Berlin Mini Game Jam October 2015.  Starting from a basic game concept from Norman Ritter, we teamed up with Denice Wagner and Tommy Friese and made this game with Löve2D.  Our description of the game is “local multiplayer abstract infinite runner survival game”.

It’s a game about avoiding obstacles of your same color.  You can control your own shape, becoming narrower or wider.  When you are narrow, the speed increases, making it harder to dodge the coming obstacles but easier to pass through the gaps, and vice-versa.  The game can be played by up to 4 players at the same time, the single player mode being a practice mode.  With more players, it’s about who survives the longest.  Visually, the running tracks of each player are overlaid on top of each other, adding a bit of confusion but also making the game more fun.  It supports gamepad controllers as well as keyboard input.

The music is the song “Master of the universe”, by Alpha boy’s album Heroes on tape.  Graphic design by Denice and Tommy.

Enjoy.

• Download the game (Linux / Windows / OSX)
• Source code (Bitbucket)

 

ACE

This is a collaboration with Alpha Boy.  An audio-visual experience, rather than a game, even though it has a certain degree of interaction.

The grid.  A sky.  The 80s.

We teamed up at the Berlin Mini Jam of September 2015.  Inspired by my partner’s music, I started sketching some procedural code based on old tricks for demos, and we went on with that.  I think the result is quite neat.  We even recorded a small video of it.  However, youtube’s compression has severely affected the quality of the result, we recommend people to download and play the game themselves.

Enjoy!

• Download the game ( Windows + OS X + Linux + Löve2D)
• Source code repository

 

Stock Option

In August 2015, I attended Join, a conference about local multiplayer games.  Gregg Tavares presented his latest project, SuperHappyFunTimes, which is a NodeJs-based module for massive multiplayer local games.  The idea is that you can run a nodejs server in your computer, running the game.  This server creates a captive portal in your local wifi network, which other devices in the same network can access by opening a browser and going to the direction http://happyfuntimes.net .  The idea is that these other devices will be smartphones.  The server gives them a simple web page that will be a custom controller for the game.  In other words, as many as 100 players at the same time can connect to the same game, via their smartphone, and use it as a controller.

I found it very interesting, and at the following mini game jam that month, I made a little game called Stock Option.  It’s a very much simplified “simulation” of the stock market, with only one single type of stock.  The players only have two options, “buy” and “sell”. The rule is that each time one player “buys”, the price increases by 1 euro, so the next buyer will find it more expensive.  Each time a player “sells”, the price decreases by 1 euro.  All players trade with a “central bank” with a virtually infinite supply of such stocks, the price is only directed by their actions.

If you want to play it yourselves, you’ll have to download and install SuperHappyFunTimes.  Then you can get this game directly from the official site, in addition to other games that are made available in that system.

Notes: The screenshot is of a lower quality this time because it’s ripped from the presentation video below.  Still, I wanted to use it because it shows more players connected.  If I was creating my own screenshot at home I wouldn’t be able to easily reproduce 16+ players connected.

Have fun!

Presenting the game during the jam:

• Source code repository (Github)
• Game page at Super Happy Fun Times

Pulse

The theme for the Global Game Jam 2013 was “the sound of a heartbeat”.  Tanja Borzel had an idea for a game involving single cell beings swimming in the primordial soup, the player would synchronize the beat with other cells in order to connect to them, “becoming friends” and merging towards a multi-cellular being.

We teamed up and built a first prototype.  She took care of the art direction and created all the graphic assets, I wrote the code.  I had not been using Löve2D for a couple of years, last version I had checked was 0.5.0.  Over time, new versions of this framework had come out, adding new interesting features like shader support and sprite batches.  I decided to give the latest version at the time (0.8.0) a try.  I was pleasantly surprised, so much that this is the framework I have been using for the majority of my games in these two years.

First of all, we made a game with a strong influence from “exploration” games, something deliberately relaxing without any pressures on the player nor fast-paced action.  One of the design goals for this game was “no aggression”.  We would avoid any game mechanics involving cells “attacking” each other, by eating or any other similar means.  On top of that, another design goal was to create a game without instructions, a game where the whole point of it is to learn how to play by trying.  Given that the concept of this game is very different from the typical ones, in terms of new game mechanics to learn, the prototype had the flaw that it was very obscure and players were mostly lost.  Across time, this has been a game that survived in a corner of my hard disk.  Every few months I would go back to it and change a few things and show it to friends for play-testing.  Through this iterative process, the game has evolved into what it is now.  I am satisfied with how accessible it has become, and I am finally sharing it publicly.

Iwan Gabovitch helped us with the sound design and music, finding royalty-free material we could use.  For the main sound effects, I ended up using some instruments from the OLPC project.

As I mentioned, the game is made with Löve2D (version 0.9.1).  It’s free to download, but we appreciate a donation if you like it.  It’s available at itch.io.

Enjoy.

 

• Get the game ( Linux / OS X / Windows )
• Source code repository

 

Löve2D documentation for offline browsing

Some days ago I was looking for some way to quickly check the documentation for some of the languages / frameworks that I use, specially when I am offline.  I came across Zeal, which integrates well with many text editors.  The idea is simple: you highlight the keyword you want to look up, press “F1”, and you get directed to the corresponding page.  Zeal provides a quite big list of documentation bundles, called “docsets”, but one for Löve2D is missing.  However, it is relatively easy to create one yourself, provided you have the documentation already in HTML format.

So, I downloaded the Löve2D wiki as a zipfile, using the link provided in the wiki itself, and spent a couple of days massaging the files until they appear in a format that is better fitting for this purpose.

If you are using Löve2D on a regular basis and you’re tired of the typical “copy text -> open browser -> go to google -> paste -> click search -> click on the first result -> maybe I still need to navigate the wiki a bit more to find the info that I’m looking for”, this might be helpful to you.

Docsets, however, have a predefined set of possible “categories” in which to classify your pages, as you’re building the internal database.  I’ve tried my best to fit the wiki categories into those, but sometimes I couldn’t find a good match: for example, the tutorials are in the “Annotations” category since I couldn’t find anything better, or the information about the different versions of Löve2D are in the “Packages” category since there was no “Versions” category.

The docset might or might not work on similar software that also uses the format (like Velocity or Dash), but I haven’t had a chance to try it.

I hope you find this useful.

• Static page with instructions on how to install or download the docset into your copy of Zeal
• Github repository with the docset itself

Button Mashing Duel

This is the game I made at the Berlin Mini Game Jam on June 2015.  During the jam I wrote the prototype in Löve2D.  Afterwards, I thought that I’ll get more reach if I port it to HTML/Javascript, so that the game runs in the browser, avoiding the need for a downloadable binary.

The week before the jam, I had been thinking about online arguments.  I had an idea for a possible game where the person who gets the last word in “wins”.  But if someone else replies, then the other person is “winning”.  This is a minimalist interpretation of that concept, where you “win” by being the last to press the button. The catch is that if you “reply” again when you were the last to “talk”, you “contradict” yourself, so you lose points.  In terms of this game, this means double-clicking is punished, you need to be alternating presses between the two players.  The point of the game is to trick the other player into double-clicking, so that you can get ahead in the race for maximum score.

The game was playtested during the jam, the players generally liked it and some suggested turning it into a drinking game, which I think it’s a cool idea.

The browser version supports gamepad controls: just plug 2 gamepads, one per player.  If you don’t have gamepads, you can use the keyboard: left player uses the “A” key, right player the “L” key.  But part of the point of the game is to psychologically trick the other player into double-clicking, therefore physical contact is not allowed, nor touching the other player’s button.

Enjoy!

• Play the game in your browser (HTML5)
• Source code repository (github)

 

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!

• Get the game
• Source code repository
• Download APK

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.

• Andrew Harrison Apr 30,2014 (English)
• Melcadrien May 9, 2014 (English)
• wsclough1945 May 15, 2014
• Damien Lamouroux May 27, 2014
• Le SadPanda Jun 2, 2014 (French)
• Zyphoss VS Pickonace Jun 21, 2014 (French)
• Fork Jul 26, 2014 (English)
• Silicon Glitchy Aug 2, 2014 (Spanish)
• Button Masher Bros Aug 5, 2014 (English)
• SirFancyDinosaur Feb19, 2015
• Forgetful Lucy Mar 14, 2015 (English)
• Teddy Campbell Aug 15, 2015

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

• Downloads (Linux/Windows/OS X/Löve2D)
• Source code repository

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.

Vector

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.

• Vector on Github

 

Livecode

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.

• Livecode on Github