April Mini Game Jam

An other game jam is over and great fun was had! After I couldn’t attend the jam in February and didn’t get anything done during the March one (read a lot of the Doom3 source code though) I was pumped to actually make a game this time.The themes were:

  • Dark Science
  • Making a game character interesting instead of focusing on the game itself

  • Retrœalism

Naturally, I went with dark science. First I thought about something related to alchemy, but I couldn’t come up with a doable concept. So I went over to actual science, namely physics and after fiddling around with Unity for a while, I had a pretty good idea of what I wanted to do. In Ride the LHC you are a particle which gets continuously accelerated. You  have to collide with other particles to fuse into new elements and gain weight. But beware, if you fuse into an unstable isotope you’ll decay, loosing mass and speeding up. The goal is to gain as much kinetic energy as possible until you reach 0.9c.

I wanted to make it feel as scientific accurate as possible. While I know that this is not how particle accelerators work, the calculations I do should be pretty correct. All in all, I had a good time and other people seemed to like my concept, which is always great.

You can play the game here.

Advertisements

January Mini Game Jam

And Now for Something Completely Different…

This jams result is not really a game, though it is at least interactive. I have been trying to get back into OpenGL for some time but never got an excuse to do so. Hence the theme “Psychedelic Visualization” provided the perfect opportunity to throw shaders at something until it stopped moving.

Download Link

It sure is not quite as visually impressive as the stuff other people did with Unity, but I learned a lot from it and that is what I want from those jams anyway. I started out with grabbing some of my 3-year-old iterative code to render the Mandelbrot Set and coverted it to a fragment shader. That is what it ended up looking like:


#version 330

out vec4 outputColor;

smooth in vec2 gs_Pos;

uniform float time;
uniform vec2 resolution;
uniform vec2 size;
uniform float mirror;
uniform vec2 mousePos;

void main()
{
   //calculate local coordinates in the drawn quad
   float coordX = gs_Pos.x * size.x;
   float coordY = gs_Pos.y * size.y;

   //calculate zomm (mirrored if negative)
   float zoom = 500f * mirror *(sin(time+3*sin(time)) * 
                cos(log(time+20)/2) * cos(time * 12) + 1.0f);

   //calculate position to sample the fractal
   float cx = (coordX - size.x/2 - zoom * 1.2f)/zoom;
   float cy = (coordY - size.y/2)/zoom;

   //wobbly effect
   cx -= cos((cx + size.x/2 - coordX/2) *time * 0.025f)/zoom * 2;
   cy -= sin((cy + size.y/2 - coordY/2) *time * 0.025f)/zoom * 2;

   //compute the number of iterations needed 
   //to go over max_abs_square
   float max_abs_square = 5;

   //let the maximum iterations change over time to 
   //create a "breathing" effect
   int max_iter = int(15 + (sin(time) + 1)*10);
   float abs_square = 0;
   float iter = 0;
   float x = 0;
   float y = 0;
   float xt = 0;
   float yt = 0;

   while ( (abs_square <= max_abs_square) && 
           ( iter < max_iter ))
   {
      xt = (x * x) - (y * y) + cx;
      yt = (2 * x * y) + cy;

      x = xt;
      y = yt;
      iter++;
      abs_square = (x * x) + (y * y);
   }

   //calculate the fragment color dependend on the number 
   //iterations (you can do that as fancy as you want)
   outputColor = vec4(pow(iter/max_iter, 2.0f), 
                      pow(iter/max_iter, 4.0f)-0.25f, 
                      pow(iter/max_iter, 10.0f)-0.5f, 
                      iter/max_iter);
}

I added the music in the video after recording it. I unfortunatly hadn’t had the time to figure that out in the 8 hours as well. Fractaculus was partly inspired by my recent ventures into the demoscene, though I realize it’s nowhere close to what those people do. Also, I guess the shader could be a lot more optimized, but it does its job well enough.

December Mini Game Jam

I’ve decided to make a video of every game jam game I make. Most people wont download a 8 hour prototype and with a video you still get to show what you have done. This jams themes were;

  • Stealing things
  • Wait… it’s not what you think it is
  • Why do people run away from me?

I decided to go with “Stealing things” and make a classical capture the flag game. The mechanics of “Super Smash Balls” are inspired by ROFLNAUTS, the mini game which comes with Awesomenauts. That in turn is basically a simplified Super Smash Brothers clone. “Super Smash Balls” a two player game in which you can hit the other player. The more you get hit the further you will fly. I combined it with some tricks mentioned in this talk about making games “jucier”. The screenshake/tilt really add to the experience. It shows that you can make a game a lot more fun to play without changing the mechanics and highlights the importance of polish.

Download: https://www.dropbox.com/s/folphxfiejqgp93/SuperSmashBalls.zip

November Mini Game Jam

I’ve come to love game jams for the opportunity to try out new technology without having to worry about productivity. After two episodes of HTML5 + JavasScript I decided to dust of my C++ skills. This jams themes were:

  • “The war is over. We lost.”
  • “Doom, but you can talk to the monsters”
  • “Camouflage”

I decided to take up “Doom, but you can talk to the monsters”. First I started out trying to mod Doom. After two hours I had spent a lot of time on 90’s websites and struggled with multiple editors, but the only result was that I got to play Doom for the first time. After that I made the decision to pick up my initial plan and downloaded SFML. I took some of the Doom graphics and and a few sounds and made “Monsters can’t do Math” (get it here). It’s not that great of a game, but I learned the basics of SFML which opens up another way to leave XNA behind me.

October Mini Game Jam

ImageThe October Game Jam was just two short weeks after the September one. The themes were:

  • No turn back
  • Panic
  • Trapping enemies

I decided to go with HTML5 + JavaScript again, because I really like the ease of sharing those games. No one wants to spent time downloading a 8 hour game jam game. It’s even worse with XNA as you’ll probably have to install the runtime libraries as well. Plus it’s all open source and cross-platform that way.

The end product of this jam is “MAZEMORPH”. I did all the coding and Iwan the sound. Unfortunately I can’t get the sound working in the web version, it works fine if you download the source.

The game is about finding your way out of an ever-changing maze. You have to avoid traps, which decrease your FOV and increase the rate of which the labyrinths changes.

With this game the most time was spent on the implementation of the A* pathfinding algorithm. You can have a look at it in the source, though it’s not pretty.

Play the game here and look at the code there.

September Mini Game Jam

Image

The theme I used in the September Mini Game Jam was “Ultra Low Resolution”. The resulting game “Pixelfieldwars” is a local two player game. The red player spreads white and the blue player black color. The more fields one player occupies the more life the other player loses. The green fields are power ups which increase the outflow of color.

This game was my first try at HTML5 + JavaScript. I didn’t use any libraries, just a few lines of code for the basic game loop. You can play the game here.

 

July Mini Game Jam

Aaaand another Game Jam! I really start to enjoy those and I’ll try to attend as many as I can find as long as they are in Berlin. It’s a great experience, even if you don’t quite finish your game as it happend to us this time. You learn alot anyways.

This time I worked in a group with three other people, one programmer and two design/music/writing guys. We tried to make a text adventure which we then cut down to a interactive story.
Note to self: Parsing conversations into XML files takes god damn ages.