I'm thinking about another attempt.

I've made another pong version, this time more playable and challenging:
http://www.allegro.cc/files/attachment/595282

Yeah, I know, now I'm trying to minimalise mine code.

BTW, love C++ for things like that:

From

if(y<r)
{
  y=r;
  vy*=-1;
}

if(y>s->h-r)
{
  y=s->h-r;
  vy*=-1;
}

to

y=y<r?vy*=-1,r:y>s->h-r?vy*=-1,s->h-r:y;

Four bytes saved

The comma separated values are evaluated from left to right, so d or f will be returned for a, if this is what you ask for. The ternary conditional is evaluated from right to left.

Næssén and Ted, your game is awesome. 80x25 or not, that game is really good.

-edit-
I haven't played cursor*10 before, so part of the reason I like this game is that it seemed so original and innovative. Now that I've tried cursor*10 this game doesn't seem as original (obviously) but I still prefer this one.

Here's my second game. It's a side scroller shoot-em-up. You're the green triangle, and you must avoid the grey cavern walls and shoot as many yellow orbs as you can before you crash.

Control is with the mouse, left button to fire.

{"name":"595290","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/b\/8\/b85d32d32803630ad64ce5068b61d9a6.jpg","w":645,"h":504,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/b\/8\/b85d32d32803630ad64ce5068b61d9a6"}

Attached is a little tool that takes some of the tedious work off your shoulders.

What it does:

Reads a C or C++ source file, removes all unnecessary stuff (whitespace unless absolutely needed, comments), renames all identifiers that start with a dollar sign into the shortest possible set of identifiers (first a single underscore, then a through z, then A through Z, then combinations of these plus digits; most-often-used identifiers get the shortest names), replaces character literarals by their numeric counterparts (because for everything below 100 the latter are shorter, above 100 they're equally long), formats the whole thing to max. 80 characters wide, and sends it to stdout.

How to use:

1. Unzip into a folder of your choice.
2. Compile using something like g++ *.cpp -o compress
3. In your code, prepend all of your own identifiers you want replaced (types, variables, functions) with a $. Identifiers without a $ will be left alone.
4. Assuming your original, unoptimized source file is foo.c, use something like this: compress foo.c > foo_compressed.c

For example, my attempt at (yet another) snake:

...is converted into this cryptic mess:

BTW, that game lacks some very basic features like edge collision (or proper wrapping), but hey, I still have 10 lines left.

-- edit --

Oh, and one more thing: C has this "nice" feature called "weak typing", which enables you to do things like this:

int b = create_bitmap(256, 256);
int c = "Hello world!";

In other words, pretty much anything can be an int.

You mean like this?

Given this thread is still open, I may have a crack at another idea...

This weekend I tried to turn my Tetris into 3D, but the Allegro 3D functions have long names and you have to call plenty of them, plus the vertex definitions and it easily went beyond the 25 lines. Even blitting from the buffer to the screen was annoying and the result wasn't even that great, not to mention how much slower it became, so I did quit.

Screenshot:
{"name":"595366","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/5\/1\/51bbe58adc86990fb5c2869534fd3d93.gif","w":263,"h":431,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/5\/1\/51bbe58adc86990fb5c2869534fd3d93"}

I think he did 'ray tracing' in one line actually. For raycasting, you only need to draw a line... repeatedly.

Hmm...I'll play!

I can't really work on it until I get home and don't have an idea anyway, but I have been thinking about some shortening tricks I haven't seen anyone do yet.

In particular, I haven't seen anyone do something like this:

#define  I  int
I(*DS)(I,I,I,I)=draw_sprite;I(*CB)(I,I)=create_bitmap;

/* and later on in your code */

BITMAP *b;
b=CB(64,64);DS(screen,b,1,1);

If you have a lot of calls to draw_sprite() or create_bitmap(), this might be a pretty significant space savings. This should save people from burning the first few lines on #defines (a cautionary note: this WILL generate warnings, at least with gcc)

May entries assume that they'll be run from the same directory the source file is in? I have some asset generation stupidity in mind...

I actually have something somewhat sprite-heavy in mind; there might be a lot of calls to draw_sprite() (although the same trick would work for any routine with a long name and argument list that gets called a lot). I'm not sure if this will save me space or not, although it seems like it might (and yes, I agree that #defines are a huge space waster). I didn't know that all functions defaulted to int arguments, though, that might come in handy.

I haven't quite cooked up a strategy for encoding stick figure animations yet; the game I'm envisioning might not even be possible...