What I learned with this LD is that 12 hours is not enough to develop a game, at least for me. For first day the competition my only progress was that I had the idea for a game in the theme of “Advancing Wall of Doom”.

My toughts during innovation followed path quite similar to this:

• What is the best known wall of the world? - The wall of china!
• How it may cause DOOM? - Of course it would have caused DOOM for all mankind if the chinese people hadn’t stopped building it! Sooner or later it would have covered entire face of the earth!
• The construction material for the “uber wall of china” would come from other human made constructs (cities and protective walls in my game) . The player tries to protect his cities by building his own walls (inferior to “uber wall of china” of course). Too bad that the hard working chinese workers can also use steal protective walls for building material, thus making the construction of their WALL OF DOOM even faster.
• The gameplay would have been an hybrid between Amiga game Masterblaster (the advancing “spiraly” wall) and the game classic Rampart (building your own walls using wall blocks not entirely different from tetris). The gameplay should be rather hectic and emphasizing on intuition rather than logic.

So what did I manage to complete in 12 hours. A lot, if you look back:

• I managed to set up dev enviroment on my secondary Ubuntu Jaunty box, consisting of MonoDevelop, SDL.NET, GIMP, Audacity, ffmpeg and others.
• I got a world with advancing china wall, (for now) invisible chinese workers, dwindling cities and basic wall placement rules.

I’m missing:

• Protective walls for players and mouse controlled way of placing them in Rampart style.
• Animated chinese workers who carry bricks from cities and player walls to their own wall.
• Score counting. Every tick with cities gives you points, when all the bricks from the city have been stolen to the chinese wall, points are no longer gained.
• Menu, hi-score and some sort of winnablility.

Perhaps I will complete game project later this week. Well see.

Video of the “toy” version of the still incomplete game (not playable or winnable):
http://www.youtube.com/watch?v=fn-EVAtI2xw

Timelapse of my 12h:
http://www.youtube.com/watch?v=80kwKIIYsCk

Edit: My comments to ratings are attached to this post.

Here it is,

http://code.bluedinosaurs.com/SDL/SlugvSalt.zip

Windows binaries included

You command a squad of slugs against the sinister cubes…
‘wasd’ and ‘g’ to fire, ‘h’ to jump for player 1.
Arrow keys, ‘m’ to jump, and comma to fire for player 2.

With PlatyGame in hand, I’ve got some simplified basecode ready.

#include <PlatyGame.h>
using namespace PlatyGame;

int main (int argc, char* argv[]) {
if (!initialize())
return 1;
atexit(shutdown);
if (!initText())
return 2;
atexit(shutdownText);
if (!initSound())
return 3;
atexit(shutdownSound);

bool fullscreen = false;
if(argc > 1) {
if(strcmp(argv[1], “fullscreen”) == 0) {
fullscreen = true;
}
}

Screen screen(800, 600, “Game”, fullscreen);
if (!screen.good())
return 4;

Sound snd(”snd/platymuus.wav”);
BitmapSprite splash(”gfx/platymuus.png”);
splash_run(screen, splash, snd, 4);

return 0;
}

Well, I’m ready and roaring for a great LD14 weekend. I’m going to break my programming-vacation for 48 hours and have myself at some code.

I’ll be using:

IDE: Code::Blocks
Language: C++
Libraries: SDL, SDL_image, SDL_ttf, and SDL_mixer, all rolled into one big PlatyGame (which I wrote myself), and possibly libcurl if internet is needed.
Art: GIMP and a little Paint.
Audio (if I do any): Musagi, SFXR, and Sound Recorder.

PlatyGame source and object files can be downloaded here:
http://www.platymuus.com/goods/PlatyGame.zip

Also, does anyone have any idea how to cut down on the number of DLLs I need to include with my application?

Here’s my submission.  This is my first compo, but I think you’ll like this.  I have included WinXP and Debian binaries in the zip:
http://pubpages.unh.edu/~jmb97/SDL/Dino.zip

I had to forget about sound to get it in on time.

Please leave descriptive comments of your reactions and impressions!

Thanks to pekuja for compiling Balloon Game! It should work for everybody now. I also included SDL.dll in the zip. No changes have been made to the code or graphics. Get the new version here.

See old post at http://www.ludumdare.com/compo/2009/01/10/balloon-game/

It’s amazing! It’s wonderful! It has potatoes.

Get it here. Uses C++ and SDL. Written & compiled in MSVC++ 2008 Express edition. MS Paint & GIMP for graphics. SFXr & Musagi for the sound & music that didn’t make it in.

Note: this is the Debug build because for some reason the Release build refuses to compile.

EDIT: See new post (http://www.ludumdare.com/compo/2009/01/11/balloon-game-update) for version that should actually work.

I have chosen the theme Balloon!. I think my color is going to be yellow. I’m itching to start coding even though I’m not supposed to yet. Normally I use C++ and SDL, but I’m considering using Flash as its capabilites might be better suitied to my project, though I’m not sure how to go about it.

If I do use C++ and SDL I’ll use my special library, which I am releasing right now here, if it’s not too late to be official. Please respond if you know for a fact this is valid or invalid! This is my own library, PlatyGame version something or other.

EDIT: I just realized this, apparently the compo already started.

Download here

Other screenies, time log and the above download here

It’s a board game for 1-3 human players, with AIs taking over the other 1-2 cars depending on how many humans there are. Cars can’t jump over each other, so if there’s no free lanes, you can block the traffic. Different routes are longer than others, and it’s possible to run out of gas.

Everyone plays with the same cards, only shuffled differently. Have fun!

Well, this is kind-of compo related, as I’m devoloping my library thing the wiki says I can have. I keep getting these warnings when compiling:

1>c:\program files\microsoft visual studio 8\vc\include\xlocnum(590) : warning C4312:
‘type cast’ : conversion from ‘uintptr_t’ to ‘void *’ of greater size
1> c:\program files\microsoft visual studio 8\vc\include\xlocnum(566) : while
compiling class template member function ’std::istreambuf_iterator<_Elem,_Traits>
std::num_get<_Elem,_InIt>::do_get(_InIt,_InIt,std::ios_base &,std::ios_base::iostate
&,void *&) const’
1> with
1> [
1> _Elem=char,
1> _Traits=std::char_traits,
1> _InIt=std::istreambuf_iterator>
1> ]
1> c:\program files\microsoft visual studio 8\vc\include\xlocnum(1367) : see
reference to class template instantiation ’std::num_get<_Elem,_InIt>’ being compiled
1> with
1> [
1> _Elem=char,
1> _InIt=std::istreambuf_iterator>
1> ]
1>c:\program files\microsoft visual studio 8\vc\include\xlocnum(590) : warning C4312:
‘type cast’ : conversion from ‘uintptr_t’ to ‘void *’ of greater size
1> c:\program files\microsoft visual studio 8\vc\include\xlocnum(566) : while
compiling class template member function ’std::istreambuf_iterator<_Elem,_Traits>
std::num_get<_Elem,_InIt>::do_get(_InIt,_InIt,std::ios_base &,std::ios_base::iostate
&,void *&) const’
1> with
1> [
1> _Elem=wchar_t,
1> _Traits=std::char_traits,
1> _InIt=std::istreambuf_iterator>
1> ]
1> c:\program files\microsoft visual studio 8\vc\include\xlocnum(1373) : see
reference to class template instantiation ’std::num_get<_Elem,_InIt>’ being compiled
1> with
1> [
1> _Elem=wchar_t,
1> _InIt=std::istreambuf_iterator>
1> ]

Anyone know what’s going on, or how to fix it? I’m using SDL and VC++ 2005 Express.

And also, anyone know an easy way to keep <pre> tags inside the column thing? I had to find where it went over and make my own line breaks… And I don’t know if it’ll still look right if you have a different screen resolution. Thanks in advance!

EDIT: Aiee! I give up… I’ll just use some other type of formatting…

Finished I guess. The minions didn’t make it in. They are so close to being ready but oh well It’s already late. I had a unicorn with a horn-stab move all ready too. ah well.

What it needs is gamepad input. And some scrolling, and the minions!

Windows EXE with C source

It’s Done! sort of…

Download here:
Download Frogger X Master Shake V3 MS Windows Version
Download Linux version
* Source included

My web pages with other projects

There are a whole lot of things I wanted to add but couldn’t. I’m pretty happy though about getting sound working and doing some halfway decent tile collisions for my first time.

**UPDATED** made it a little harder and improved particle performance, also jacked up the timer freq. for particle events.

This is my first Ludum Dare. I really like the theme and rules so I jumped in this time.

… so I stalled right out of the gate trying to pick a good pair of characters to face-off against each other. I had all kinds of ideas. My trouble was picking one and sticking to it. It’s definitely a fun theme. I picked Frogger from the 80’s arcade game and Master Shake from Aqua Team Hunger Force.

I like frogs and Shake is the perfect villain.

I picked a single-screen 1-on-1 duke-it-out style game with projectile and close quarters weapons. I haven’t done a 2D tile game before so I kept it simple: no scrolling, 1 screen, no OpenGL acceleration. it looks like the OpenGL acceleration isn’t that rough to add. I won’t have time tough.

So far I have a primitive particle system, my 2D tile drawing and loading from text files, and a simple sprite animated character. The mouse is used to aim the projectile weapon and fire. Keyboard moves left/right, jumping, change weapons, and can also fire weapons (as well as left mouse button).

The big stuff still to do:
very primitive collisions - rectangle-rectangle at tile level for jumping & weapon damage.
sound and sound content - this is a biggie for me. I haven’t messed with sound much before.
Draw Master Shake sprites
Draw “slap fight” hand-to-hand combat tile/sprite animations & add hand-to-hand game logic

Windows exe + source (compo version; if it crashes, get the post- compo zip below)

Windows exe + source (trivial post-compo fix edition, see below)

Timelapse video

Updated with a fix version above. The game would crash if run at a bit depth lower than 24bpp, use the fix version if it does! The fix also removes a comma from brygge-s.lua to fix a copy/paste bug that prevented turning around/right when looking away from the wharf, this isn’t required to beat the game or even much noticeable though.

Tools used: kate (text), gimp (graphics), sfxr (sound)

Libraries used: SDL, SDL_image (png), SDL_mixer (ogg vorbis), Lua

Bit of a late entry for me, but oh well, here it is anyway:

Download: cubetendo.zip (Updated with trivial fix for ATI cards)

Windows exe and source code included (compiles in Linux). Requires OpenGL 2.0. If it crashes, try running it from a console (updated the zip with a bat file that does this).

Howdy!

Here is my entry. It’s basically a cross between robotfindskitten and a generic platformer.

DOWNLOAD: http://kittay.ca/kittay-fydo-LD105.zip (1.0 mb)

Written in C, uses OpenGL. Didn’t have time to make a linux binary, sorry team.

I’m planning on doing a post-compo version, with bugfixes and better level graphics. Also, I’ll incorporate the other 3 mini-songs that I recorded, too.

Enjoy!

EDIT: Note that I’ve created a launchpad project for kittay. So you can file bugs there! Yay!

Shrapnel!

Downloads (both have windows exe + source code and Linux makefile):

• Compo version
• Post-compo: Smaller zip, sound latency fix (no code or data changes) (new)

Uses SDL, SDL_mixer and SDL_image. I used kate for code/text, gimp for graphics, sfxr for sound effects (thanks DrPetter!), and pxtone to make music.

If the Linux version crashes when you run it on 32-bit x86, use this SDL library (contains a fix for a bug in SDL_SoftStretch)

Edit: Figured out the Windows sound latency issue! Seems the SDL.dll I used was buggy. Replacing it with one from libsdl.org fixes things.

I ported DrPetter’s excellent sfxr (info) to SDL, so it can now be compiled and run natively in Linux!

Download: sfxr-sdl.tar.gz

Just type ‘make’ to compile. You need SDL and GTK 2.

The theme for LD 9 was “Build the level you play”. The premise is that you’re some god or something whose sole purpose in life is to control the path of some space fish, guiding them through gates that changes their colour, and get at least some set number of fish to go through the spectrum in each level. You control their path by creating planets, of course. Planets attract fish using the laws of gravity.

This is actually the first game where I’ve used OpenGL, apart from some small fiddling. (This also made it easy to make the game window freely resizable with hardware scaling, and I made sure the window always keeps the correct aspect ratio by inserting black borders where appropriate. Incorrect aspect ratios are always annoying.)

That aside, this one didn’t go very well. I spent a lot of time just fiddling around with insignificant things and not getting any parts of the game done, and about midway through I changed the aesthetics from creepy-ish paper-cut-outs floating around — something which at least looked somewhat interesting — to badly drawn space fish, and also inverted the planets, for reasons which completely escapes me. I had also coded up an in-game level editor that I used to create the included levels, but this was disabled for the compo release. For a compo where the theme was “build the level you play”. WTF?! Why did I do this? I have no idea.

The gameplay itself also had its issues. I think I made the gravity a bit too “realistic”, since inserting a planet subtly effects everything — so it doesn’t really matter if you’ve fine-tuned your existing planets to perfection if you have to insert a new planet or even move an existing one, the new gravity will upset the fish and you’ll have to fine-tune again. So, while the gameplay can be fun-ish for a little while, the constant required adjustments can quickly get annoying.

After the compo I played around with visualization of gravity by using a GLSL shader, which made the game somewhat more interesting (not to mention extremely colourful). Another thing I tried, both during the compo and after, was making the planets be effected by gravity, so they’d float around too (until they collided and launched themselves at light speed off the screen), and also make the fish generate gravity, attracting other fish and planets. Somewhat fun to watch and play with, specially with gravity visualization enabled, but the game was pretty much impossible then, heh =)

Download [ Windows/source code ]

My entry for Ludum Dare 8.5. LD 8.5 wasn’t a 48 hour compo, we only got 24 hours to make the game in, but the start time was flexible so you could choose the 24 hours of the weekend the compo was held that was best for you. I managed to use exactly 24 hours on my entry =)

Themes were Moon (actually “But even if you doubt their overwhelming findings, the Moon will never be the same to you again. Never will you raise your eyes to look at her without wondering: IS IT OR ISN’T IT AN ALIEN SPACESHIP WORLD?”, but everyone interpreted it as just “Moon”) and Anti-Textmode, no text at all in the game.

The story, which you have to guess at since there’s no text (and the readme is rather sparse), goes: You’re a rabbit, minding your own business on the moon, when one day a butterfly comes flying from somewhere. It flies straight into a crater, which happens to lead to a huge system of caves beneath the surface. Curious rabbit as you are, you follow it, and so the game begins.

When I started making this I actually intended to make one of those bullet hell shooter games, but for some reason the game evolved into this cave-flying exploration game in stead. Or, well, calling it an exploration game might be a bit of a stretch since there’s only 5 rooms in the game, not counting the exit room (which is a very quick drawing of what’s supposed to be me in my bed, getting a good night’s sleep after 24 hours straight spent coding and drawing), but it would have been if I had spent less time fooling around with the code. For such an art-heavy game you’d think most of the time was spent drawing things (all the rooms are just bitmaps, there’s no tiles), but I actually spent most of the time on code. So, the art didn’t take much time, which kinda surprised me, though of course everything being lores greyscale had something to do with that, and I did rush it a bit too. Anyway, doing the art was a lot of fun.

So anyway, you fly around in this cave system, collecting flashing ring things to open gates while avoiding monsters and projectiles and such. It’s a shame the game is so extremely short, because I really like it and think it could be a good game with some more work. Maybe I’ll get back to it sometime =)

Download: [ Windows | Linux/source code ]

This was my second Ludum Dare entry, for LD#8. Theme was swarms. This time you’re playing the Master of Fireflies, out for revenge against some mushroom-dwelling things who didn’t invite you to some insignificant party last week. So you send your swarm of fireflies after them to torch their mushroom homes. That’ll teach ‘em! The mushroom-dwelling things doesn’t take kindly to this though, and starts spraying water around, which unfortunately kills your swarm and stops the mushroom fires. The battle is on!

This was the first time I made something with a swarm-like behaviour, which was nice. The game turned out ok, though not really finished — those mushroom-dwelling things only ever face right, for example, and the levels weren’t supposed to be that flat. There should have been platforms and stuff. Still, there’s a win condition and level progression and such, so that’s something at least. Anyway, it’s kinda fun-ish for a little while, torching mushrooms while those poor guys losing their homes at your hand try to kill off your swarm, but it gets boring and repetitive after a while.

Oh well, I had fun making it, and learned some new things in the process, so I choose to consider it a success regardless =)

Download: [ Source code ]

This was my entry for Ludum Dare #7, which was the first LD I entered. The theme (growth) eventually gave me the idea of growing a maze.

So, you create the maze as you walk around inside it. When the game begins, the maze is just a set of disconnected squares. Each of these squares can be linked with a set number of its neighbours (how many depends on the square, from none to four), and you create new links by walking from one square to another where there’s no previous link. Once a link is created it can be walked on as much as you want, but a link can’t be removed once created, so you have to be careful when creating your maze so you don’t get stuck.

Once I had that working the deadline was looming close, so I threw in some keys and locks and made the objective to clear all locks of each level, to make the thing resemble an actual game. In the end there was four levels, a random level generator, and also a level editor.

I wrote in the original README that I’d continue to work on the game, something I haven’t done. I still like the general idea behind the game, but it has this tendency to degenerate into just staring at numbers, which isn’t very fun at all, and on top of that it’s easy to get stuck, having to restart the level if you don’t pay attention. Perhaps some of the extra elements I didn’t have time to put in the game for the compo — more tile types, powerups, bombs, enemies — would have made it better (more varied if nothing else), but I think the interface is the main problem. It should be more obvious what tiles can connect, how many exits are left, etc, so there’s less guesswork, no number tracing, just puzzle solving. Since the levels are so “dynamic” getting that to work would be tricky, though.

Download: [ Windows | Linux (x86) + source code ]