fasterthanlime

Dec 18, 2013 8 min #programming · #gamedev · #gamedesign

Lestac: The Making Of

Update: Lestac is now available in Early Access on itch.io! Read more on the official page

So, Lestac is out! Ain't that something? For those who don't know, it's Sylvain and I's entry for Ludum Dare 28, a video game jam that happens every four months.

Here's how it looks:

You can play it now if you haven't yet - it's available for Linux, OS/X, and Windows. And then you can come back and read this postmortem if you will!

People come to play a Ludum Dare 72 entry expecting a collage of Google Image results and public domain sounds, but nope, we've actually composed everything in there within the 72h time limit.

In fact, we liked the result so much we put it up on Bandcamp! Have a listen.

Buying the album is a sure fire way to support our game dev and music efforts. Of course, do it only if you actually like it!

Other fun facts about the soundtrack:

1. The first track was a joke - I started playing whatever and Sylvain kept adding tracks and hitting record. I had no choice but to improvise, and well, in the end, while heavy, it's a pretty funny one!
2. The second track is the only collaboration between Sylvain & I - he wrote the early, chill part, and I ruined it all with my electric guitar sounds and whatnot.
3. The Untradeables is definitely inspired by Michael Giacchino's work on The Incredibles' soundtrack, except we don't have 30 brass players handy. It's also the only track with a 5/4 time signature, which is FUCKING AWESOME.
4. The Deep End was recorded in one go - Sylvain says it sounds like a Christmas tune. Well, all the better.
5. Lost In Town was a personal sin - when you're a pianist you don't do piano ballads in your game soundtracks! They all sound the same! But I still think it ended up okay. During the whole thing I had Radiohead's "My Iron Lung" song stuck in my head, hopefully it's not too similar.

I haven't much to say about 'You Only Get One Goodbye' since I didn't write it, except of course, that I like it very much - there's so much good stuff in there, I'm pretty sure it would be a 12 minutes track if only there hadn't been a damn deadline.

Fun fact: most people who play Lestac think of the universe as "one big map" that you scroll into, one screen at a time. What they don't suspect, is that there's no such thing as one big map - all the screens are separate levels with teleport sensors and spawns so that you can seamlessly navigate it all.

In fact, here's one big map, which are really screenshots of the game stitched together - with three colored dots to show the non-linear teleports:

This design results in some pretty powerful stuff - not only can you go left and right and down and up to another screen, but you can also enter buildings, then exit then again and be elsewhere, in the same screen as before, also enter caves, etc. The map above is missing interior scenes, but you get the point.

However, this also led to design problems - since screens are loaded when the loader goes through a teleport - what happens with objects? In the initial version, you could throw an object into a side of the screen and lose it forever. That's pretty annoying.

In recent builds, they'll be teleported to the screen in question, but there's still something that's not terribly seamless - physics won't be simulated there until the player actually enters that screen, which looks funny. But it's still a lot more playable now.

There is some sort of backstory, although not a heavy one - each character has a motivation for which item they want and each item they give. For example, the scientist wants mushrooms (which are actually quite potent) and a feather, to make the air-bazooka.

Similarly, the dude at the entrance of the cave is some kind of creative junkie who craves shrooms but is afraid of the dark - the old lady in the building will happily give you her cat because it fights with her dog. The kids want a balloon in exchange for the front wheel of their broken bicycle.

Oh by the way, you can make awesome jumps with the air-bazooka. There's also something akin to the shotgun-jump of Spelunky - but the level design doesn't allow you to use it right now. Perhaps in a post-jam version...

Here is the list of hardware and software we have used to produce Lestac:

• A Yamaha Clavinova CLP-880 keyboard
• A cheap midi USB interface (thanks, Fred!)
• Cubase 7 Artist edition
• EastWest's Composers Collection
• Debian sid, Windows 7, OSX 10.9, Ubuntu 13.04
• The Gimp 2.8.10
• Tiled 0.9.1
• A Wacom Bamboo Dock tablet
• Two screens, two mice, two keyboards
• Three laptops, one desktop computer
• Coffee & cigarettes

So, pretty much standard stuff. I wouldn't use anything other than Cubase 7+ to write music, though. Expensive, but after spending years suffering the whims of various open/free music packages, I'm not going back. Ever.

In fact, the whole soundtrack except for Le Baron, is one 18-minutes Cubase project - it was easier to work on the whole that way, to make sure it was coherent - not only that it used the same instrumentation and effects, but also that the tracks were good to listen in a single go.

On the other hand, Gimp, while painful to work with multiple layers / animating stuff, has pretty much everything we needed to work on this project. I could think of a thousand little feature requests for the Gimp, but it got the job done.

Tiled (the map editor) was nice, although it crashed on us a few times - its flexibility (pretty much everything can have arbitrary key-value attributes) allowed us to quickly whip up a lot of content without having to touch the code at all! There were a few crashes, but nothing too serious.

Much like many of my other games, the game is fully written in ooc - not only that, but the game framework underneath it, the dependency manager, the audio and graphics framework, and, well, the compiler itself, too.

I remember during the first few Ludum Dare jams I participated in, I was already in the "It'll be all ooc or it won't be at all!" mindset, but it got in the way a lot more. That last one? Pretty much excellent. Compiler reported the right errors, ran fast so we could iterate quickly, almost ideal.

Here's the complete software stack:

• rock, the ooc compiler and its SDK
• dye, my game utility framework (along with gnaar)
• stb image to load textures
• SDL 2.x, SDL mixer, GLEW 1.10.x, OpenGL 3.x
• git, gvim, ack, zsh, among many others
• libyaml, mxml, bleep, deadlogger, ooc-tiled
• Both gdb and lldb, for Linux and Mac debugging
• Both clang (for dev), gcc and mingw32-gcc (for release builds)

There's a few things I've done with this game that I hadn't done previously. One of them is 'live config'. Basically, there's a config file, in YAML format, that is being reloaded whenever you Alt-Tab in and out of the game - which means adjusting speeds and stuff was very fast.

Also adjustable while the game is running, debug overlays - here it is showing where teleports (in blue) and spawns (in green) are - along with where they go. Very useful to figure out a buggy transition.

Overall, Ludum Dare 28 was definitely a good millesime - I'm looking forward to the next one, and - but I always say that - I might keep working on Lestac, as we've gotten really awesome feedback and I'm excited to add new environments and perhaps new features / mechanics.

Don't forget that you can buy the soundtrack if you like what we do. The game is all free to play on its Ludum Dare page, available for Linux, Windows, and Mac.

Now that you've read all that, go play the latest build of Lestac again. And this time, press the F11 key before you start - full screen or no screen. And FINISH IT THIS TIME. If you do, send a proof to @fasterthanlime on Twitter.

Comment on /r/fasterthanlime

Here's another article just for you:

I am a Java, C#, C or C++ developer, time to do some Rust

Aug 12, 2020

1 hour 2 min #rust · #traits · #lifetimes

As I've said before, I'm working on a book about lifetimes. Or maybe it's just a long series - I haven't decided the specifics yet. Like every one of my series/book things, it's long, and it starts you off way in the periphery of the subject, and takes a lot of detours to get there.

In other words - it's great if you want an adventure (which truly understanding Rust definitely is), but it's not the best if you are currently on the puzzled end of a conversation with your neighborhood lifetime enforcer, the Rust compiler.

Read more