Starting Make That Game Project

My final semester at RPI. Taking a few simple courses, another that I view as a capstone of sorts, a research project and finding a job. Of everything that will be keeping me busy, the research project will have the heaviest weight. While most of my classmates are just doing work for professors, I will be working on something I am excited about.

Last semester I was trying to figure out what I should do for this research requirement. It hit me in the shower, I really like languages, programming languages. I am also enjoy making games. Response? Make a game in multiple languages and analyze the resulting code. Metrics I am interested in is productivity, time to complete an objective, and maintainability, or readability of the code.

The Game

The game I have in mind is fairly simple. Play as a geometric object in an environment of other geometric object or chains. Create explosions, emanating your effluence onto these other objects. Once they have acquired enough effluence they too explode, spreading that effluence for you. After enough of this effluence has spread, you win. Simple, with a feedback loop.

I've already implemented one version as a Java4K competition game, whose turn in date was today (February 28th) (mirror). Though this is not one of my targeted languages for the immediate project, it was interesting to flush out the logic of the game (it helped flush out networking too, though left out of the java4k implementation due to security restrictions on applets). This will allow me to focus more on the systems.

Difficulty

The difficulty (mostly in the aspect of time) in this project will be that I am building all the game related systems (physics and networking are the two systems I am most interested in) in three target languages (C++, Go, Haskell).

I would love to do complete implementations in each language but as time will likely tell, that won't be possible. Parts of systems will be implemented in stages (eg. physics will only support circle collision at first).

This should turn out to be a fun adventure.

posted at: Mon, 01 Mar 2010 06:43 | path: /language/make_that_game | permanent link to this entry
Global Game Jam 2010: Disception

Everything I needed to do was held hostage this weekend as I dove into developing a new game for the much harolded Global Game Jam. At least SUNY Albany thinks its a big event and there was enough traffic on the website to slow it down to an absolute crawl.

To begin, this weekend was a lot of fun and I'd like to thank the great people at SUNY Albany and 1st Playable Productions. Lot of great people at both.

This was a great experience. I enjoyed as much as the last. Even though people advise you to not try new things I did. I didn't rewrite my entire pipeline and engine but I did write a few character controllers. I created movement systems that used the physics system of the engine in part instead of whole (the engine is Unity by the way). This was an interesting experience. I learned a lot. The methods used may not be optimal but I have a lot of great ideas I would like to try now to replace those used. Thanks to this experimenting, my team won Technical Excellence for a second year (there were two members in common between this year and last, Frank and myself).

I enjoy making physics based games, while this one does not fully follow a newtonian model except for falling, the movement style was different from other games and one of the core parts of the game. The virtual sensation of this movement method is a ton of fun.

Carrot - The Game

Before I continue blathering about the physics maybe I should go over what the game is. We made a game, and we called it Carrot. The idea that linked it to the theme of the jam, disception, is that the character jumps on an animal and holds a "carrot" on a stick in front of them. The character is limited to moving with up being in the opposite direction of the spherical (or circular, since its 2D). In short they cannot run up walls. The creatures you can jump on can, as well as run upside down. While a creature runs around it can eat other smaller creatures.

I really like this simple gameplay structure. My partners think it needs more, and maybe we will get to adding that later. But this simple package becomes so much more when you add multiple players. There is a simple but very fun aspect to escaping and chasing. Especially with creatures becoming enormous as they eat more. Players get attached to a creature they are growing. Its a lot of fun.

And while its fun, the current implementation is a little frustrating. Creatures move too fast for one and the level design is very poor for the creature and character movement. A lot of variable tweaking needs to happen.

Postmortem thoughts

Game Jams are a great place to test developers and working in an agile environment. It is not a place for testing methods, just new developers. I believe its a great situations to show simple ways of improving team communication in a short time period.

My primary thought on this is builds. Something fundamental to agile development is having an easy to run build system (just hit go) and using it often. (and part of Joel's 12 steps to better code.) Using unity we can create builds in one step but I didn't use it until the end. I wish I had and plan in the future to do so. This would have likely benefitted us. But maybe not.

Another thing we missed out on was having a pure designed in the group. Which there were none of at our jam location. Having a pure designed would have been very beneficial to have someone to test and tweak those fundamental values that never got touched. The core idea of the gameplay was coded (because we had programmers) but the bulk of the design work went incomplete (since we had no designers). As has happened in a lot of projects, I ended up being the task giver. We had artists and programmers and so I assigned tasks as such. But we did have people who had designer stickers (myself included).

So I think I have two improvements to perform:

  • Build early, build often (and have people test, and give thoughts. this should be a continuous task, almost to the point where people play new builds as they are created.)

    I do this already for projects outside of game jams. Finish a task, commit and build. But I didn't do this for the game jam, that pressure for doing everything can make you forget to do some activities.

  • Don't forget the design (and audio) tasks

    They are important too!

I think to solve this I'll make a wallpaper or overlay for my desktop that will say these things in large, menacing letters to remind me for my next jam.

posted at: Tue, 02 Feb 2010 17:58 | path: /games/gamejam | permanent link to this entry
Iteration 3: Plugins for Plugins

From about November 27th to December 2nd, I was sprinting over a new branch/version of the webfront for PyBlosxom that I have dubbed Iteration 3 (as its branch name on launchpad). It uses some code from the original webfront code base (namely the SessionControl object). But a lot of the core functions (saving, authenticating, session handling, template rendering, views) have to be implemented by callbacks that are called using PyBlosxom's callback facility.

The current callbacks in the core system are:

  1. wf_save - saves a entry to the datadir
  2. wf_authenticate - authenticate a username and password
  3. wf_session - manage session information
  4. wf_page - handling a query and form data and spitting out a response
  5. wf_render - rendering a template for a page

Iteration 3 provides a base/default implementation for these callbacks along with some useful functions in a tools package. But leaves plenty of room for improvement through additional plugins. Or you could modify how it works.

You can change how authentication works. Maybe instead of using a config variable to save your authentication information, you want to use OpenID or maybe you want to check the information against the local operating system. Write a plugin with a wf_authenticate callback using the method you want and there you go.

You can change how files save or how sessions are tracked. You can use a different template engine, or different templates. You can change how a page is handled.

What I think is potentially the best part is adding new pages.

Some ideas of mine:

Another idea I am hoping to do at a later time is look for/make a plugin to allow looking through a source repository as my datadir for old versions of a file and have those available. This plugin would also include callbacks for the webfront to save and commit changes to files. Which brings up thoughts improving methods for how the webfront reads files, whether it uses preexisting callbacks or a new one.

I have posted this initial sprint in a branch on launchpad next to its elder brethren at https://code.launchpad.net/~zera-goddard/pyblosxom-webfront/iteration3. For the time being, I will have to wait before I mess more in this branch. I like the resulting code so far but I have many criticism of many parts of my own already written down.

I have also played with using a few widely available javascripts (jquery & jquery.growfield) to make using the textarea in the editing page better. But I have not published that (partly because it takes five lines in the templates and inclusion of the forementioned in the templates folder).

More to do, so little time.

posted at: Mon, 07 Dec 2009 06:45 | path: /software/webfront | permanent link to this entry
Migs 2009 - Day 1

Its the morning of Day 2 at the Montreal International Game Summit, but I thought I'll try to quickly jot thoughts about talks made yesterday. Here we go.

Opening Keynote - by Yoichi Wada

It was cool to hear from the CEO of Square Enix. Thats most of what could be said of his keynote. Most people I have spoken to about had less than stellar feelings about it afterwards. We can probably all agree that the translation was a problem with it. At one point Wada-san said (through the translator), "Online is so important, I'm not going to talk about it." I took him to mean that he was not going to talk about it separately but it was still weird to hear.

Solving the Networked Physics Puzzle - by Glenn Fielder

I was very excited about this talk and I was not alone. The room was packed, though the rooms were smaller than last years. People stood. Then we watched Glenn's demo fail to start and through errors since it didn't want to go through the second monitor ... strange. He canceled after that happened since he did not slides, but fortunately MIGS later rescheduled it to the last time-slot of the day.

Skipping along

Indie in 2D - by Nathan Vella

President and Co-founder of Nathan Vella told us among things how to hire the best artists at an indie company: Have your other artists recommend people, they will recommend the best. One of my favorite talks.

Running out of time, so I'll post more later.

posted at: Wed, 18 Nov 2009 13:58 | path: /conf/migs/09 | permanent link to this entry
C: Multidimensional Loops

I am always looking for ways to make code more readable. Keeping the code terse yet clear. One kind of code I wanted to optimize was specific, partial looping on a multidimensional array. My example is that where you want to check adjacent positions in a 2D array. Previously I would have done something like the following:

int pos[2] = {0, 0}; // the base position

// perform the check on adjacent squares
int i, x, y;
for (i = 0; i < 4; i++) {
  switch (i) {
    case 0:
      x = -1; y = 0; break;
    case 1:
      x = 0; y = -1; break;
    case 2:
      x = 1; y = 0; break;
    case 3:
      x = 0; y = 1; break;
  }
  x += pos[0]; y += pos[1];

  // perform bounds check
  ...

  // perform the desired check
  ...
}

I have also seen other people's code which had a similar setup. As a big Python user for the last two years, I would express the above in a more terse fashion in Python:

base = (0, 0)

# perform the check on adjacent squares
for direction in ((-1,0), (0,-1), (1,0), (0,1)):
  x, y = direction + base
  # perform bounds check
  ...

  # perform the desired check
  ...

So now instead of 11 lines, we have 2 performing the looping. Yay Python! But we can do better in C and with something similar in nature to the python snippet:

int pos[2] = {0, 0};  // the base position

int i, x, y,
  // the adjacent directions
  dir[4][2] = {{-1,0}, {0,-1}, {1,0}, {0,1}};

// perform the check on adjacent squares
for (i = 0; i < 4; i++) {
  x = pos[0] + dir[i][0]; y = pos[1] + dir[i][1];  // unpack
  // perform bounds check
  ...

  // perform the desired check
  ...
}

This does apply quite well to multidimensional arrays. We can also use it for arrays of a single dimension if we needed to step over the array in an irregular way.

posted at: Mon, 16 Mar 2009 05:25 | path: /cplusplus | permanent link to this entry