A couple of years ago I came up with an unusual video game idea where you have to help these two species of creatures get along.  They coexist on an island, but, for the most part, hate each other.  Your character, through some misfortune, find yourself stranded on the island and the only way to get home is by befriending the local inhabitants and get them to cooperate — sharing resources and skills — to construct a ship.

The game would have been heavily artificial intelligence driven so that everything that happens effects the emotions and decisions of the characters in an unscripted way (which would have been rather difficult to pull off.)  The characters were going to communicate with each other through simple sentence structures which would convey relationships between characters, objects, locations, items, etc.  If, for example, one character hears news that a friend of his was attacked he might seek out revenge.  The character’s personality traits, knowledge, and emotional states would affect the probability of a character making certain decisions and taking action.  The exact details were never really worked out, however tricking the characters or lying to them would have been possible — which would have made the game have a unique dynamic.  You could deliver a gift to one of the tribes and claim it was from the leader of the other — effecting the way they think and feel about their rivals.  The gameplay would not at all been simple and straight-forward.

Every so often I decide to write simple test programs in Python just for the fun of it.  Here are a few that I had written over in the past.  Please note, because these were originally just simple experiments the source code could be a little messy and poorly optimized in most of them.  Also note, these are not meant to be all that impressive.

All of the programs require Python and PIL (The Python Imaging Library.)

Simple Recursive Maze Generator

This is just a simple maze generator that uses a recursive function.  It creates a near-infinite number of random mazes.

Source: maze.py

Rectangle Packing

I wanted to figure out a simple and effective way of packing rectangle images in an OpenGL texture — which is useful for hardware accelerated 2D graphics.  The solution I came up with simply subdivides the availible free space and packs the rectangles from largest to smallest.  It may not produce the best packing results and there are quite a few wasted cycles in this implimentation, but, for being as simple as it is, it produces fairly reasonable results rather quickly.

Source: rect_packing.py

Simple Error Diffused Dithering

Just simple error diffusion based image dithering.  The above image is showing four color dithering.

Source: dither_test.py

Random Forest Path

I decided to try to see if I could easily produce a visual effect resembling erosion patterns in a forest area.  This was part of some preliminary work in trying to write a game that randomly generates a completely different world each time it’s played.  The results were very satisfying considering how simple the solution is.  Essentially it’s just squiggly lines of varying thickness with some textureing applied to it.

Source: forest_path.py

Image Outlining

Originally I wanted to see if I could have interesting features of an image identified and later used in some sort of image recoginition system.  Hilighting sharp edges brought out too many points to practically be used for comparing spacial relationships and proportions, but it did produce some nice results for drawing outlines on an image.

I wanted to test it on a picture of a person, so I found the above image online.  It is actually a composit of 32 american male faces averaged together.  I hope the creators of the website he’s from does’t mind.

Source: img_outline.py