1 shot every 15 seconds, encoded at 24fps. In HD!

So, I’ll be participating this weekend, and I’ll be using a new library/framework I’ve been working on during the summer called dokidoki. It’s a collection of lua modules which provide utilities useful for game development, and some native C modules which interface with glfw, opengl, portaudio, etc. The idea is that you have a binary which runs init.lua in the current directory, which implements the game.

Source code for the binary parts

Compiled version for linux x86 (includes the lua parts of dokidoki)

Some examples (copy them into the binary directory and rename any of them to init.lua):

The windows binary isn’t ready to release yet, but I’ll be working on that sometime this weekend (or more likely Monday).

Assembled out of more than 10k JPEGs, totalling almost 2GB O_O.

http://www.youtube.com/watch?v=r5iXb51buMs

You play on the side of the advancing wall of doom, which is trying to engulf all. The lousy civilization which is getting in you way has set up barriers, though, in an attempt to hinder the darkness! Your job is to destroy these defences so that the cloud can continue its conquest. (Edit: I posted a bit more info about the process at my blog)

Download:

• Windows executable
• 32-bit Linux executable
• .love source (rename to .zip if you want to extract it)

You play on the side of the advancing wall of doom, which is trying to engulf all. The lousy civilization’s set up barriers, though, which the cloud can’t cross! Your job is to destroy these defences so that the cloud can continue its conquest.

Basic mechanics are working, the main things missing are enemies that fight back. Better graphics should be on the way, as well as some sound effects.

Here’s where I’m working most of the weekend. I’d like to clean it up a bit, but there’s no time for that this weekend =). I’ve got an second monitor I could use with xinerama, but that make the timelapse impossible to follow, so I won’t be. On the left is my afternoon snack, tortilla shell things with sliced chicken and Emmental on top. There’s also a bunch of Sambal Oelek under the chicken, just to make it a little bit more interesting XD.

Well, I have my idea, just gotta do it! Yummy lunch:

Well, it wasn’t awesome, but it was okay. More later!

The first of many. It may look small, but it makes up for it with lots of cheese.

And yes, it is sitting on top of a stack of encyclopedias, it’s just that kind of food.

Well, this is going to be my third Ludum Dare if you count the mini-LD I did. Previously I used Scheme/SDL/OpenGL, but since Lua’s a language I want to get comfortable with for other reasons, so I’m going to be putting it to use this weekend =).

I’ll be starting simple and working with the LÖVE engine. I have a bit of code already set up for miscellaneous things, which includes a small demo. Good luck everyone!

Had to be done. (actually it’s just a hack =p)

Timelapse!

http://ca.youtube.com/watch?v=2WrnjfxFQ64

Strangely enough, very little of the final levels I shipped with are in there. I stopped recording when I rebooted about half and hour before the deadline, so you can’t see me fooling around with sfxr either =(. You can, however, see all the time I wasted on that math problem on Saturday >:).

My final game is Mininode:

Download the source, Windows binary, or Linux binary (there was a problem with this last one, it should be fixed).

To execute from source, you need mzscheme with OpenGL support, libSDL, libSDL_image, and libSDL_mixer.  Execute with “mzscheme -u game.ss” from the folder. To execute the Linux binary, you need libSDL, libSDL_image, and libSDL_mixer, but you probably already have these. The Windows binary includes all required libraries.

Well, the family ate all the eggs before I got to them, so I had mini-wheats instead.

More of the blueberry/banana smoothie as well, and some toast.

I actually ate a couple of hours ago, I just didn’t get around to posting until now =). Only ~8 hours to go, gotta make the most of it!

After laziness and distraction, I’ve finally got enough of the game coded for a screenshot:

Right now it’s just some nodes pushing around signals when you click on them. Eventually I’m going to add nodes which take different actions  when hit with signals, and build some puzzle elements. Tonight, I’d like to get the tech side of things done, so I can focus on design tomorrow.

Dinner with my family is fried rice!

It’s actually much better than it looks. There turned out not quite to be enough for everyone, so I guess I’ll have a large snack later on.

My solution:

So the problem is to figure out the direction a player (moving in 3-d) has to shoot to hit an enemy (also moving in 3-d) given their positions, velocities, and the speed of the bullet.

The approach I used was to solve the equation

time it takes the enemy to reach a position = time it takes the bullet to reach the position

for the time.

First, redefine the vectors so that they are all relative to the player. This
leaves you with only bullet speed, enemy velocity, and enemy position. The
points in question are the points along the enemy’s trajectory, so express the
above equation in terms of t:

This can be solved with the quadratic equation:

Note that there may be zero, one, or two solutions. Negative solutions reflect hits in the past. If there are no positive solutions it is not possible for the player to hit the enemy.

Once you have t, it is simple to calculate the position.

Edit: forgot the exponent on the bottom of the final answer.

Okay, it’s a little late, but I was up late last night!

Yummy scrambled eggs, served on toast with garlic butter, with plentiful amounts of purple goop (blueberry and banana smoothie!).

little-lib is a library for quickly writing small games or OpenGL applications in mzscheme (v372). It relies on OpenGL, SDL, SDL_image, and SDL_mixer to process graphics output, key and mouse input, and playing sound effects. A sample program (demo.ss) illustrates the use of little-lib in these three respects.

little-lib is released under the MIT license. I plan to use this library for my Ludum Dare 11 entry.

Download the source code.

So, I’ve got something to submit (finally)! Not as polished as I’d like, but it’s pretty fun. It’s similar to asteroids, except instead of falling apart helplessly the asteroids fight back. Give it a try! WASD to move, IJKL to shoot.

Source (Install mzscheme and run it with “mzscheme -u black-box.ss”. libSDL, libSDL_image, and libSDL_mixer are required.)

Windows Binary (All libraries included.)

I’m not sure how this happened, but we seem to have managed to democratically voted in a theme which is unanimously hated. Last night, after about an hour of developing and throwing away bad ideas (too much content, dead boring, and lame, respectively) I finally came up with what I’m now going with.

I came to this idea through a roudabout manner, but what it really boils down to is asteroids. One difference, though, is that the asteroids have behaviour. Instead of simply coming apart when hit, the asteroids react in a (surprising!) manner. Some retaliate, some just act silly, and some in turn shoot at the other asteroids. You don’t know which is which until you try shooting at them, so you’ve got to be careful!

Of course, now for the long part, implementation. So far I’ve progressed to the point where I can move around and shoot:

I hope I’ll have time to finish, I’m going out for dinner tonight and tomorrow my family is eating out to celebrate my birthday (which, strangely enough, is today).

Only around 24 hours to go before the warm-up, so now is a good time to know that the blog works.

Everyone ready?

I hope the theme is moon mice.