• This year I will be attending the Game Developers Conference in San Francisco, California. All arrangements have been booked, and I will arrive a few days earlier to poke around the city and meet with family and friends. If you are into game development and want to meet up, please let me know! Especially if you want to jam. I hope to document my experiences (photos and writing), so keep an eye on this blog.
• I am currently seeking a new work situation. My CV is available in Hebrew and English — please contact me if you are interested.

== — == and now back to your regularly-scheduled programming == — ==

When I say “crapware”, I mean trial software/shareware of dubious origin. The process I came up with has plenty of software involved, but it is all freeware and stuff I trust or already had installed for other reasons. This is probably not the ideal way to do it.

1. Determine the origin of the RM file. If you have a link to an RM, you’re fine. If you have a .RAM file instead, download it and open in a text editor. The .RAM file contains a single line pointing to the .RM file you need.
2. Download the RM file. This is easy if the protocol is http. If the protocol is RTSP, you must use a special program. I used mplayer on Linux, following instructions found here. Simply run:mplayer -noframedrop -dumpfile out.rm -dumpstream rtsp://url/to/file.rm -bandwidth 250000
to download your music file. (“Bandwidth” is some random number to make it go faster.)
3. Convert the file to PCM (WAV) format. I used mplayer for this as well, under Linux. Simply run: mplayer out.rm -ap pcm Your file is now in PCM format!
4. Convert the PCM file to MP3. We have finished the ugly parts and now I’m sure you can do this on your own. I use Audacity to open the WAV file and export to MP3.

Good luck!

snake snake snake snake snake snake snake

Less than a week ago, I was busy developing a game called “Ghost Town” (see relevant post). This has been, by far, my most productive and successful Ludum Dare for quite a while, perhaps since April 2010. That’s not to say I haven’t gained anything from these other Ludum Dare competitions, but I’ve usually gone into them half-heartedly or with too grandiose a concept. The main reason is probably because I was trying to juggle my Physics degree and work at the same time.

However, I would like to save the motivational analysis for a future post (I have much to say in this regard!), and let’s get down to the technical/artistic breakdown of what happened.

The theme

I’m going to let you in on a secret: I didn’t do any voting for the theme! Not a single round. I think SoS Sosowski and the other Ludum Dare organizers did a fantastic job of weeding out the “weak” themes before the voting even began. Each round, I found myself looking at the list with indifference, because any one of the themes could work as an inspiration for games. I’m happy to say I didn’t build any expectations, nor did I feel any disappointment when I woke up on Saturday morning to find the theme announced as “Alone”. That said, I didn’t feel much in the way of identification with the theme either. (Though I will say that it was a crushing blow to see “Kittens” pushed to the end of the list. That was undeserved cruelty.)

When I awoke that morning, I didn’t get up immediately. I kind of went back to sleep. During this quasi-sleep, or maybe when I woke the second time, the idea of having a snake jump out and bite the player in a surprise cut-scene came to me. I put it aside in my gigantic brain, in the hopes that I’d come up with something better.

As per tradition, I left the house almost immediately, carrying my trusty camera. Instead of standing around waiting for an idea or forcing one into existence, I try to clear my head and frame photos around the theme. You can see these photos here, on my G+ photo album. I think they captured the feeling of “Alone” pretty well.

When I got back, I stared at the whiteboard for a while, trying to build some free associations. This didn’t lead me too far, and I just kind of ended up starting to code and draw things without really having a clear idea of where it was going.

I don’t believe that this thoughtlessness did much harm to my project. I knew something had to happen with ghosts, and something had to have a dangerous, filthy atmosphere to it. I knew there was a snake in it, and the snake was meant to surprise the player. This would be introduced by a cut scene, in which the player has a near-death experience by a hit-and-run snake.

With these things in mind, I set to work.

Coding

I used my boilerplate Flixel code to put together this platformer. On the one hand, I’m quite pleased with Flixel and I’m very comfortable with it as middleware for my Ludum Dare games. It is extremely fast and easy for me to get up and running, because if I forget how to do something, I have tons of in-house reference code I can look at. On the other hand, it means my games usually look and feel the same, and not just because Flixel lends its own look-and-feel. It has to do with how I build them, always in the same kind of general way. If I ever want to branch out and try something new, it will probably be difficult if I use the same Flixel basecode I am used to. But like I said, the learning curve was absolutely flat, and my game was up and running in no time at all.

But this smooth flow of coding was not to last. Following up on my “surprise snake” cutscene, I decided I needed a generic[ish] scripting method…. Things started to slow down here. I implemented a generic scene that would receive an embedded XML with a list of triggers and actions. The triggers would be read from each scene’s maps built in Tiled. It was daring and risky, because once you start building such a system, there really is no end to it. You can keep adding features and trigger options until coding each script takes longer than it would to simply add a huge “switch” statement with special cases.

It ended well, because it did work. But I think things would have been smoother if I had either already built such a thing (elegantly, unlike how it came out during the competition), or if I had just added special cases (ugly, but much faster to get working, and justified because of the small scope of the project). So this goes on the list of things to practice or wrap in an Eli Basecode library for the next time.

The artwork

Artwork for this game splits itself into two neat categories: spriting and backgrounds. Spriting was a huge challenge for me, because I really suck at animating. I think I did better than usually, because the walk cycle for the main character has more than two frames in it.

But the sprites did come out ok. Especially the ghosts, which I made using Photoshop, not GraphicsGale.

The backgrounds are a whole different story. For over a month, I’ve been attending “intuitive” drawing classes, and drawing something on my own nearly every day. While the idea was not to make “intuitive” style backdrops, I decided I would use the painterly style. These backgrounds were very easy to make, and I blitzed through ten of them in a really short time on Saturday night (direct link to portion of video with “background blitz”). Doing these backgrounds (and the tiles that went with them) are surely the high points of my Ludum Dare entry. Feeling at home with a tool is the greatest. In this case, it was Photoshop.

Sounds and music

And after that bout of self-congratulation, we arrive at the hardest part of the post-mortem. This part went all wrong! There are no sounds, and only one tiny musical riff played when the player finishes a screen. (I have been told that it does more harm than good, and I should probably have just left it out.)

So what happened here? I’m no stranger to music and sound in games, especially Ludum Dare. In retrospect, I think there was a certain kind of pressure I fabricated for myself, demanding too high a level of quality for the game. I could have made something simple and had a more complete entry, but the “visionary” Eli decided this was not good enough. I had great ideas for atmospheric sounds (windy building interiors, ghostly ambience, etc.), and five minutes with bfxr just weren’t enough to make it happen for me. I gave up on sound.

Music had a similar failure. I wanted some kind of moody music. The original idea even had more than one tune: Quiet ambience from the start of the game, followed by tense action sounds after the snake cut-scene, and finishing up with a wistful melancholy song for the ghosts. Obviously this was too much.

I think there are two ways to deal with this in the future. Either I should practice throwing together simple songs on a theme, or I should lower the demand on myself when it comes to the compo. Perhaps a mixture of the two will do it. Either way, being paralyzed because “it probably won’t come out good enough” is against the spirit of Ludum Dare and my own recent mindset about creation.

Overall

Overall, it was an excellent Ludum Dare weekend. I had a terrific time. Stress levels were high, and I had a very hard time getting to sleep, even after submitting the finished entry. But I did eat properly (mostly thanks to having a caring wifes — highly recommended), and I don’t feel I neglected myself.

Another difference this time was the recording of the timelapse. I found this to be a great productivity tool. I did take breaks, and I did find myself staring at Gmail or Google+, but every time I did so, I remembered the timelapse photos being taken and these breaks sort of ended themselves. Trying to make a good impression for the camera is an excellent motivational tool, (as long as it is voluntary!). Of course, when it’s all said and done, the timelapse looks pretty much the same. A blur of code and pixels flying by, and it inevitably looks like the subject is some kind of magician. So who knows if this productivity “trick” will work next time….

All in all, it was a fantastic weekend, and I look forward to the next one: Ludum Dare’s April 2012 edition will mark its 10th anniversary, and it will surely be a compo to remember.

Here is my entry for the 22nd Ludum Dare 48-hour game development competition.

All in all, it was a terrific experience (again). Very stressful, but extremely fun at the same time.

Links:

• Play the game (web-based Flash)
• See the Ludum Dare entry page

Simon reminded me how much glitchy animation is fun, so for one of my “daily exercises” I made a jittery guy do some silly animation. Looking at it again about a week later still makes me feel good, so here it is.

B.A.D. Animation (Flash)

Another source of inspiration is David Evans’s daily drawings.

The course included a short practical project chosen by the student. I decided to use a genetic algorithm to “breed” a kind of simulated life-form. The plan was elaborate, and I considered many complex ideas, but eventually stayed with the simplest creature I could come up with. It took form as a 3D box with four boxy “paddle” appendages. I used the Bullet physics engine, and I made the rest with C++ in Visual Studio.

Videos of the crazy creatures in action after the jump.

Here is Generation Zero of a random batch:

After many unsuccessful attempts at tweaking the breeding algorithm, damping was added to the simulation, and the populations began to converge after only a few generations…

Afterwards, to up the ante, I changed the plane to accept different inclines. This demanded that the creatures climb up, instead of just in any arbitrary direction.

Finally, here is a video of the creatures reacting and adapting to an erroneous fitness function. This function mistakenly demands that the creatures go as far as possible to their right (roughly in the direction of the camera). This leads to some strange and lopsided behavior.

All the code and some binaries are available for download. You can also find a more formal writeup in .PDF format.

There were tons of features I wanted to add, notably the huge sub-plot where the character is actually a mental patient “escaping” their reality by inventing a punching hero. The game was meant to switch back and forth between these two realities.

Visit the Ludum Dare entry page here.

I made everything, but the Wifes donated some voices for the evil nurse.

Thanks for playing, and thanks to all who cheered me on!

Special thanks to Daniel Zoran moral support, and also for really powering through this competition. His entry is most impressive!!!!

Entropy and time

To illustrate entropy, we use the classic example: a bottle full of gas, suddenly opened. The laws of thermodynamics dictate that the gas will expand to fill the new volume available to it. Conversely, placing an empty bottle inside a room full of gas would never collect every molecule inside it. This tendency towards disorder is quantified as entropy — but entropy is only a property of the entirety of the gas cloud as a very large collection of microscopic molecules.

Gravity affects all particles, even a single particle alone in a vacuum. Each particle of that gas “feels” the acceleration of gravity, but no single particle can “feel” entropy.

Entropy is more fickle than that, even. In closed systems, the total entropy can never be lowered — but nothing is guaranteed when it comes to local or open systems. Entropy can easily be lowered in many cases at the expense of total entropy, which can only rise. It’s safe to say that nothing on a human scale is truly a closed system, being as we are only a minuscule speck in the infinite expanse of the universe. We don’t even know if the universe itself is open or closed.

And so the question: how do we “feel” time passing? Even while staring at a wall, we have a sense of movement, that we traverse time like a fourth dimension. We certainly have no need of observing a thermodynamic process like a bottle of gas being opened in order to feel time moving by. We don’t need to observe our own body processes responding to entropy (such as hunger). Holding your breath and closing your eyes, you still feel time passing, even between heart beats.

Organic reduction of entropy through emergence

As I said before, it is possible to reduce local entropy at the expense of global entropy. Nature performs this miracle all the time in a process known as emergence. This occurs when many, many tiny components are exposed to huge influxes of energy. These tiny components tend to spontaneously organize themselves into larger structures, capable of reducing or even reversing their own entropy. A simple example is a desert full of many grains of sand, exposed to the terrific energy of endless winds. The sand grains tend to organize themselves into sand dunes, thus reducing their entropy.

Taken further, this describes life-forms very well. As living beings, made up of countless cells, animals are structures that minimize or reverse their own entropy.

Does consciousness reverse entropy?

And what of consciousness? Obviously this is a field that nobody currently understands very well, but we can still make observations of this strange phenomenon. I’ll use a very primitive model of the consciousness, which is probably wildly simplistic and inaccurate.

Our senses provide input, and translate events as they happen into signals.  These signals are consumed by the consciousness and stored in “memory”. Thus, the disparate signals reaching us from the outside world become organized spontaneously into what we can access later as memories. The brain, which has something to do with all this, consumes a huge amount of energy. I believe that this mimics the emergence phenomenon mentioned earlier: a huge influx of energy and information that organizes itself. In a word, the consciousness exists in an entropic minimum — or even in a realm of negative entropy, consistently.

To answer our question, maybe entropy does tell us which way is “future”. The world may be decaying, but our consciousnesses are busy organizing and reducing entropy. And thus, we “feel” time flow towards the lowest internal entropy of our consciousness, just as our bodies feel we are being accelerated “down” towards the center of the Earth.