Hiiii,

Here it iiis:

Windows version: http://www.raschke.de/julian/temp/ld14_final_win_jlnr.zip

Mac version: http://www.raschke.de/julian/temp/ld14_final.zip

Source code: http://www.raschke.de/julian/temp/ld14_src.zip

Not much content—sorry—I lacked direction and worked much more iteratively than before. Only really worked productively during the last hours. But I managed to do some nice little tricks using just a 2D lib

Enjoy!
(Reuploaded the next day because the original wording was unintentionally offensive in one instance. Didn’t touch the rest.)

Here it goes, Mac-only and without source so far:

http://www.raschke.de/julian/temp/ld14_demo.zip

This is my moment of triumph. I fear the level design will show that my concept is not THAT well thought out

Last night I wasn’t too happy with my mockup:

But I even switched to C++ because it allowed me to add some features that I wanted to do for a while. Also, I ate delicious tempeh burgers:

And suddenly, my game looked a lot better! I also had some ideas for more interesting gameplay last night, so today I’ll hopefully be more productive:

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?

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.

The main menu! Yay!

The game. Aww.

Finishing up tonight - pause menu, driving controls

Tomorrow - people that follow you, obstacles, and a goal.

I need help with collision code. I want to keep the player from falling through floors, pretty much. Help?

EDIT: Okay, I’ve got some good collision detection, but there’s something wrong with my moving code.

bool checkCollision(SDL_Rect &movable, double &vx, double &vy, SDL_Rect solid, bool move) {
int moveLeft = movable.x;
int moveTop = movable.y;
int moveRight = moveLeft + movable.w;
int moveBottom = moveTop + movable.h;

int solidLeft = solid.x;
int solidTop = solid.y;
int solidRight = solidLeft + solid.w;
int solidBottom = solidTop + solid.h;

int clipLeft = max(moveLeft, solidLeft);
int clipTop = max(moveTop, solidTop);
int clipRight = min(moveRight, solidRight);
int clipBottom = min(moveBottom, solidBottom);

if(clipLeft == clipRight || clipTop == clipBottom)
return false;

if(!move)
return true;

int clipWidth = clipRight - clipLeft;
int clipHeight = clipBottom - clipTop;

if(clipWidth solidX) {
// moving to right
movable.x += solidRight - moveLeft;
} else {
// moving to left
movable.x -= moveRight - solidLeft;
}
} else {
// moving along y axis
vy = 0;
int moveY = moveTop + movable.h / 2;
int solidY = solidLeft + solid.h / 2;
if(moveY > solidY) {
// moving to bottom
movable.y += solidBottom - moveTop;
} else {
// moving to top
movable.y -= moveBottom - solidTop;
}
}

return true;
}

Please help! If you’re interested in seeing what’s happening, here’s the program: http://files.chocoboheaven.com/uploads/Guests/files/85267_PaintWorld.zip

Ok. So I’m done! Thanks to timezone, I’m early too.

This has been my first competition, and it’s been a lot of fun.

Download it: http://www.ingeniumdigital.com/ldimg/TowerOfDoom.zip

Readme it: http://www.ingeniumdigital.com/ldimg/readme.txt

With all hope (due to its lack of being tested) it’ll actually work. It’s written in C++ with SFML. I’ve licensed the source under the MIT license. If this is a problem, yell.

Stay tuned for a postmortem and perhaps a less broken build after I sleep.

I’ve made a few improvements to Col-4, so that now at least I think it’s fun.

Relevant changes are:
- Smaller playing area, but higher.. kind of
- Different speed scale
- Special block
- Now middle area swappable instead of the upper one
- Preview of next block

Download source and Windows binary. Extra clarification note and reminder: this is post-48h, and shouldn’t be used for the voting.

Here’s my 10 hours entry: Col-4. It’s based on Columns, with the biggest difference being that you can swap the upper part of the playing field. This isn’t really so useful, but it can serves as a few extra lives, or half-lives, rather.

I didn’t much like the theme in the end, and that was why I didn’t start on an entry until today (well, partly — I couldn’t come up with a fun idea). And even then, I did a minimal effort. For matching the theme, there’s lots of minimalism. Columns to begin with is a very minimal game. Then I added minimal innovation that had minimal usefulness. Improvement in fun over the original is extremely minimal (probably negative). Readme is pretty minimal too. Features in game are minimal. Graphics are minimal.

Line up three or more blocks in same color to get points and remove blocks. Left/Right/Down keys to move moving block. Space to drop it. Up to rotate colors. A/D to swap upper part. Esc to quit.

Windows binary and source. Compiling for GNU/Linux shouldn’t require more than a small effort, but I’m not sure it would be worth even that.

Mr Head and the Cow Drowning is now complete. Or as complete as it will get this weekend. I have many ideas on improvements, but they must, alas, wait. But I’m getting ahead of myself.

As said earlier, the game is about drowning cows to prevent them from dying. Granted, they die anyway, but in a much more nice way, and outside the screen, mostly. Anyway, to drown cows, you must use key 1-5 to select which slot is currently bouncy, which will make any cows falling there to bounce out into the water. If you fail to catch a cow, you lose a life, but if you catch two in a row, you gain a life. You can have ten lives, and if they run out, the game is over.

During the game, Mr Head will observe and give you points and make announcements. He’s the mastermind behind everything, but exactly how is not certain. Do use his combo scheme to get many, many points. I’ve gotten 22 million as best so far. There’s no highscore in this version, but maybe I can add one later.

So, except for what has been told here, and what can be seen, there’s also a fancy intro, and mighty fine sound effects.

You probably want to download Mr Head and the Cow Drowning. Binary and source are included, the binary is for Windows, but with the right libraries and some changes to the makefile, you’ll be alright on other platforms too. Hopefully.

Also, make sure you don’t miss the Banana Ship text adventure non-entry, also made during this warmup.

Paramecium is a monocellular love story, in which the protagonist (you) must collect food vacuoles in order to replicate. You play on a team versus an a.i. opponent, and the first to collect enough vacuoles to replicate 25 times wins the round. Some of the game’s parameters are randomized at the start of each round, so it’s quite replayable.

Features artsy graphics, intuitive mouse control, and a looping ambient soundtrack.

Screenshots:

Download Paramecium Game and Source

Hero School is an arcade game that forces you to nimbly avoid, disarm or block bombs while navigating terrain to rescue alarmingly ugly girls who tend to say snide things to you.

It’s sort of Bomberman with new play mechanics, you don’t throw bombs, you avoid/disarm them.

Each level has different rules or items in place.

Heroes can’t cross water but fire sure does.

What a good looking hero!

Download game with source for Windows
(will think about doing a linux/OSX build too.. hrm)

Postmortem comments:

This was a really difficult competition for me because my brand new computer arrived RIGHT BEFORE it started and I had to constantly fight the urge to go set it up! Yeah, that’s dedication.

Ultra Fleet was my entry to the LD8 Swarms compo. For a bit of background information on it, please read about The Hat Swarm Attack on Dance Islands.

Set in space, you controlled a fleet of virus ships that could convert enemy ships. Fleets of enemy ships kept on attacking, and you needed to keep your fleet alive so you could go on fighting, gaining points while doing so.

The game was, if anything, more pretty than fun, but it really was playable once you got into it. Although you probably got bored within an hour or so. Don’t know how it placed, but it received OK scoring, and also got praise such as ‘The game I’m supposed to be reviewing is more like a screensaver’, ‘I liked Hat Swarm better, though’, ‘Without a doubt, Hat Swarm is WAY better’, ‘I honestly would have given the hat swarm a higher score though.’ But seriously, some people (including me!) actually seemed to like it.

You can get the Ultra Fleet compo version. It requires OpenGL and is for Windows, but I’ve been able to compile it for Linux, although I have no idea where that port went, but it should be pretty easy if you want to try yourself.

The Hat Swarm Attack on Dance Islands is a game made within 14h for the LD8 Swarms compo. However, it was never really entered into the compo, because I felt it wasn’t quite enough, but also couldn’t figure out how to make something more of it. In the end, I abandoned it, and instead used it as a base for Ultra Fleet, which I did enter. This might not have been the best of decisions, but no matter.

You navigated your hat swarm around islands to destroy dancers that tried to defend the islands, while at the same time trying to avoid the deadly dances that was danced at you.

The Hat Swarm Attack on Dance Islands prime features was an intro, an island generator (that I later used as a base for rather prettier islands), the famous Hoids algorithm that simulates hats in groups flocking behaviour (later adopted for the fleets in Ultra Fleet), stick figures, and a lot of dancing. Strangely, it was also my very first LD game (together with Ultra Fleet) that didn’t use tiles.

There’s no dedicated distribution for The Hat Swarm Attack on Dance Islands, but you can get it as the bonus in the Ultra Fleet compo version. It’s for Windows, but if you’re a bit clever, you can probably compile it for Linux. It requires OpenGL with 512×512 sized textures support.

The People was written for the Growth theme, and in many ways it resembles my first two LD games—there’s the tiled world, and you can build things on it. Only in this case it looks more fancy due to some clever tile rendering. Like my two first LD games, it’s a puzzle game.

There’s seven levels of varying difficulty, with goals such as ‘reach a population of X’ or ‘get Y huts’, a sandbox mode, and a tutorial mode. While you build stuff, a simulation is going on where new people appear and so on. A good description of what you actually do is, as someone put it, playing a planetary engineer.

My ‘post mortem’ for the game was pretty much the following:

So how did the game turn out? Good, and bad. My first idea was a kind of God game where you created land and such and people appeared. And there was supposed to be a kind of currency, that I called belief. So I coded the tile system and the simulation first, then I started to try to get it into a game. Well, it didn’t work, or at least it didn’t work without very much job, so I dropped it (the game idea, not the simulation and that). So I figured out another game: You have a limited supply of different kinds of land, and you have objectives to complete. Then there’s supposed to be interesting levels that are fun and challenging. I fixed up a tutorial mode, and a sandbox mode. These are pretty cool. Then there was the levels. I managed to come up with a few OK ones, but then it went downhill. So I ended with 7 levels, of which some are OK. Most are pretty easy, you just have to wait a while. I’m not very happy about them. But on the whole, the game’s pretty OK.

If you’re to believe the unofficial results from my own vote counter, The People did indeed turn out OK, and placed first in ‘fun’ and second in ‘innovation’ and ‘production’.

You can get the Windows compo version, or the Linux port version. They require OpenGL with multitexture support.

Uplighter was my entry for the Light & Darkness theme. It was a puzzle game centered on lighting up levels to certain percent by, among other things, placing lights, breaking down walls, and removing light sinks.

It’s was my first entry to feature 3D, although all gameplay and lighting is really in 2D, and it was also my first entry to not use Allegro. Instead it used GLFW, which is more lightweight, and I really didn’t need all the extra stuff from Allegro.

Uplighter is probably my best and most innovative LD entry so far—it placed first in ‘innovation’, second in ‘fun’, and also won the ‘Best In Show’ award.

You can get the compo version of Uplighter. It’s for Windows, but there’s a shell script (kindly provided by alar_k after the compo) that will fix stuff so it will compile for linux. You’ll need GLFW, GLFT, FMod and FreeType2.

Small notice: After the compo, it was reported to run very slowly on 3.0+ GHz machines. I’m still not sure what that was all about, but it has been reported that this can be fixed by compiling it in VS. If this is still much of a problem, I might get around to fix it myself.

Random Dungeon Exploration is the result of trying to push the Random theme as far as possible. It got random levels, random enemies, random quests (well, a little bit random!), random items, random player names, and random events. I guess it could have been even more random, but time was a limiting factor.

As for the actual gameplay, it’s fairly simple step based dungeon crawling. And a ‘town’ screen where you can shop and select dungeons. It felt pretty solid, but there were a lot of balancing issues that you’d notice once you reached some higher levels.

The game was well received, placing second in the ‘Fun’ and ‘Production’ categories, and also getting the ‘Best In Show’ UBER prize.

You can get the slightly improved post compo version, or the compo version. Both are for Windows and OpenGL.

The Destruction of the Viruses was a fairly ambitious (but not very innovative) game written for the Infection theme. The player had to clean out the insides of a computer by killing all the viruses that resided there. The viruses could clone themselves, so it wasn’t always that easy.

It played like a top-down shooter, with FPS controls, and used OpenGL to draw a level that could be rotated around the player.

There were many good intentions, and much love for the number 5 (there being 5 levels, 5 enemy types, and 5 weapon types), yet the game failed badly. The biggest mistake was a bug which made some parts of the game framerate dependent, leaving it extremely hard if you had a low framerate (it played as intended at about 180 FPS). It’s hard to say how it would have fared without the bug, but as it were, it placed about 23th.

You can get the compo version, or its source, if you want to, but I really must urge you not to! Better to get the ‘made working dist’ released a few days after the deadline. Both of them are for Windows and OpenGL.

I have an even better version around somewhere, that I haven’t packaged and released yet. I’ll do that soon, and then I’ll include it here.

Having learnt some great lessons from my previous LD48 entry, Save The Hut, I decided to not include as much boringness, confusion and frustration in my next game. Together with the theme Construction/Destruction, and a cosmetic theme of Sheep, it all became so obvious: I was to make a game where you construct traps to destruct sheep. And lo and behold! there was The Destruction of the Sheep.

I decided to use pretty much the same tech as for Save The Hut, but used it better to get some fancier stuff, like sub tile precision movements, rotated sprites, pseudo 3D particle gibs, and paintable background.

The game was supposed to be a puzzle game, but in the end only a few levels were puzzly, the rest was just mindless, but entertaining, sheep destruction with lots of gore. All in all, it worked out very well, making me a winner in ‘fun’ and ‘complete’ categories, and third in ‘gameplay (innovation?)’ and ‘overall’.

There’s an improved version available, adding some fixes, and a 2x time speed-up button (but there remains at least two bugs and a lot of spelling errors). You can get this version of The Destruction of the Sheep as a .zip archive or as an installer. They’re for Windows.

The original compo version is also available, both for DOS and for Windows (the Windows .exe was kindly provided by Hamumu during the compo). There’s also the source.

Save The Hut was my very first entry into the world of ‘make a game in a low amount of hours’ compos. It was all about The Hut, and how to Save it from the hut-hungry alien invaders. The player had to make sure The Hut survived for a certain amount of time. To achieve this, stuff could be built, but there was a limit set by the amount of credits available. It played as a mix of RTS and puzzle.

Featuring 10 levels, 8 bit palette graphics awesomeness, developed for DOS using Allegro and DJGPP, it placed about 14th. Its shortcomings seemed to be that people had trouble figuring it out, had real trouble passing level 3 (The Holy Cactuses, which was pretty hard), had trouble running DOS games, and also found ‘hold out for X seconds’ extremely annoying (because it sucks to fail at ‘2 seconds left’ and have to replay the level).

You can download a newer, slightly improved version (for Windows) of Save The Hut as a .zip archive, or as an installer. Or, you could get the old compo version (for DOS).