Introduction

This is a collection of all my games made for the LudumDare 48 hour game programming contest, and similar contests like Speedhack and TINS. These games are mostly pretty rough but some are already quite fun.

List of Games

(bolded entries are the ones in this package)

• LD22: Aloneasaurus Rex
• LD21: Escape -- No Entry
• LD20: It's Dangerous to go alone -- Take This
• LD19: Discovery -- Planet Thing
• LD18: Enemies as Weapons -- Iron Reflex
• LD17: Islands -- Crater Galapagos
• LD16: Exploration -- No Entry
• LD15: Caverns -- Spaceship in a Cave
• LD14: Advancing Wall of Doom -- Glacier
• LD13: Roads -- Crossroads
• LD12: The Tower -- Moonbase Defense
• LD11: Minimalist -- Cowbell Hero
• LD10.5: Weird/Unexpected/Surprise -- No Entry
• LD10: Chain Reaction -- Jumping Chain Guy (barely started)
• LD9: Build the level you play -- No Entry (i think)
• LD8.5: Moon, Anti-Text -- No Entry
• LD8: Swarms -- Bugzapper
• LD7: Growth -- Kudzu Commander
• LD6: Light and Darkness -- No Entry
• LD5: Random -- Buttonlands
• LD4: Infection -- Bad Food (2nd try)
• LD4: Infection -- BioWar (abandoned)
• LD3: Preparation -- Hannibal's Cannibals (lost the code)
• LD2: Construction/Destruction (Minor Theme: Sheep) -- Trans-Icelandic Express
• LD1: Guardian -- Zillagame (the game that started it all for me)
• LD0: Indirect Interaction (I didn't know about LD yet)
• MiniLD16: Constraints -- Moonsweeper (not included here)
• MiniLD11: Sandbox -- The Wanderer
• MiniLD9: Audio/Sound -- JamClock
• Speedhack 2003 - Outlands (my first allegro game)
• LudumDare Halloween Hack 2003 - The Halloween Machine
• TINS2006 - Railroad Merchant aka Merchant of Venus
• TINS2007 - Headline Recycler

Technology

Mostly these are built with C++ and a bit of python. They use either allegro or SDL/OpenGL (with one oddball Ogre experiment)

Each game includes a branch with the original version as it was after the 48 hours, and the 'trunk' which may contain future post-contest updates.

Part of the reason for creating this repository is to share the games with the world, adding to the pool of open source games. But I'm also planning to add future games to this repo, so during future contests you can watch me code in real time (or as often as I check in).

Building the Games

The build system is pretty craptastic right now. There's a CMake project that will build some of the games on linux but it will certainly need some tweaking to work for you. For windows, there are a few msdev project files but they will probably need so much work you'd be better off starting from scratch.

The Luddite Engine

I've slowly, slowly been collecting common bits of code into the "luddite" directory. This isn't a standalone engine like the usual thing, but a collection of code snippets that can be included into a project. It might evolve into a phat library one of these days but for now I like the decoupled and messy approach.

Some of this is my code, some of it is useful snippets from the internet that I adapted, all under MIT or BSD license though.

This code is not ready for prime time, it's confusing and full of bugs, so don't expect to just drop it in and work, but there's lots of useful bits.

Update

I have started to clean this up for real. But then stopped. But now I've started again. It's now hosted at: https://github.com/joeld42/luddite

There's not much there yet, but that's where it will go.

Features and status:

• Debug prints, assert and stack trace (works)
• font rendering (works, but it's convoluted process generate the font image)
• load obj files into openGL display list (works but not for GL ES2)
• embed obj files into C++ (sort of works, use the obj2cpp script)
• AVars, animated variables (works)
• Random numbers in uniform and normal distributions (works well)
• Tweak values in source code and live update (see: http://bit.ly/4B9Siu)
• Texture Handle Manager (a little rough around the edges)
• OpenGL sprites (works well, API is very rough)
• OpenGL Tilemap render (very primitive)
• Basic GUI stuff (not working)
• Some 2D particle stuff. (not working)
• Entity/Behavior system (good start but missing a lot)
• Singleton Template (works)
• example luddite_demo.cpp is a simple SDL/GL mainloop. (my starting point for LD48)

As you can see there's no rocket science here, it's not some super-awesome rendering engine, it's just a collection of stuff that I keep finding useful. The not working stuff, and other bits that I haven't mentioned, are things I've copied into here but haven't had a chance to clean up or make generic yet.

Remember, this is not meant to be used like a monolithic library, but more or less intended to grab a file or three and add them to an existing project.

There is absolutely no documentation. If you are brave/stupid enough to try and use any of this, feel free to email me with any questions. I'm also on IRC during the LD48 contests themselves.