#! /usr/bin/env python

import random

# Width and height of maze needs to be an even number because of walls
WIDTH = 60
HEIGHT = 20

# The change in x and y for all four directions
UP = (0, -1)
DOWN = (0, 1)
LEFT = (-1, 0)
RIGHT = (1, 0)

def recursive_maze(maze, x=0, y=0, dirx=0, diry=0):
	# Check if current position is inside maze boundry
    if 0 <= y < len(maze):
        if 0 <= x < len(maze[0]):
			# Check if this position can have a new hallway going to it
            if maze[y][x] == "#":
				# Make this position into a hallway
                maze[y][x] = " "

                # Connect this position with previous position
                maze[y-diry][x-dirx] = " "

                # Create direction list and randomize it's order
                directions = [UP, DOWN, LEFT, RIGHT]
                random.shuffle(directions)

                # Follows each direction when the callstack returns here
                for dx, dy in directions:
					# Go down this current direction
                    recursive_maze(maze, x + dx*2, y + dy*2, dx, dy)

def draw_maze(maze):
	# Draw top wall
    print "#" * (len(maze[0])+1)
    # Draw each line with left wall added in
    for line in maze:
        print "#" + "".join(line)

# Initialize the maze as am array of arrays filled with wall spaces
maze = [["#" for j in xrange(WIDTH)] for i in xrange(HEIGHT)]

# Start making the maze
recursive_maze(maze)

# Finally, draw it
draw_maze(maze)

The output of this program will look similar to this:

#############################################################
# #       #     #           #           #               #   #
# ##### # # ### # ######### ####### ### # ########### # # ###
#   #   # #   # #   #     #   #   # # # # #           # #   #
### # ### ### # ### ### # ### # # # # # ### ########### ### #
#   #   #     #   # #   # #   # #   # #   # #     #   # #   #
# ##### ######### # # ### # ### ##### ### # # ### # # # # ###
# #     # #     #   #   # # #   #     #   #     # # # # #   #
# # ##### # # ######### ### # ### ### # ######### # ### ### #
# # #       #         #   #   #     # #         # # #   #   #
# # ### ########### # ### ######### ########### # # # ### ###
# #   #   #       # #     #         #           # # # #     #
# # # ### # ####### ####### ### ### # ########### # # # ### #
# # # # #   #       #     #   #   # # #           # # # #   #
# # # # # ### ##### # ### ### ### ### ########### # # ### # #
# # # #   #   #     # # #     #   #   #         # #   #   # #
# ### # ### ##### ### # ####### ### ### ####### # # ### ### #
# #   # # # #   # #   #       #     #   #     #   #     #   #
# # ### # # # # ### ####### # ######### # ### ########### ###
#   #     #   #             #           #   #               #
#############################################################

This first article will feature message queue and publisher classes.  They are quite simple, yet certainly useful.

Message Queue

The message queue class is very short and simple.

class MsgQueue:
    def __init__(self):
        self.messages = []

    def post(self, msg, category, *args):
        self.messages.append((msg, category, args))

    def get(self):
        for msg in self.messages:
            yield msg
        self.messages = []

Messages can be posted to it and retrieved from it through the ‘post’ and ‘get’ functions.  The messages that are posted are tuples of message, category, and arguments.  The categories can be used to group messages of similar types together.  For example, in a game there might be a category called ‘switches,’ where a message is posted each time a switch in the level is turned on or off.

The ‘get’ function is a generator for iterating through the messages then clearing the list of messages.

#Example Use for MsgQueue
q = MsgQueue()
q.post("red switch on", "switches")
q.post("red switch off", "switches", "with an extra argument")

# elsewhere in a sea of code ...

for msg,category,args in q.get():
    if category == "switches":
        if msg == "red switch on":
            fire_laser_beams("Pew! Pew!")
        elif msg == "red switch off":
            stop_firing_those_lasers()

Publisher With Message Queues Subscribers

Message queues can subscribe to message categories within this message publisher class.

class MsgPublisher:
    def __init__(self):
        self.categories = {}

    def subscribe(self, subscriber, category='default'):
        if not self.categories.has_key(category):
            self.categories[category] = []

        self.categories[category].append(subscriber)

    def unsubscribe(self, subscriber, category = None):
        if category is None:
            for c in self.categories.itervalues():
                c.remove(subscriber)

        else:
            if self.categories.has_key(category):
                self.categories[category].remove(subscriber)

    def post(self, msg, category='default', *args):
        if self.categories.has_key(category):
            for subscription in self.categories[category]:
                subscription.post(msg, category, *args)

The method ‘subscribe’ is used to subscribe a message queue to a publisher.  Categories are used to group subscriptions so that a single publisher can serve several uses.  A subscribing message queue will need to subscribe to each of these categories separately. If category is blank ‘default’ will be used.

The method ‘unsubscribe’ removes a subscribed message queue from it’s subscription list(s).  If category is ‘None’ (default) it will be unsubscribed from all of the categories.

The method ‘post’ is used for posting messages to the subscribed message queues.  Each message will be sent to all of the message queues that have subscribed to the specified category.

#Example use of MsgPublisher
qa = MsgQueue()
qb = MsgQueue()
qc = MsgQueue()

p = MsgPublisher()
p.subscribe(qa)
p.subscribe(qb)
p.subscribe(qb, "new category")
p.subscribe(qc, "new category")

p.post("message")  # sent to qa and qb
p.post("something else", "new category")  # sent to qb and qc

p.unsubscribe(qa)
p.unsubscribe(qb, "new category")  # qb will be removed from "new category"
p.unsubscribe(qb)  # now qb removed from all categories
p.unsubscribe(qc)  # will be removed from all categories

Opportunities for Use

There are many times when speed and direct interaction are not needed but flexibility is.  In a game objects can simply plug in and listen to the messages being sent — creating an easy and modular system.  Also it is more like asking for things to happen than telling other parts of your program to do things.  These messages can be ignored.

Some instances where message queues and publishers might be useful include: game state changes, abstraction to other systems such as sound, world dynamics, communications between game entities, etc.

Most of the simply used graphics and sounds stolen from other sources, but I decided to make custom content for all my games.  My favourite is Rolling Hills, which even has music!

My four games can be found at here. Have fun!

Here is a timelapse video of me working.  It is 22 hours of the 48 hour long competition.  The only parts not recorded was when my computer was off and when my screen was blank from inactivity.  Music is Escape Route by Corran on the Cave Story ReMix Project based on the music of Cave Story by Pixel.

This article will outline how such a procedurally generated map could be made.  Note, I have not yet written the program.  All the illustrations shown here were hand-drawn, but the results of a real implementation of this generater should be the same.

Room Seeds

Starting locations for rooms to grow from.

The first thing to do is to randomly select starting locations to grow rooms from, as indicated as green circles.  These locations will be stored in a list of grid cells.

Grow Rooms

Rooms grown to fill cells.

A cell will be randomly selected from the list of active cells.  If the cell has empty neighboring cell that will be activated, given the same room id, and added to the active cell list.  If the cell has no available empty neighboring cell it would be removed from the list.  This loops until all of the cells are filled, defining the shapes of each of the rooms.  The growth pattern is shown as blue lines and the room boundaries are indicated as black lines.

Connectivity

Finding how the rooms are connected.

The cells of neighboring rooms will be noted and a list of possible door locations will created.  These possible door locations are indicated as short red lines.

A separate list will be generated noting what rooms are accessible to each other room.  The links between rooms are shown here as pale yellow lines.  No spacial information is needed, but for illustration purposes I’m using the room seeds to make the connectivity easier to see.

Flow of game-play

Flow of game-play connectivity.

A starting location will be selected.  If this is the game’s over-world then the starting point may be any random room.  If this is an interior location, such as a castle, an outer room may be a better choice.  The starting location is shown as a little star here.

Starting from the start location connecting paths between rooms will be defined.  A running inventory of items obtained in rooms will be kept track of, such as the collecting of keys.  If a key is available then a locked door between rooms may be defined.  This will result in the creation of a new room group.  The room groups are shown as colored lines with the group id and group depth level also indicated.

Interlinking between rooms of the same group may be fairly common.  Cross linking between rooms of the same group depth level should be more rare to make sure rooms or whole groups are not skipped too often.

Keys will keep track of what room group id they were obtained in.  Keys should only be used in room groups of greater or equal group id to make sure the player doesn’t get stuck by choosing a different order of game-play — since any key can open any door and the key dissappears after use.  Use-once and infinite-use items do not need as much care since there is no risk of cutting off access to pathways.

Defining Doors

Choosing where doors will go.

Doors will be selected from the possible door locations list.  In the above illustration unlocked doors are white and locked doors are yellow.  I also shown where keys may be obtained.

Doors do not need to be a single space.  Several doors may be selected, whole walls removed, or any other pattern of connectivity could be used depending on situation and desired result.

Using room growth info

Using room growth information.

Dead ends in the room growth process can be useful.  As long as the cell is not in front of a door, we know the player does not need to cross through these cells to reach other areas in the game.  These cells can safely be blocked off if we wanted them to be.

Beautification

Final map.

We can now use all the information we had gathered in the previous steps to generate the final map.  Here I filled in the spaces between the rooms and the dead ends with trees.  I also added a few other decorations just to make it not look so sparse.

And there you have it — an intersting procedurally generated map ready to be explored.

Alien Game Prototype

For one of the Ludum Dare mini competitions a few months back I started hacking together a simple arcade style game.  The human race is being attacked an eaten by a vicious alien species.  You play the role of a benevolent alien who comes to the rescue of the helpless humans.

Originally the only defence the hero had against the invading aliens was going to be a tractor beam — where you must grab and throw the aliens to get rid of them.  After showing it to the Pipe Cleaner Man he insisted that I added lasers and homing missiles, so I did.

I’m not certain what I’m going to do with this project.  As it began as a quick hack for a 48 hour competition, it is not very well designed.  It would need a considerable amount of rewriting before being able to transform it into a real game.

For the time being I think I’ll hold off before posting the actual game for download.  I would like to add at least a simple scoreboard and actually being able to win or lose before sharing it.

Random Neighborhood Generator

I was wondering how visually interesting a randomly generated neighborhood could be a made by using simple binary subdivision.  Basically the algorithm starts with a square, cuts it in half, cuts those halves in half, and so on to produce streets and plots of land.

It is in no way how a real neighborhood would be laid out, but for such simplicity I am rather satisfied with the results.  Such a system could randomly produce results that are visually interesting enough for possibly a small, simple flying or driving based game — such as having to rush a firetruck to burning homes, for example.

Here is the source code: neighborhood.py

You Can't Have Your Towlr And Eat It Too

A bunch of people at a game development competition site was putting together short confusing games they called “Towlrs.”  The intent of a Towlr is to leave the player wondering, “What exactly am I suppose to do to beat this game?”  I decided to get in on the action.

You Can’t Have Your Towlr And Eat It Too was my attempt at a Towlr.  It may be considerably easier than many of the other Towlrs, but the concept is somewhat interesting.

You can download it at the Towlr website (which includes a Windows executable), or you can go to the page I quickly thrown up on my site (Which requires Python and Pygame because I’m too lazy to copy the compiled vesion to my site.  Also, in the future I may move this to a different directory on my site, so be warned!)

The following posts will show off a few of the things I worked a little on in the past few weeks.  Most likely many of these projects will not amount to much in the future, but I thought I should share them anyway.

I’ve been meaning to write about pretty much everything I had worked on irregardless of their likeliness of completion.  Some things are simply done for fun without any real future plans for them.

I am now going to begin writing about the stuff I neglected to write about earlier.

Standard 2009 Calendar

====== January =====
Su Mo Tu We Th Fr Sa
.  .  .  .  1  2  3
4  5  6  7  8  9  10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31

Download Standard 2009 Calendar

Compressed 2009 Calendar

JAN      1111111111222222222233
1234567890123456789012345678901

Download Compressed 2009 Calendar

2009 List Calendar

JANUARY
 1 -
 2 -
 3 -
 4 -
 5 -
 6 -
 7 -
...

Download 2009 List Calendar

[edit]Corrected 2009 List Calendar so that the months have 10′s instead of 0′s.  If I wrote a script to make these instead of hand typing them this error may have been avoided![/edit]