Hum, well, here’s my breakfast. Wasn’t easy to build The Tower, even though I cheated and it’s leaning against the glass. Now about coding a game.. or even finding an idea for one.. that will come next.

Didn’t spend much time, and also had no idea.. thought I still put up what I got: here

It needs python, pygame and pyopengl to run (..hm, for the real LD, I have to find someone who can make me a py2exe and py2app version of my entry). You can run until you touch the turnip if you want, but nothing will happen even then. Except for the unicorn, it also totally fails the theme and at no point I was even close to an idea

The good things about this mini LD for me though were, I think I know now how I could easily do one of those motocross games.. just need to use 2 or 3 collision circles instead of a single point as I did here, and some spring forces between. Also, I was surprised how easy it was to read SVG files – took me a total of 5 minutes to develop loader code for it (first few lines of line.py).

Here: download

Requires pygame and pyopengl.

If someone with Windows could create a py2exe, would be nice.

Also made a complete playthru video just now:

I started toying around a bit.. maybe I’ll submit an entry a bit later, if I get not distracted from coding. My idea is.. help a yellow python eat perls. The “versus” should be obvious, especially from the screen below

Well, didn’t really have time for LD, but I scribbled together a minimalist text adventure in 2 or 3 hours

It requires pygame and pyopengl to run if you still want to look at it..

final entry zip (.py files, had no time for py2exe)

A post-compo version of my entry is here.

Changes are:

• Different algorithm to create dynamic holes (without any texture upload), and compiled with optimization on (so no more slowdowns)
• Gameplay change: Can now walk even during explosions (which allows new timed puzzles)
• Gameplay change: Added movable bombs (allows Sokoban style puzzles)
• 4 new levels (13, 14, 15, 16 are new – still not very good, but a lot better than the ones in LD)
• Allow to choose your starting level (once reached)
• Some graphical changes, like flags to mark indestructible fields
• Fixed several bugs (most of which could not occur in the LD levels)
• Includes a crude linux makefile now besides the mingw makefile and the .exe
• There’s still a bug with 16-bit desktops under Windows
• Another bug which caused unexplained failures to upload textures is fixed with the fixed exe in the comments (so if it doesn’t start up, you can get that .exe – maybe I’ll also re-upload a new version with this later)

Was experimenting with this, gtk-recordMyDesktop made it trivial to capture a window and even sound, shows me again how little gameplay there is, oh well:

(Hm, got bored at work, so an extremely lengthy post-mortem following..)

Post-Mortem

LudumDare 10 entry “Lunte” by Allefant

Introduction

I have yet to analyze the over 3GB worth of automatic screen caps, but I think I spent about a third of time each in IRC, coding, or working in Blender. Rather minor amounts of time were devoted to idea research, making sounds in SFXR and making music in LMMS.

Audio

In fact, my music is somewhat of cheating, as I used an existing melody, and further, an existing .mid file including 2 additional scores to the melody, cords (or whatever, I’m no musician) and percussion. What I did is just fiddle in LMMS to create and assign instruments.. I gave a high pitched square wave to the main melody, a piano to the cords, and since LMMS decided to simply lump the midi percussion notes into one channel, ignoring the MIDI assignment, some wooden sounding neutral percussion to that. As for in-game sounds, I used SFXR by DrPetter, which simply is incredible – in last LDs I was running an old SimSynth through Wine to get some poor sounds, now (also thanks to mjau) I have a native app with all those randomization features making sound generation much quicker.

Video

Since sound is covered, next to graphics. My tools were Gimp and Blender. But most of the visible graphics are Blender renderings. I do know by now how to set up a simple “armature” to get stuff animated. I still have no idea what the difference between the three windows IPO/Action/NLA is and why some of them are empty some times and sometimes not. And very likely connected to that, I can’t figure out how to give separate animations to separate things (like, doing the feet animation independent of the head animation, in the same armature). With everything downscaled to 640×480 pixels, not many details were necessary anyway though.

One thing which proved somewhat challenging were shadows. I decided I want to have them separate – since two tree sprites next to each other looked somewhat odd otherwise. Suffice to say, I had to resort to Blender’s Python-scripting capabilities to have a script which fiddles with material parameters – for the non-shadow version, disabling the shadow, for the shadow version, setting all materials to “cast-only” and a special “shadow plane” to “only-shadow”. The result is, each of my graphics has two versions, the shadow and the rest.

The biggest challenge however was the explosions. I learned some about particles, soft-body and the deflection setting in Blender. One thing I wasted time on was when I tried to get the explosion to cast a shadow – Blender simply can’t to that (yet?) – particles can receive shadow, but not cast it.

Code

Now, finally, to the code. I ended up not using pygame but my C-disguised-as-Python language and my custom library. Which for someone who wants to compile means, the following dependencies are required:

• allegro window, input, timers
• allegroglopengl context in above window
• DUMBmod player, actually not used, but i found no time to edit it out of everything
• OpenGL, FreeType, png, z, jpeg, ogg, vorbis, vorbisfile

After that, it should be a matter of compiling all .c files in the “generated” folder and linking to those library. I provided the Makefile I used for cross-compiling the .exe.

The actual code I have written is all in the src directory, little more than 800 lines. I love the Python syntax for that, even though the code is rather hackish and there’s no comments, the forced indentation makes it still easy to follow. There’s nothing really special regarding the gameplay, it’s a rather simple puzzle game, done a 100 times. I made one huge list of all objects (santa, trees, bombs, wood), then pass it to the C qsort function to sort by layer and by y position, then draw it.

The challenging thing was the water/ice/snow layers. The straightforward idea was to first draw water, then where there is ice draw ice tiles, and finally snow tiles. It just would have meant, if there’s a snow tile at x/y, cut that tile out of the snow texture, and place to the screen. However, I wanted to use an alpha mask for the cutting out – but OpenGL 1.0 does not allow specifying a separate alpha channel. Which would have left me with some texture combine extension, or a fragment shader. I read up a bit on fragment shaders, but then finally went for a software solution, re-calculating the water animation with possibly ice and snow in front each time level geometry changes.

Game Design

One thing I totally neglected was level design. The game I cloned apparently lived from the clever level design, giving you hours of puzzles. In my version, there are no real levels, basically just 13 tutorial/test screens. I guess I could try and find a ROM of the original then rip out the levels. Or try to create some challenging levels myself. In any case, when doing a puzzle game in an LD48, time for level creation must be factored in. It’s hard enough doing platformer levels in short time, but for a puzzle game it’s crucial.

Conclusion

In a way, not having the least bit of originality haunted me throughout the competition. I wish now I had thought more about my initial chain-of-lights on xmas tree idea (all the xmas setting is a remnant of it), then could have spent the time creating explosions and break-able terrain on implementing that idea instead.

Ok, here a final screenshot:

Download (including source and windows .exe) is here: click to download

Not sure the .exe works, it’s cross-compiled from linux.

Right now I’m tired and should go to bed as I have to get up soon again, but some short thoughts. I’m quite satisfied I managed to finish. But I’m somewhat disappointed by how disinventive I was. This is just the original’s gameplay, with different artwork. Also from the technical side, I didn’t try anything new. Well, I blame the theme

Ok, slept about 7 hours then coded for about as long. Still far from finished. I spent some time looking into OpenGL shaders, then decided against using them and instead fiddled with some slow software solution.  Now there’s about 9 hours left, but I can’t stay up until 4am so it will be much less. Hopefully I can make some small levels so there will be about 10 levels.

to keep me alive during this LD.

Ok, I went the easy way and just added bombs with a chain reaction explosion. Took me hours to make those explosions in Blender. Oh, and for anyone who was wondering: Blender’s particles can not be made to cast shadows – no matter how hard you try.

Was playing around in Blender for hours.. and still have no idea about the game mechanics. Somehow, there needs to be a chain reaction of light bulbs Santa can somehow initiate or influence. Or maybe I’ll just add some bombs and have them chain react, worrying about what Santa has to do with it later..

Ok, still no fleshed out idea – but somehow, it goes like this: Santa wants to light up all trees for Christmas, so he has to do some electrical wiring in the forest to cause a chain reaction lighting up all trees. So far all I have is some mockup drawn in Blender:

I still have no idea. That is, already when Chain Reaction won in round 1of the voting I thought I’d just remake an old puzzle game where you place to bombs to set up a chain reaction of explosions. Problem is, I already remade that very game in SpeedHack once, so it would be like totally un-inventive, a re-remake.

Another idea I’m toying with is, a chain reaction of light bulbs. Like, you have to light a Christmas tree with electrical bulbs, and a chain reaction is involved. A level is won when you manage to light the tree. Still don’t have a complete plan how it should work though.

Just a bowl of soup for me – half an hour before announcement of the theme.

 Nothing much to see here – and interestingly to my cellphone everything but the monitor looks dark..

Since everyone is posting custom libraries, I assume that was required somewhere in the rules? I’ll likely just use pygame, but if not, I might use this library or parts of it. I put the code on SF a few years ago, it uses Allegro and OpenGL: logo is here and code is here. It’s written in C disguised as Python (I converted it all from plain C after being inspired by pyplus).

For the LD4 in 2004, we did a series of preparation compos. They were much shorter as a real LD, and as theme had the remake of an agreed upon classic game. One of them was Robotron (the others were Sapce Invaders, Frogger and Spy Hunter). In the Robotron one you had 4.8 hours for the game. My entry turned out to be a much better game than the one I actually wrote with 10 times as much time for the real LD. Oh well.

The game is rather simple. One directional input (cursor keys) controls the movement of the pink blob, another one (ASDW) controls the gun. Just like in the original.

There’s 30 partially random levels, and quite a lot of different enemies with unique behaviors.

Some of them, like the crab and the spider, were added in a post-compo version. Those are really hard (but fun, this is one of the few of my games I play through occasionally), as is the final boss. The crabs circle you, and the spider tries to aim ahead when shooting – back then I was still good at calculus, apparently The final boss doesn’t shoot you directly, but takes a lot of hits and spawns random enemies.