The IGF main competition entries are up, bigger by a third than last year (which was bigger by a third than the year before apparently). Will it be bigger and badder though? Such remains to be seen, but there definitely were some that caught my eye:

7 Nights: “”7 Nights” shows that a quality AAA-style 3D first person shooter can be deployed on the web and could be created in about 7 MB.

This is also the first videogame in the world that was created and tested while on public transportation (Seattle Sound Transit Routes 545 & 577)”. Represent!

78641: “Saluton!! GZ Storm is now proudly to present – 78641 – the classic Esperanto-language adventure game now playing first time in Language English!!!”

A Slow Year: “A Slow Year is a collection of four games, one for each season, about the expereince of observing things. Played on the Atari Video Computer System (aka Atari 2600), the game invites sedate observation and methodical action.

A Slow Year is a kind of videogame chapbook, a set of “game poems” that attempt to embrace maximum expressive constraint and representational condensation. The game will be available for PC and Mac in a custom Atari emulator, and for Atari as a limited edition cartridge and poetry set.”

Achron: “Achron is the first “meta-time strategy” game. It is a real-time strategy game where all players can simultaneously travel through time, change the past, preview the future, and send their forces through time to when they are needed.”

ARGH: Augmented Reality Ghost Hunter: “ARGH is an augmented reality game that lets you use your Ghost Goggles to discover ghosts in your actual environment.

Players collect different ghosts located in physical locations all over the world. Explore the REAL WORLD and experiment with the time of day and time of year to discover the phantoms that share our space.”

Good lord I’m not even out of the a’s.

edit: Too bad, no parser IF this year. Looks like a few games you could call IF though.

I have only two weeks to play the games. Luckily there’s just 24 this year. Instead of posting here I think I’ll keep everything at the Intfiction forums.

MiniBoa, a minimal Python socket and telnet package

Jim Storch, author of the in development BogBoa, has kindly packaged his socket and telnet modules into a minimal, Python, single-threaded asynchronous telnet server called MiniBoa (think SocketMUD), much to my own delight! The cool thing is, as far as I’ve found, MiniBoa is the first such package to be made available in Python. Up to now your choices were to strip out something from an existing codebase, or use something like Twisted — which is great, but for learning purposes not the best for people like me. Not only is this a good learning tool but if you want to start writing a mud in Python for fun this is a great solution for the networking side.

Maiden Desmodus

For the last few weeks I’ve been playing Maiden Desmodus with my first character — the first time in a couple years probably that I’ve done more than just login to a mud to chat or check a place out. As I’ve found MD suits my casual drop-in play very well, aided in no small part by its Flash client, but also by the somewhat episodic nature of the gameplay. Every other day or so I can drop in and complete a task (a quest in other words, usually a fetch or kill task but sometimes something more involved). Skill progression is time-based on a decreasing power curve so this also encourages playing at the front of the curve if you don’t have a lot of time (or money, as MD allows you to buy skill progression blessings). Anyway, my physician is level 5!

The game itself is quite fun, and as a pleasant surprise does most of the things that I personally like in a mud. The world is well done and not filled with generic races or silly fantasy names. Its setting is a refreshing mix of dark medievalish fantasy and more Elizabethan to Victorian era stuff (quite a broad cut I know but I like that sort of thing). The skill and guild system is interesting, and the combat is on the shorter and less spammy side thank God. The players also seem to be a good group on the whole. So while I don’t see myself putting a whole lot of time or money into the game right now (maybe if I had started playing ten years ago), it’s definitely worth it to keep playing my character (give Caturige a shout if you see him!).

Up to now message handling (what gets printed to the message log) was just adding a message string to the log wherever something in the code warranted it. This was simple at first, but required checks to make sure a monster wasn’t initiating a message (like ‘you can’t go that way’ — seemed like a bug until I understood what was going on!).

So I’ve taken the next step to something a little more involved. Here’s what the message class looks like now;

class Log(object):
    def __init__(self):
        self.history = ["Go!"]
        self.cursor = 0

    def add(self, message, enactor, *string):
        for handler in enactor.handlers:
            if isinstance(enactor.handlers[handler], Messages):
                script = enactor.handlers[handler].script

                if message in script:
                    if string:
                        self.history.append(script[message] % string)
                    else:
                        self.history.append(script[message])
                    self.cursor += 1

            break

    def set_cursor(self, line_number):
        self.cursor = line_number

Adding a message now requires the message (which isn’t the message itself as I’ll explain), the enactor who initiated it, and an optional string to pass into the message. Using this method looks like this:

game.log.add("got something", enactor, target.name)

You can see that before anything gets added to the log I check if there’s a handler in the enactor’s handlers that is of type Messages. This class is a parent class that doesn’t really do anything, but allows me to subclass off it with handlers that actually do something — namely, add scripts to the enactor. For example:

class Messages(object):
    def __init__(self):
        self.script = {}

class PlayerMessages(Messages):
    def __init__(self, gid):
        self.gid = gid
        self.script = {
                        "move failed"       : "You can't go that way.",
                        "opened something"  : "You opened the %s",
                        "closed something"  : "You closed the %s",
                        "command not found" : "Try again!",
                        "got something"     : "You get the %s",
                        "used inventory item" : "You used inventory item %s"}

    def update(self):
        pass

By checking for an instance of Messages I can create many different message subclasses with different scripts, and attach these to actors depending on what messages I want them to have. Once the add method finds a Messages subclass, it checks if the message is in the script, and if so adds it to the log — with another check if the optional string was passed in as an argument or not.

This should get more interesting once I have messages for other actors — I can customize a standard message for each script.

I think I can extend this to be able to attach multiple scripts to the same actor — I’ll have to change the conditional check in the add method to create a list of handlers that are Messages subclasses, and then run through each handler’s script to find if a particular message is in there. There could be a problem though if I attach two subclasses that have the same type of message in their scripts — I’ll probably just have to add the first one that matches if that case arises.

Also I’ve been playing around with the UI some more.

I dropped the idea of the alt key + a number as a secondary use for inventory items — I’ll probably have enough to do just adding single uses for items! I also mocked up a pane selection scheme, where the tab key cycles through each pane and highlights it (the inventory pane is highlighted in that screenshot). When you highlight a pane you’ll get some additional functionality — scrolling through the message log, examining inventory items, examining things in the viewport, and scrolling through the journal pane (the pane to the right).

Usually it’s for a good reason, to fix something I did earlier for no reason, or maybe for a bad reason that I didn’t understand at the time.

Up to now I’ve been passing objects around by referring to the object itself (I guess this is passing by reference? I think this is what Python does by default). However when you save the game state with yaml (and perhaps with the pickle module too, though I haven’t investigated this), it saves every reference as the actual object data. For example, if you had an attribute on every thing that referenced a map object, that whole map object including its map array would be saved once for each thing.

That in itself wasn’t a problem, as you can clear data that you don’t need to save in your saving routine before you exit the game. However my future plans for the game include a lot of cross-referencing between objects, and I do want to be able to save that state without saving the same object data over and over.

So now instead of passing objects around by reference, each object has a unique game id (the gid). This gets created in a thing’s __init__ method like so:

class Thing(object):
    def __init__(self, name, x, y, properties, *handlers):
        self.gid = id(self)
        while self.gid in game.gids:
            self.gid = self.gid + 1
        game.gids[self.gid] = self

The reason for the while loop is if I create a thing after a game has been saved and reloaded, there is a slim chance that a new gid could match an old gid (as I’m just using Python’s id() function to create the number). If that does happen, I create a new gid until I have a unique one.

Of course this is not as simple as what I was doing before (though saving is actually a little simpler, as I just save a single dictionary of gids and re-use it when I load it back in). Every time I want to look up a thing’s properties I need to look up the thing’s object first in the gids dictionary. Nevertheless I think it’ll pay off in the long run.

Things are getting to the point where this is less of a demo and more of what I want to do in the game itself. I may or may not write a more complete tutorial based on the demo — I think there’s more than enough here for people to get familiar and get started with libtcod in general.

I’ve put in a rudimentary message log in the bottom pane of the display. That skull on the right is from the libtcod package — I’m thinking about using the right-hand pane to display images like character portraits, text of signs, books, conversations maybe? The top pane will contain game information views, like inventory and so on.

The command set right now is very simple — bump to open things (I’ll extend this to mean operate something that isn’t otherwise openable), press x to pick things up. Control + direction closes things (or will turn something ‘off’). Control by itself will act on a thing in the same cell as you. I still mean to work in throwing things, and using things in inventory, but I’m going to keep the command set simple. I’d like to use ‘z’ for taking an action with something in hand, but allow using anything in inventory (which will be limited) by selecting its inventory number (I think this is what Chickhack does if I remember correctly, I liked it at the time). Control + z then could be used as an undo/rewind, but that’s so far off I’m not really thinking about it at the moment.

I’m going back and forth right now about extending this command set and keeping it simple. I’m leaning toward keeping it simple, both as a creative constraint and to keep the project size small. The one thing that bugs me about this is I’d like multiple uses of things (for example, you have a potion you could either drink or throw at something). I may have to accept single-use items if I keep the command set limited. One possibility to open options up a bit is to use inventory-keys for an item’s primary use (so hitting ‘1′ and then ‘enter’ drinks the potion if that’s inventory item #1) and pressing ‘1′ then ‘z’ does an item’s secondary action, which could be throw. In the end I may save multiple-uses for another project…I don’t want things to get too convoluted.

update: don’t want it too convoluted?…where’s the fun in that? I’ve started trying something I think could work — using number keys for primary use of the item, and Alt + number for the secondary use. I may be able then to hijack Alt + x as a drop key if I ever want one.

I don’t write much about muds anymore as I haven’t been playing muds. Nearly all of them are far less suited to casual play that I would like. Nevertheless I still read the various forums, and right now there’s a long thread over at Mudbytes about a new moderation system the admins there are considering implementing. Read on if you’re curious, but fair warning that this may be interesting only to a very few people.

If you don’t follow muds, there are three main sites with forums: The Mud Connector, Top Mud Sites, and Mudbytes. Mudbytes is a relative newcomer, in some sense taking the role that MudMagic used to fill (a site which is now closed), indeed, as is often the case with community sites, it got its start partly due to people leaving MudMagic. All things considered I’d say that Mudbytes is the most vibrant discussion forum currently going. Particularly in the last few months it seems to have gained some new members, and while in my opinion it used to be focused on DIKU-derived codebases, lately it’s seen a more interesting range of discussion from programming to design.

All of this is a long preamble of context to frame why I’m posting this. I would have posted in the thread linked above but I felt it wouldn’t have served much purpose really, and what I’m trying to do here is get some thoughts out there to figure something out. For the record my nick on Mudbytes is Idealiad.

So what the Mudbytes admin are proposing is a system of moderation with a dedicated forum to contain ‘moderation threads’ — basically reference threads created when any disciplinary action takes place. The basic idea is to create a transparent system so that threads aren’t derailed with moderation disputes, and make it easier to reference moderation actions without digging up threads all over the forum. Also new moderators would be put in place to do the actual work of modding. The idea for this is derived from another forum with a similar system.

This is all in response to some recent issues with people getting suspensions and threads getting locked over some troll threads and responses that apparently are against various Mudbytes rules. People were crying foul over what they saw as heavy-handed moderation and wanted more transparency and accountability in how the modding went down.

So the proposal thread has developed in an interesting way. First of all my response was against the idea of a moderation sub-forum, but for the idea of new mods. My main beef with the separate sub-forum is that I think it creates an atmosphere of antagonism rather than cooperation. I’ll try to explain my reasons for thinking that.

I think the ‘community energy’ of a site is relatively fixed. How the community chooses to spend that energy influences the tone and direction of the site, how its members will treat each other and how new members will integrate into the established community. So when the community spends its energy in creating an infrastructure to deal with infractions, it is taking away energy from other things.

I have to admit my main influence on this thinking is the time I spend on TIGSource. TIGS is not without moderation of course. People there have been banned and threads locked. In general though, I get the sense that the atmosphere of TIGS is much, much different than that of Mudbytes (to be fair it’s also a much larger site, and so personal disputes don’t tend to involve the whole community like they do at Mudbytes, so their impact is somewhat diluted in the grand scheme of things). In essence TIGS spends its community energy on, for lack of a better word, ‘positive infrastructure’. An effort is made to keep things moving in a positive direction. When people trend the other way there is an effort by others to steer the ship to its original course.

As a result of this comparison, I got frustrated with Mudbytes. What I’d like to see is a similar focus on positive infrastructure, and less on what is in effect an infrastructure for litigation.

What could be the reasons for this difference? My first thought was that it has to do with the nature of mudding itself. Muds are games that primarily are social spaces. Unlike the majority of games on TIGS, a mud is in itself a social space. You certainly can have a community based around a game on TIGS, but this idea of a social space is quite different. There is a long tradition of large hierarchies running muds, with all the rules, sometimes formal and sometimes informal, you would expect in any community. By their nature then, mudders are used to all sorts of frameworks for maintaining this social space, and these frameworks are going to mirror what we see in society at large — judicial and political systems — and when the time comes to moderate another social space which they are a member of, like Mudbytes, they’re going to turn to these same rules and frameworks as the tools they’re comfortable with.

It’s not surprising then that in that Mudbytes thread people are not really arguing about the need for such a system of moderation (with one or two exceptions), but instead debating what seems to me more and more elaborate systems of moderation and their finer points of implementation. In essence the die already is cast.

The thing here though is that I think people like this. Whether there is a sub-forum for moderation or not it doesn’t really matter — the community at Mudbytes already is oriented toward this way of being. They like going back and forth over who’s trolling who, what should be modded or shouldn’t, and all the finer political points in between, and will continue to do so no matter what kind of system is set up. It’s kind of like people who go for student government or model UN. In that case a system with more transparency is probably better than a system with less, don’t you think?

So in the end I guess I have to accept this community for what it is if I want to participate in it. I don’t know if it’s possible for it to be different, more like TIGS or something like it. In effect its social space already is dictated by the social habits of the mudders themselves, and I don’t see in the near future those habits changing very much at all.

I haven’t really spent much time yet figuring out what a thing from the Thing class is, so far defining it as an object with a name, speed, position, and maybe a handler for field-of-view or dumb AI. Furthermore the character used to represent it on screen simply was based on its name. Since I knew I wanted to better define a Thing and start figuring out how I want to represent it visually, I’ve started hacking on Thing.

First of all Thing’s parameters have changed. The __init__ now looks like this:

class Thing(object):
    def __init__(self, name, x, y, properties, *handlers):
        self.name = name
        self.x = x
        self.y = y
        self.properties = properties
        self.handlers = {}
        if not None in handlers:
            for string in handlers:
                handler = eval(string)
                self.handlers[string] = handler(self)

        self.things = []
        self.stage = None

        self.char_type = self.get_char_type()

As you can see I got rid of the speed parameter, which is now included in properties. A thing therefore looks like this in its yaml definition file:

- iron-barred window
- 35
- 12
- speed : normal
  kind :
  - window
  state :
  - none
-

That definition gives the thing’s name, x, and y attributes. The next item in the list is a dictionary containing the keys speed, kind, and state. This dictionary is passed into a new instance of a thing as properties. The last blank list item is handlers.

It’s all very provisional right now as I figure out how to define a thing. But here’s a closer look at the last statement in __init__, self.char_type = self.get_char_type().

Here’s that function:

 def get_char_type(self):
        name = ''
        if self.name in player.ui.char_types:
            name = self.name
        else:
            name_tokens = self.name.split(' ')
            for token in name_tokens:
                if token in player.ui.char_types:
                    name = token

        if not len(name):
            for kind in self.properties['kind']:
                if kind in player.ui.char_types:
                    name = kind

        for state in self.properties['state']:
            state_modifying_name = ' '.join([state, name])
            if state_modifying_name in player.ui.chars:
                return state_modifying_name
            if len(name):
                return name
            else:
                return 'unknown'

What I’m trying to do is find the visual symbol for a thing (its char_type) based on its name, kind, and state (if any). This is of course not very straightforward and I may have to choose a different method. Whenever a thing’s state changes, its symbol may change as well. There is also the possibility, not accounted for in this code yet, that a thing may have a combination of states that modify its name or kind producing a unique visual symbol. I think I can get this to work but it’ll require some experimentation.

In the meantime I’ll explain how this works. The player.ui.char_types list looks like this:

        self.char_types = ['player', 'unknown', 'ground', 'wall', 'window', \
        'lamp', 'knife', 'door', 'portal']

So the first thing the get_char_type function asks is if the thing’s self.name is in that list; if so, it assigns it to the local variable name, previously set to an empty string allowing it to be referenced later in the function. If the thing’s self.name is not in the list we break up the name into its tokens (parts), and if one of those are in the list, we assign that to name. Keep in mind that name may still be empty at this point.

Next, if name is empty, we see if the thing’s kind is in the list of char_types, and if so, assign that to name.

Finally we combine whatever state the thing might have with its name, and check if that’s in the list. This takes care of things like ‘closed door’. If there’s a match we return it. If not, we see if name is non-empty (there was a successful match earlier) and return that. Lastly if name is still empty, it’s not in the list of char_types and so we call it ‘unknown’, which gets the question mark symbol when drawn to the screen.

Some notes after the cut on how to find symbols for combination of states.

I’m imagining things like an object that’s an ‘open broken door’. (perhaps this door can’t then be closed and/or locked). I would have to find this symbol (if I do indeed try to represent this with a unique symbol) in the dictionary of ui.chars when I draw it to the screen. Given the code above this isn’t going to happen, as it only searches for individual states, not a combination — how then could I find the right symbol?

First of all it seems like I don’t want to depend on an exact match, as I would have to reorder every combination of words in the string — i.e., ‘broken open door’ and ‘open broken door’. What I really want to do is compare the list of states + name (‘open broken door’) with the ‘list’ of the key (a string, really) into ui.chars (for example, say the key actually is the string ‘broken open door’).

If I convert the string to a list by splitting on the space (string.split(‘ ‘)), then find the difference of the two sets like this:

difference = set.difference(set(a), set(b))

If the two strings in any order are different from each other, difference will be non-empty.

This alone doesn’t solve the problem where a thing has multiple states and only one of them in combination with its name matches a key in ui.chars. For example, if a door has the states ‘open’ and ‘pickled’. If the key is ‘open door’, ‘open pickled door’ won’t match it using a difference of sets. But maybe ‘pickled’ isn’t applicable to the visual symbol for the door at all, and it should match as ‘open door’.

One possible preliminary test is to create a list of states + name, then check if each word of a key’s string is in this list. If so, this should match if the states + name in its entirety doesn’t match any other key. For example:

list = thing.properties['state'] + [name]

for key in player.ui.chars.keys():
    key_list = key.split(' ')
    for item in key_list:
        if item in list:
            print 'match'
....
#etcetera

Perhaps more trouble than its worth. For certain effects/states I’m going to want to just color the character anyway, rather than having a separate symbol for every combination of thing and its state. Still, this could work well for updating a thing’s symbol on a dynamic basis as states change. Have to try it out and see.

I’ve been thinking for a while about something like a drawing tool for writers…something like Alchemy that I would write in Python, maybe using pyglet. I’ve always wanted to make tools as well as make games, but they seemed beyond my capabilities somewhat…I have some specific UI ideas I’d like to try in the software flesh (mainly — bigger text for godsake, though it may turn the tool into one only I would use). A couple of new developments inch me closer to my goal. It’s beginning to look like Nick Montfort’s nn, now known as Curveship, will have a release later this year. And then over at MudBytes in a thread where someone asked for help naming a mud framework/IDE written in Python, I thought of the name pystil. So…a narrative/text generation player/maker? Who knows.

A few days ago I got to the point where I wanted to add switching levels and a get command. Adding the get command led me to consider how I would represent inventory in the code, and I thought simple, every thing has a list of things it holds.

The new code is after the jump, but first some explanation.

My thought was that a level is simply a thing that holds the things inside it. OK, I was thinking this is good, because I had wanted to have different kinds of levels in the game, like airships, giant woolly mammoths and so forth, and this would potentially make it straightforward to have a giant woolly mammoth walking around that the player could jump on and explore. So I decided a level would be a kind of handler that gets attached to a thing and adds the functionality of a map.

As you can tell I’m not too concerned with representing scale at this point — I don’t think I will be at any point really, this is a game after all. Regardless, I decided to call a level handler a Stage.

You can see in previous postings of the demo that I managed the map in a single World object. So I needed to do some heavy rewriting, and this led me to reconsider the handler/thing structure altogether. As a result I threw out the Brain class and now add handlers directly to a Thing. I think this is simpler overall.

At one point I got sidetracked by the magic of Python’s __getattr__. This is an attribute on every object, that’s executed when the interpreter doesn’t find the attribute it’s looking for as a result of a call on a property or function. So I was doing things like calling thing.foo where foo was actually an attribute on a handler, not the thing itself. However this proved to be more trouble than it was worth (since, as far as I could tell, __getattr__ expects you to return a value when called, and I decided this was too much hassle). The easier solution for me was to rewrite things so that wherever I call an attribute of a handler, I access it through a dictionary of handlers on the thing, like this:

            cells = stage.handlers['Stage'].cells_get(self.thing, self.fov_radius)

A little verbose, but easier in the end, and maybe clearer overall.

Saving the game now means saving the stages in a game. I’ll need to revise this in the future to account for stages within stages though. Switching stages means removing the thing from its current stage and adding it to the new stage. By keeping track of the player’s current stage I know what to draw to the screen. Currently I only update things in the player’s stage, so this will need to be changed in the future so time doesn’t freeze on a stage when the player leaves it. And finally, getting and dropping things means removing and adding the thing to the things that are getting it or receiving it.

There’s a crude inventory display in the upper part of the UI at the moment, but there’s only one thing to get.

Things are now kept in a file by stage, which is named like stage_name.things, and the maps are in stage_name.map.

addendum: With all this talk of stages, it may seem as if something is being left out — namely procedural generation of levels! And for the moment this is true, but as I think I’ve mentioned before I’m not going to focus on generating levels until I have a better idea of what I want the game to be. So for now I’m sticking with hardcoded content to give me a base to test on.

#!/usr/bin/python

'''
libtcod OO python tutorial
This code modifies samples_py.py from libtcod 1.4.1. It shows a '@'
walking around a scrolling map with a source of light giving simple FOV.
It's in the public domain.
'''

#############################################
# imports
#############################################

import os
import random
import yaml
import cProfile
import libtcod.libtcodpy as libtcod

#############################################
# profile
#############################################

PROFILER = cProfile.Profile()

#############################################
# constants
#############################################

PROFILE = False
SAVING = True

#############################################
# thing
#############################################

class Thing(object):
    def __init__(self, name, x, y, speed, properties, *handlers):
        self.name = name
        self.x = x
        self.y = y
        self.speed = speed
        self.properties = properties
        self.handlers = {}
        if not None in handlers:
            for string in handlers:
                handler = eval(string)
                self.handlers[string] = handler(self)

        self.things = []
        self.stage = None

    def set_position(self, dx, dy):
        self.x = self.x + dx
        self.y = self.y + dy

    def set_name(self, name):
        self.name = name

#############################################
# handlers
#############################################

class Stage(object):
    def __init__(self, thing):
        self.thing = thing
        self.cell_types = {
                            ' ' : ['ground', 'transparent', 'walkable'],
                            '#' : ['wall']}
        self.width = None
        self.height = None
        self.state = []

        name = self.thing.name + '.map'
        self.load(name)

    def load(self, name):
        file = open(name, 'r')
        for line in file:
            line = line.strip(' \n')
            line_data = []
            for cell in line:
                line_data.append(self.cell_types[cell])
            self.state.append(line_data)

        self.width = len(self.state[0])
        self.height = len(self.state)

        file.close()

    def update(self):
        pass

    def cells_get(self, thing=None, radius=None):
        cells = []

        r = 0
        if radius:
            r = radius

        y_start = 0
        x_start = 0
        y_end = self.height
        x_end = self.width
        if thing:
            y_start = max(thing.y - r, 0)
            x_start = max(thing.x - r, 0)
            y_end = min(self.height, thing.y + r + 1)
            x_end = min(self.width, thing.x + r + 1)

        for y in range(y_start, y_end):
            for x in range(x_start, x_end):
                cells.append((x, y))

        return cells

    def cell_has_monster(self, x, y):
        for thing in self.thing.things:
            if (thing.x, thing.y) == (x, y) and (thing.name == 'monster' or thing.name == 'player'):
                return True

    def cell_is_unwalkable(self, x, y):
        if not 'walkable' in self.state[y][x]:
            return True

    def cell_has_closed_door(self, x, y):
        for thing in self.thing.things:
            if (thing.x, thing.y) == (x, y) and thing.name == 'closed door':
                return True

    def cell_type_get(self, x, y):
        return self.state[y][x][0]

    def cell_add_property(self, x, y, property):
        self.state[y][x] = self.state[y][x] + [property]

#############################################
# do things
#############################################

class Fov(object):
    def __init__(self, thing):
        self.thing = thing

        self.fov_map = None
        self.fov_radius = 2
        self.fov_map_to_world_coordinates = []

    def update(self):
        stage = self.thing.stage

        if stage == player.thing.stage:
            self.fov_map_to_world_coordinates = []
            cells = stage.handlers['Stage'].cells_get(self.thing, self.fov_radius)
            cell_first = cells[0]
            cell_last = cells[len(cells)-1]

            difference_right = cell_last[0] - self.thing.x
            difference_bottom = cell_last[1] - self.thing.y
            difference_left = self.thing.x - cell_first[0]
            difference_top = self.thing.y - cell_first[1]

            fov_map_size_x = difference_right + difference_left + 1
            fov_map_size_y = difference_bottom + difference_top + 1

            self.fov_map = libtcod.map_new(fov_map_size_x, fov_map_size_y)

            for i in range(len(cells)):
                x, y = cells[i]
                fov_map_x = i % fov_map_size_x
                fov_map_y = i // fov_map_size_x
                cell = stage.handlers['Stage'].state[y][x]
                if 'walkable' in cell and 'transparent' in cell:
                    libtcod.map_set_properties(self.fov_map, fov_map_x, fov_map_y, True, True)
                elif 'walkable' in cell:
                    libtcod.map_set_properties(self.fov_map, fov_map_x, fov_map_y, False, True)
                elif 'transparent' in cell:
                    libtcod.map_set_properties(self.fov_map, fov_map_x, fov_map_y, True, False)

                for thing in self.thing.stage.things:
                    if thing.name == 'window' and (x, y) == (thing.x, thing.y):
                        libtcod.map_set_properties(self.fov_map, fov_map_x, fov_map_y, True, False)

                    if thing.name == 'closed door' and (x, y) == (thing.x, thing.y):
                        libtcod.map_set_properties(self.fov_map, fov_map_x, fov_map_y, False, False)

                if (x, y) == (self.thing.x, self.thing.y):
                    fov_x_focus = fov_map_x
                    fov_y_focus = fov_map_y

                self.fov_map_to_world_coordinates.append(((fov_map_x, fov_map_y), (x, y)))

            libtcod.map_compute_fov(self.fov_map, fov_x_focus, fov_y_focus, self.fov_radius, True)

            if self.thing.name == 'player':
                for i in range(len(cells)):
                    x, y = cells[i]
                    fov_map_x = i % fov_map_size_x
                    fov_map_y = i // fov_map_size_x
                    cell = stage.handlers['Stage'].state[y][x]
                    if (libtcod.map_is_in_fov(self.fov_map, fov_map_x, fov_map_y) and
                        not 'discovered' in stage.handlers['Stage'].state[y][x]):
                        stage.handlers['Stage'].cell_add_property(x, y, 'discovered')

class AI(object):
    def __init__(self, thing):
        self.thing = thing
        self.choices = ['north', 'south', 'west', 'east']

    def update(self):
        if self.thing.stage == player.thing.stage:
            choice = random.randint(0, 3)
            command_name = self.choices[choice]
            game.command.do(command_name, self.thing)

#############################################
# player
#############################################

class Awesome(object):
    def __init__(self):
        self.ui = UI()
        self.view = View()
        self.input = Input()
        self.name = ''
        self.thing = None

    def create(self, stage):
        self.thing = Thing('player', 26, 15, 'normal', '', 'Fov')
        stage.things.append(self.thing)
        self.thing.stage = stage
        self.thing.handlers['Fov'].fov_radius = 5

class UI(object):
    def __init__(self):
        self.width = 55
        self.height = 30
        self.state = self.splash

        self.dialog = libtcod.console_new(30, 10)
        libtcod.console_set_background_color(self.dialog, libtcod.light_grey)
        libtcod.console_set_foreground_color(self.dialog, libtcod.black)
        libtcod.console_clear(self.dialog)

        self.top = libtcod.console_new(53, 3)
        libtcod.console_set_background_color(self.top, libtcod.light_grey)
        libtcod.console_set_foreground_color(self.top, libtcod.white)
        libtcod.console_clear(self.top)

        self.bottom = libtcod.console_new(53, 3)
        libtcod.console_set_background_color(self.bottom, libtcod.light_grey)
        libtcod.console_set_foreground_color(self.bottom, libtcod.white)
        libtcod.console_clear(self.bottom)

        self.right = libtcod.console_new(21, 20)
        libtcod.console_set_background_color(self.right, libtcod.grey)
        libtcod.console_set_foreground_color(self.right, libtcod.white)
        libtcod.console_clear(self.right)

        self.main_menu_options = ['new game', 'load saved game']
        self.main_menu_cursor = 0
        self.load_game_selected = ''
        self.load_game_cursor = 0
        self.save_games = []

        self.chars = {
                        'player'    : '@',
                        'monster'   : '?',
                        'ground'    : ' ',
                        'wall'      : '#',
                        'window'    : libtcod.CHAR_DHLINE,
                        'lamp'      : 'l',
                        'knife'     : 'k',
                        'open door' : '-',
                        'closed door'   : '+',
                        'portal'    : 'O'}

        self.cell_colors = {
                            'wall' : libtcod.Color(67, 65, 52),
                            'ground' : libtcod.Color(145, 140, 140),
                            'dark': libtcod.Color(1, 1, 1),
                            'lit': libtcod.Color(255, 255, 33),
                            'visible': libtcod.Color(254, 254, 233),
                            'discovered': libtcod.Color(50, 50, 100)}    

        font = os.path.join('fonts', 'arial12x12.png')
        libtcod.console_set_custom_font(
                                        font,
                                        libtcod.FONT_LAYOUT_TCOD |
                                        libtcod.FONT_TYPE_GREYSCALE,
                                        32,
                                         

        libtcod.console_init_root(
                                    self.width,
                                    self.height,
                                    'Python Demo',
                                    False)
        libtcod.console_set_background_color(0, libtcod.dark_grey)
        libtcod.mouse_show_cursor(False)
        libtcod.console_credits()

        self.states = {
                        'splash'    : self.splash,
                        'main_menu' : self.main_menu,
                        'new_game'  : self.new_game,
                        'load_game' : self.load_game,
                        'gameplay'  : self.gameplay}

    def change_state(self, state):
        self.state = self.states[state]

    def draw(self):
        self.state()

    def splash(self):
        libtcod.console_clear(0)
        libtcod.console_set_foreground_color(0, libtcod.white)
        libtcod.console_print_center(0, self.width//2, self.height//2-4, libtcod.BKGND_NONE, "A Python Demo")
        libtcod.console_flush()

    def main_menu(self):
        libtcod.console_clear(0)
        libtcod.console_set_foreground_color(0, libtcod.white)
        libtcod.console_print_center(0, self.width//2, self.height//2-4, libtcod.BKGND_NONE, "A Python Demo")

        for i in range(len(self.main_menu_options)):
            option = self.main_menu_options[i]
            if i == self.main_menu_cursor:
                cursor = '>'
            else:
                cursor = ' '
            libtcod.console_print_left(0, 20, self.height//2+i, libtcod.BKGND_NONE, "%c%s %s%c" % (libtcod.COLCTRL_1, cursor, option, libtcod.COLCTRL_STOP))

        libtcod.console_flush()

    def new_game(self):
        libtcod.console_clear(0)
        libtcod.console_clear(self.dialog)
        libtcod.console_print_left(self.dialog, 2, 5, libtcod.BKGND_NONE, "%cTell me your name, hunter. %c" % (libtcod.COLCTRL_1, libtcod.COLCTRL_STOP))
        libtcod.console_print_center(self.dialog, 15, 8, libtcod.BKGND_NONE, "%c%s_%c" % (libtcod.COLCTRL_1, player.name, libtcod.COLCTRL_STOP))

        libtcod.console_blit(
                                self.dialog,
                                0,
                                0,
                                30,
                                10,
                                0,
                                (self.width - 30)/2,
                                10,
                                200)
        libtcod.console_flush()

    def load_game(self):
        libtcod.console_clear(0)
        libtcod.console_clear(self.dialog)
        libtcod.console_print_center(self.dialog, 15, 1, libtcod.BKGND_NONE, "%cTell me your name, hunter. %c" % (libtcod.COLCTRL_1, libtcod.COLCTRL_STOP))

        i = self.load_game_cursor
        game = self.save_games[i].split('.')[0].replace('_', ' ')

        libtcod.console_print_center(self.dialog, 15, 4, libtcod.BKGND_NONE, "%c> %s%c" % (libtcod.COLCTRL_1, game, libtcod.COLCTRL_STOP))
        libtcod.console_print_center(self.dialog, 15, 8, libtcod.BKGND_NONE, "%cup/down to select%c" % (libtcod.COLCTRL_1, libtcod.COLCTRL_STOP))

        libtcod.console_blit(
                                self.dialog,
                                0,
                                0,
                                30,
                                10,
                                0,
                                (self.width - 30)/2,
                                10,
                                200)
        libtcod.console_flush()

    def gameplay(self):
        libtcod.console_clear(0)
        libtcod.console_clear(self.right)
        libtcod.console_clear(self.top)

        libtcod.console_print_left(self.right, 1, 1, libtcod.BKGND_NONE, "HJKL move around")
        libtcod.console_print_left(self.right, 1, 4, libtcod.BKGND_NONE, "%s" % player.name)
        libtcod.console_print_left(self.right, 1, 5, libtcod.BKGND_NONE, "in %s" % player.thing.stage.name)

        libtcod.console_print_left(self.right, 1, 7, libtcod.BKGND_NONE, "game turn: %d" % game.time.turns)
        libtcod.console_print_left(self.right, 1, 9, libtcod.BKGND_NONE, "%s" % game.message.text)

        libtcod.console_print_left(self.top, 1, 1, libtcod.BKGND_NONE, "%s" % player.thing.things)

        libtcod.console_blit(
                                player.view.screen,
                                0,
                                0,
                                player.view.width,
                                player.view.height,
                                0,
                                1,
                                5,
                                255)

        libtcod.console_blit(
                                self.top,
                                0,
                                0,
                                53,
                                3,
                                0,
                                1,
                                1,
                                255)

        libtcod.console_blit(
                                self.bottom,
                                0,
                                0,
                                53,
                                3,
                                0,
                                1,
                                26,
                                255)

        libtcod.console_blit(
                                self.right,
                                0,
                                0,
                                21,
                                20,
                                0,
                                33,
                                5,
                                255)
        libtcod.console_flush()

class View(object):
    def __init__(self):
        self.width = 30
        self.height = 20
        self.anchor_x = None
        self.anchor_y = None
        self.screen = libtcod.console_new(self.width, self.height)
        libtcod.console_set_foreground_color(self.screen, libtcod.black)

    def update(self):
        stage = player.thing.stage.handlers['Stage']

        libtcod.console_clear(self.screen)

        self.anchor_x = min(max(0, player.thing.x - self.width//2), stage.width - self.width)
        self.anchor_y = min(max(0, player.thing.y - self.height//2), stage.height - self.height)

        viewport = []
        for j in range(self.height):
            line = []
            for i in range(self.width):
                x, y = self.viewport_ij_to_world_xy(i, j)
                cell = {
                        'light'   : 0,
                        'char'    : ' ',
                        'fov'     : [],
                        'cell_type'     : stage.cell_type_get(x, y),
                        'discovered'    : 0,
                        'scalar'        : 1}

                if 'discovered' in stage.state[y][x]:
                    cell['discovered'] = 1

                line.append(cell)
            viewport.append(line)

        maps = []
        for thing in player.thing.stage.things:
            if 'Fov' in thing.handlers:
                maps.append((thing, thing.handlers['Fov'].fov_map, thing.handlers['Fov'].fov_map_to_world_coordinates))

        for tuple in maps:
            thing, fov_map, fov_map_to_world_coordinates = tuple
            for cell in fov_map_to_world_coordinates:
                x, y = cell[1][0], cell[1][1]

                if self.xy_in_viewport(x, y):
                    fov_map_x, fov_map_y = cell[0][0], cell[0][1]
                    i, j = self.world_xy_to_viewport_ij(x, y)

                    distance_squared = max(1, (x - thing.x) * (x - thing.x) + (y - thing.y) * (y - thing.y))
                    fov_radius_squared = thing.handlers['Fov'].fov_radius * thing.handlers['Fov'].fov_radius
                    scalar = (fov_radius_squared - distance_squared * 1.0)/fov_radius_squared

                    if libtcod.map_is_in_fov(fov_map, fov_map_x, fov_map_y):
                        viewport[j][i]['fov'].append(thing.name)

                        if thing.name == 'lamp':
                            viewport[j][i]['light'] = max(.5, scalar)

                        if thing.name == 'player':
                            viewport[j][i]['scalar'] = max(.5, scalar)

        for j in range(self.height):
            for i in range(self.width):
                cell = viewport[j][i]
                affect = 'dark'
                cell_type = cell['cell_type']
                if 'player' in cell['fov']:
                    if cell['light'] == 0:
                        affect = 'visible'
                    else:
                        affect = 'lit'

                        if cell_type == 'wall':
                            n = max(0, j-1)
                            e = min(self.width-1, i+1)
                            s = min(self.height-1, j+1)
                            w = max(0, i-1)
                            cells = [
                                        viewport[n][w],
                                        viewport[n][i],
                                        viewport[n][e],
                                        viewport[j][w],
                                        viewport[j][e],
                                        viewport[s][w],
                                        viewport[s][i],
                                        viewport[s][e]]
                            for adjacent_cell in cells:
                                if not 'player' in adjacent_cell['fov'] and adjacent_cell['cell_type'] == 'ground' and adjacent_cell['light'] > 0:
                                    affect = 'visible'
                                    break
                        else:
                            cell['scalar'] = cell['light']

                elif cell['discovered'] > 0:
                    affect = 'discovered'

                if 'player' in cell['fov']:
                    affect_color = player.ui.cell_colors[affect] * cell['scalar']
                else:
                    affect_color = player.ui.cell_colors[affect]
                cell_type_color = player.ui.cell_colors[cell_type]
                color = affect_color * cell_type_color
                char = cell['char']
                libtcod.console_set_back(self.screen, i, j, color, libtcod.BKGND_SET)
                libtcod.console_put_char(self.screen, i, j, char, libtcod.BKGND_NONE)                        

        for thing in player.thing.stage.things:
            i, j = self.world_xy_to_viewport_ij(thing.x, thing.y)
            if self.xy_in_viewport(thing.x, thing.y) and 'player' in viewport[j][i]['fov']:
                libtcod.console_put_char(self.screen, i, j, player.ui.chars[thing.name], libtcod.BKGND_NONE)

    def world_xy_to_viewport_ij(self, x, y):
        i = x - self.anchor_x
        j = y - self.anchor_y
        return (i, j)

    def viewport_ij_to_world_xy(self, i, j):
        x = i + self.anchor_x
        y = j + self.anchor_y
        return (x, y)

    def xy_in_viewport(self, x, y):
        if (self.anchor_x <= x < self.anchor_x+self.width and
            self.anchor_y <= y < self.anchor_y+self.height):
                return True

class Input(object):
    def __init__(self):
        self.state = self.splash

        file = open('keys.cfg', 'r')
        self.keycfg = yaml.load(file)

        self._keys = {
                        'k' : 'k',
                        'j' : 'j',
                        'h' : 'h',
                        'l' : 'l',
                        'p' : 'p',
                        libtcod.KEY_UP : 'up arrow',
                        libtcod.KEY_RIGHT : 'right arrow',
                        libtcod.KEY_LEFT : 'left arrow',
                        libtcod.KEY_DOWN : 'down arrow',
                        libtcod.KEY_KP8 : 'keypad 8',
                        libtcod.KEY_KP6 : 'keypad 6',
                        libtcod.KEY_KP4 : 'keypad 4',
                        libtcod.KEY_KP2 : 'keypad 2',
                        'x' : 'x',
                        libtcod.KEY_SPACE : 'space bar'}

        self.ctrl = ''

        self.states = {
                        'splash'    : self.splash,
                        'main_menu' : self.main_menu,
                        'new_game'  : self.new_game,
                        'load_game' : self.load_game,
                        'gameplay'  : self.gameplay}

    def get_key(self, key):
        if key.lctrl:
            self.ctrl = 'ctrl '
        else:
            self.ctrl = ''

        if not key.vk == 65:
            return key.vk
        else:
            return chr(key.c)

    def change_state(self, state):
        self.state = self.states[state]

    def update(self):
        self.state()

    def splash(self):
        libtcod.console_wait_for_keypress(True)

    def main_menu(self):
        self.key = libtcod.console_wait_for_keypress(True)

        if self.key.vk == libtcod.KEY_ESCAPE or libtcod.console_is_window_closed():
            game.exit = True
        elif self.key.vk == libtcod.KEY_ENTER:
            pass
        elif self.key.vk == libtcod.KEY_DOWN:
            player.ui.main_menu_cursor = min(len(player.ui.main_menu_options)-1, player.ui.main_menu_cursor+1)
        elif self.key.vk == libtcod.KEY_UP:
            player.ui.main_menu_cursor = max(0, player.ui.main_menu_cursor-1)

    def new_game(self):
        self.key = libtcod.console_wait_for_keypress(True)
        if self.key.vk == libtcod.KEY_ENTER:
            pass
        elif self.key.vk == libtcod.KEY_BACKSPACE:
            name = player.name
            player.name = name[:-1]
        elif self.key.vk in (65, libtcod.KEY_SPACE):
            player.name = player.name + chr(self.key.c)

    def load_game(self):
        self.key = libtcod.console_wait_for_keypress(True)
        if self.key.vk == libtcod.KEY_ENTER or self.key.vk == libtcod.KEY_ESCAPE:
            pass
        elif self.key.vk == libtcod.KEY_DOWN:
            player.ui.load_game_cursor = min(len(player.ui.save_games)-1, player.ui.load_game_cursor+1)
        elif self.key.vk == libtcod.KEY_UP:
            player.ui.load_game_cursor = max(0, player.ui.load_game_cursor-1)

    def gameplay(self):
        self.key = libtcod.console_wait_for_keypress(True)
        key = self.get_key(self.key)
        if key in self._keys:
            key = self._keys[key]

        while not key in self.keycfg:
            if self.key.vk == libtcod.KEY_ESCAPE or libtcod.console_is_window_closed():
                if SAVING: game.save()
                game.exit = True
                return
            game.message.text = "Try again!"
            player.ui.draw()
            self.key = libtcod.console_wait_for_keypress(True)
            key = self.get_key(self.key)
            if key in self._keys:
                key = self._keys[key]

        command_name = self.ctrl + self.keycfg[key]
        game.message.text = "Go!"

        if game.command.do(command_name, player.thing) == 'free action':
            player.view.update()
            player.ui.draw()
            self.gameplay()

#############################################
# game
#############################################
class Game(object):
    def __init__(self):
        self.message = Message()
        self.time = Time()
        self.command = Command()

        self.state = self.splash
        self.exit = False

        self.stages = []

        self.states = {
                        'splash'    : self.splash,
                        'main_menu' : self.main_menu,
                        'new_game'  : self.new_game,
                        'load_game' : self.load_game,
                        'gameplay'  : self.gameplay}

    def change_state(self, state):
        self.state = self.states[state]
        player.input.change_state(state)
        player.ui.change_state(state)

    def update(self):
        self.state()

    def splash(self):
        player.ui.draw()
        player.input.update()

        self.change_state('main_menu')

    def main_menu(self):
        if not player.ui.save_games:
            dir = os.listdir('.')
            for file in dir:
                if 'sav' in file:
                    player.ui.save_games.append(file)

        player.ui.draw()
        player.input.update()

        if player.input.key.vk == libtcod.KEY_ENTER:
            if player.ui.main_menu_options[player.ui.main_menu_cursor] == 'new game':
                self.change_state('new_game')

            elif player.ui.main_menu_options[player.ui.main_menu_cursor] == 'load saved game' and player.ui.save_games:
                self.change_state('load_game')

    def new_game(self):
        player.ui.draw()
        player.input.update()

        if player.input.key.vk == libtcod.KEY_ENTER:
            if player.ui.main_menu_options[player.ui.main_menu_cursor] == 'new game':
                things_files = []
                dir = os.listdir('.')
                for file in dir:
                    if 'things' in file:
                        things_files.append(file)

                for file in things_files:
                    new_things = []
                    file = open(file, 'r')
                    things = yaml.load_all(file)
                    for data in things:
                        thing = Thing(*data)
                        new_things.append(thing)
                    file.close()

                    _stage = None
                    for thing in new_things:
                        if 'Stage' in thing.handlers:
                            _stage = thing
                            self.stages.append(_stage)

                    for thing in new_things:
                        if not 'Stage' in thing.handlers:
                            thing.stage = _stage
                            _stage.things.append(thing)

                current_stage = None
                for stage in self.stages:
                    if stage.name == 'Cyanothus':
                        current_stage = stage

                player.create(current_stage)

                for handler in player.thing.handlers:
                    player.thing.handlers[handler].update()
                player.view.update()

                self.change_state('gameplay')

        elif player.input.key.vk == libtcod.KEY_ESCAPE:
            self.change_state('main_menu')

    def load_game(self):
        player.ui.draw()
        player.input.update()

        if player.input.key.vk == libtcod.KEY_ENTER:
            file = player.ui.save_games[player.ui.load_game_cursor]
            self.load(file)

            player.name = file.split('.')[0].replace('_', ' ')

            self.change_state('gameplay')

        elif player.input.key.vk == libtcod.KEY_ESCAPE:
            self.change_state('main_menu')

    def gameplay(self):
        if self.time.phase in self.time.phases_for[player.thing.speed]:
            player.input.update()

        if game.exit == True:
            return

        for thing in player.thing.stage.things:
            if self.time.phase in self.time.phases_for[thing.speed]:
                for handler in thing.handlers:
                    thing.handlers[handler].update()      

        self.time.tick()

        if PROFILE:
            PROFILER.runcall(player.view.update)
            PROFILER.dump_stats('profile_view_draw')
        else:
            player.view.update()

    def save(self):
        for stage in self.stages:
            for thing in stage.things:
                if 'Fov' in thing.handlers:
                    thing.handlers['Fov'].fov_map_to_world_coordinates = []
                if hasattr(thing, 'stage'):
                    thing.stage = None

        name = player.name.replace(' ', '_') + '.sav'
        file = open(name, 'w')
        yaml.dump_all(self.stages, file)
        file.close()

    def load(self, name):
        file = open(name, 'r')
        self.stages = list(yaml.load_all(file))
        file.close()

        for stage in self.stages:
            for thing in stage.things:
                if thing.name == 'player':
                    player.thing = thing

        for stage in self.stages:
            for thing in stage.things:
                thing.stage = stage

        for handler in player.thing.handlers:
            player.thing.handlers[handler].update()
        player.view.update()

class Message(object):
    def __init__(self):
        self.text = "Go!"

class Time(object):
    def __init__(self):
        self.phases = ['fast', 'normal', 'slow', 'quick', 'normal']
        self.phases_for = {
                            'fast' : ('fast', 'normal', 'slow'),
                            'normal' : ('normal', 'slow'),
                            'slow' : ('normal'),
                            'quick' : ('normal', 'slow', 'quick'),
                            'fast+quick' : ('fast', 'normal', 'slow', 'quick'),
                            'fast+slow' : ('fast', 'normal'),
                            'quick+slow' : ('quick', 'normal'),
                            'fast+quick+slow' : ('fast', 'normal', 'quick')}

        self.phase = self.phases[1]
        self.phase_count = 0
        self.turns = 0

    def tick(self):
        self.phase_count += 1
        self.phase = self.phases[self.phase_count % 5]
        if self.phase in self.phases_for['normal']: self.turns += 1

class Command(object):
    def __init__(self):
        self.playbook = {
                        'north' : ('takes turn', self.move, 0, -1),
                        'east'  : ('takes turn', self.move, 1, 0),
                        'south' : ('takes turn', self.move, 0, 1),
                        'west'  : ('takes turn', self.move, -1, 0),
                        'ctrl north'    : ('takes turn', self.ctrl, 0, -1),
                        'ctrl east'     : ('takes turn', self.ctrl, 1, 0),
                        'ctrl south'    : ('takes turn', self.ctrl, 0, 1),
                        'ctrl west'     : ('takes turn', self.ctrl, -1, 0),
                        'direct'   : ('takes turn', self.direct, None),
                        'indirect'  : ('free action', self.indirect, None),
                        'print history' : ('free action', self.print_history, None)}

        self.rulebook = {
                        'move' : ('cell has monster', 'cell is unwalkable', 'cell has closed door', 'open door implicitly'),
                        'close_door' : ('cell has closed door',),
                        'get'   : ('thing not gettable',),
                        'drop'  : ()}

        self.rules = {
                        # condition checks

                        'cell has monster' : "enactor.stage.handlers['Stage'].cell_has_monster(enactor.x+dx, enactor.y+dy)",
                        'cell is unwalkable' : "enactor.stage.handlers['Stage'].cell_is_unwalkable(enactor.x+dx, enactor.y+dy)",
                        'cell has closed door' : "enactor.stage.handlers['Stage'].cell_has_closed_door(enactor.x+dx, enactor.y+dy)",
                        'thing not gettable' : "not 'gettable' in target.properties",

                        # automatic procedures

                        'open door implicitly' : "self.open_door_implicitly(enactor.x+dx, enactor.y+dy)"}

        self.history = []

    def do(self, string, enactor):
        command = self.playbook[string]
        command_name, args = command[1], command[2:]
        command_name(enactor, *args)
        self.history.append((string, enactor.name))
        return command[0]

    def move(self, enactor, *args):
        dx, dy = args
        if True in [eval(self.rules[rule]) for rule in self.rulebook['move']]:
            pass
        else:
            enactor.set_position(dx, dy)

        target_stage_name = None
        for thing in enactor.stage.things:
            if thing.name == 'portal' and (enactor.x, enactor.y) == (thing.x, thing.y):
                target_stage_name = thing.properties.split(':')[1]

        target_stage = None
        for stage in game.stages:
            if stage.name == target_stage_name:
                target_stage = stage

        if target_stage:
            for stage in game.stages:
                if stage == target_stage:
                    stage.things.append(enactor)
                elif stage == enactor.stage:
                    stage.things.remove(enactor)
            enactor.stage = target_stage

    def ctrl(self, enactor, *args):
        dx, dy = args
        self.close_door(enactor, dx, dy)

    def direct(self, enactor, *args):
        self.get(enactor)

    def indirect(self, enactor, *args):
        self.drop(enactor)

    def get(self, enactor):
        target = False
        for thing in enactor.stage.things:
            if not enactor == thing and (enactor.x, enactor.y) == (thing.x, thing.y):
                target = thing

        if target:
            if True in [eval(self.rules[rule]) for rule in self.rulebook['get']]:
                pass
            else:
                enactor.things.append(target)
                enactor.stage.things.remove(target)

    def drop(self, enactor):
        to_remove = False
        if True in [eval(self.rules[rule]) for rule in self.rulebook['drop']]:
            pass
        else:
            for thing in player.thing.things:
                to_remove = thing
                thing.x, thing.y = player.thing.x, player.thing.y

        if to_remove:
            enactor.things.remove(to_remove)
            enactor.stage.things.insert(0, to_remove)

    def close_door(self, enactor, dx, dy):
        if True in [eval(self.rules[rule]) for rule in self.rulebook['close_door']]:
            pass
        else:
            for thing in player.thing.stage.things:
                if (enactor.x+dx, enactor.y+dy) == (thing.x, thing.y) and thing.name == 'open door':
                    thing.set_name('closed door')

    def open_door_implicitly(self, x, y):
        if player.thing.stage.handlers['Stage'].cell_has_closed_door(x, y):
            for thing in player.thing.stage.things:
                if (thing.x, thing.y) == (x, y) and thing.name == 'closed door':
                    thing.set_name('open door')

    def print_history(self, enactor, *args):
        print self.history
        print player.thing.things

#############################################
# get it started
#############################################

if __name__ == '__main__':
#     try:
#         import psyco
#         psyco.full()
#     except ImportError:
#         pass

    game = Game()
    player = Awesome()

    while not game.exit:
        game.update()
        if not game.exit:
            player.ui.draw()

Here are the yaml files for things. Note that ‘Cyanothus’ currently is hardcoded as the starting stage. Much of the stage functionality is roughly coded at this point really.

---
- 'Cyanothus'
- 0
- 0
- normal
- ''
- 'Stage'

---
- 'window'
- 35
- 12
- normal
- ''
- 

---
- 'closed door'
- 30
- 15
- normal
- ''
- 

---
- 'monster'
- 20
- 9
- normal
- ''
- 'AI'

---
- 'lamp'
- 29
- 6
- normal
- ''
- 'Fov'

---
- 'lamp'
- 41
- 6
- normal
- ''
- 'Fov'

---
- 'lamp'
- 29
- 11
- normal
- ''
- 'Fov'

---
- 'lamp'
- 41
- 11
- normal
- ''
- 'Fov'

---
- 'knife'
- 35
- 15
- normal
- 'gettable'
- 

---
- 'portal'
- 38
- 15
- normal
- 'to:Sexangulare'
-

---
- 'Sexangulare'
- 0
- 0
- normal
- ''
- 'Stage'

---
- 'portal'
- 38
- 15
- normal
- 'to:Cyanothus'
-

The maps are 80×50, and can be any combination of ‘#’ and ‘ ‘ in plain text. The location of things will have to work with the spaces on the map of course.