Firemint.

I've just read a job advertisement for a game programer position at Firemint, the Australian developer of the smash hit iPhone game, Flight Control. They must be making bajillions of dollars, as they seem to have about 14 employees in their office, which is not bad for a new studio with no apparent external funding.

Anyhow, one of the lines on the list of job requirements was:

* Demonstrated understanding of how to translate a game design into code and fill in gaps as necessary

"Fill in gaps as necessary". LOL.

That's probably the #1 requirement for a game developer. Most of the time, there is no design, no spec. If there is a spec, it is probably wrong. I'm not sure if this is a good thing, or a bad thing. The engineer inside me says "Surely this is no good!@#!" but the late night coder in me says "This is reality. Cope with it."

Wing Commander Concept Art

I was digging around my folks shed the other day, and came across some ancient Wing Commander Concept Art which I collected during my mis^H^H^H well spent youth.



This is the Dorkathi. I don't remember this ship, however I guess it is some kind of Kilrathi Transport for... dorks?

BinaryWriter, BinaryReader for Python

I've released some code which I use to read and write binary data in Python, which can then be used with System.Collections.BinaryReader and BinaryWriter in .NET.

I primarily use this for communicating between Unity3D applications (Mono) and Stackless Python servers. It includes the classes as an optional C extension if you feel the need for speed.

The Sky Crawlers

I've just finished watching The Sky Crawlers. This is a brilliant yet depressing film. Don't watch it if you're looking for something cheerful. Do watch if you want to spend a day or two thinking about what it might mean.

I'll probably take a look at the game when it is released, sometime this January.

Perth - GameJam Capital of .au?

I just had a look at what the other GGJ sites in Australia are doing.

Currently, NSW has two locations with two Jammers in total, and Victoria has one location with two Jammers.

Perth has one location with... 14 JAMMERS! Yes, Perth is the GameJam capital of Australia. We have an awesome community of artists and developers. I am certain that we will kick collective ar$e in January!

C# 3.0, properties.

After discovering that my favourite game platform could potentially use C# 3.0, I decided to see what I might be missing out on while I'm stuck with C# 2.0. I found the relevant document on MSDN, and came across this curious snippet. It is an example of "Automatically Implemented Properties".

public Class Point {
   public int X { get; set; }
   public int Y { get; set; }
}

Please enlighten me C# experts, why would I want do this? Surely this is semantically equivalent to:

public Class Point {
   public int X;
   public int Y;
}

It seems all the first snippet does is add extra function call overhead and extra keyboard taps. What am I missing here?

C# 3.0 in Unity3D?

Yes, it seems it is possible.

From http://answers.unity3d.com/:

Download and install the latest version of Mono (2.4.3)

From C:\Program Files\Mono-2.4.2.3\bin, grab these files: mono.exe, mono.dll, libglib-2.0-0.dll, libgmodule-2.0-0.dll

From C:\Program Files\Mono-2.4.2.3\lib\mono\2.0, grab these files: gmcs.exe, gmcs.exe.config, mscorlib.dll

Copy all these files to Unity\Editor\Data\MonoCompiler.framework

I'm guessing that this works because the C# 3.0 compiler still compiles to bytecode which is compatible with the mono runtime used by Unity 2.6.

I might try this out later, and post instructions for OSX.

Animation Resources for Indie Game Devs

Mixamo offer a tool for building and modifying prebuilt animations. The site looks very easy to use. Watching a soldier release his inner ballerina is... quite entertaining.

I'm quite impressed with the results so far, I can see myself using this in future projects.

Symbols in Python

Wikipedia defines a Symbol (as used in Lisp):

A symbol in the programming language Lisp is a primitive data structure that has a name. Symbols can be used as identifiers. Symbols are unique in a namespace (called package in Common Lisp). Symbols can be tested for equality with the function EQ. Lisp programs can generate new symbols at runtime. When Lisp reads data that contains textual represented symbols, existing symbols are referenced. If a symbol is unknown, the Lisp reader creates a new symbol.

I'm not overly familiar with Lisp, however I have done some work with Scheme; and an explicit Symbol type is something that I sometimes miss in Python. Do you ever find yourself defining classes to be used as global constants, so that you can use the identity operator? Perhaps something like this:

class START: pass
class QUIT: pass

if something() is QUIT: exit()

Symbols offer a better alternative to this, so I decided to implement a Symbol type in Python, which offered some of the features of a Lisp Symbol.

import sys 

class Symbols(object):
    def __init__(self, name):
        self.name = name
        self._symbols = {}

    def __repr__(self):
        return "<SYM %s>"%(self.name)

    def __getattr__(self, name):
        s = self._symbols[name] = self.__class__(name)
        self.__dict__[name] = s 
        return s

    def __getitem__(self, name):
        return getattr(self, name)

s = sys.modules["symbols"] = Symbols("Root")

How is this module intended to be used? Try this:

>>> import symbols
>>> symbols.START is symbols.QUIT
False
>>> symbols.START is symbols.START
True
>>> 

The symbols module contains every possible Symbol, and can be used as simple set of constants... but it can also do more than that.

>>> symbols["START"] is symbols.START
True
>>>

Symbols can be accessed by a string name, which lets you use different characters in a Symbol name, and provides a convenient method for creating new Symbols at runtime.

The last requirement is for Symbols to be unique within their own namespace. Our symbols module can support this too.

>>> symbols.Foo.Bar.Foo is symbols.Foo
False
>>> symbols.Foo.Bar.Foo is symbols.Foo.Bar.Foo
True
>>>

This feature allows you to have an nested set of Symbols which retain their identity wherever they're used in your program.