One last important thing I needed to add to command handling was commands that take no time — certain out-of-game actions or meta commands like switching UI views and things like that. I’m imagining that most commands will take a player’s turn but I wanted to have support for actions that don’t.

At the same time I wanted to centralize command parsing — before commands were enacted by calling the command directly which was OK but made it tedious to add things that would happen when any command was called. So here’s what I came up with — some significant changes to the Command class:

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),
                        'print history' : ('free action', self.print_history, None)}

And now commands are routed through a single function:

    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]

Which gets called like this in the player input function:

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

        if game.command.do(command_name, player.thing) == 'free action':
            self.gameplay_update()

So the command_name is created, for example ‘ctrl north’, and is sent to command.do. That gets looked up in the playbook, and the command is called with its arguments. The lookup also tells the game if the action takes a turn or not — this information is returned to the original call, and if it’s a free action the player input function is called again without a turn passing.

The ‘history’ is mostly a way to test this out. I have a vague idea of allowing playback of moves, but that’s going to require a lot of other work that’s not a priority right now.

Up to now I’ve been motoring along quite happy with my simple arrangement — a player, a monster, some lamps, field-of-view, saving and loading. In theory I’d written the code as a framework that would make it easy to add stuff, but…I hadn’t actually added any stuff yet. I knew this was an important step. Would things totally break down? How easy would it be to add stuff?

So I’ve started to add stuff. Let’s see how easy it is to add something. Trying to keep things simple, I’m starting with windows and doors.

Now I already had windows, but these were a part of the hardcoded map. I’ve decided to make them of the Thing class instead, and so the hardcoded map will strictly represent terrain (at the moment just walls and ground). To make a window a thing this is what I had to do:

• remove the window from game.world.cell_types and the hardcoded map
• add a test to Fov so that if a cell in field-of-view is a window, it’s marked as transparent in the fov map.
• add the window to player.ui.chars
• remove adding the window to the viewport structure in the view.update, as now it’ s just drawn with the other things.
• create the window thing in Game.

Adding doors followed a similar path as above (minus removing code of course as doors are totally new), but I also had to add the functionality of opening doors. So, I went to the Command class. Here is what the rulebook and rules look like now:

class Command(object):
    def __init__(self):
        self.rulebook = {
                        'move' : ('cell has monster', 'cell is unwalkable', 'cell has closed door', 'open door implicitly')}

        self.rules = {
                        'cell has monster' : 'game.world.cell_has_monster(thing.x+dx, thing.y+dy)',
                        'cell is unwalkable' : 'game.world.cell_is_unwalkable(thing.x+dx, thing.y+dy)',
                        'cell has closed door' : 'game.world.cell_has_closed_door(thing.x+dx, thing.y+dy)',
                        'open door implicitly' : 'game.world.open_door_implicitly(thing.x+dx, thing.y+dy)'}

So I added ‘cell has closed door’ and ‘open door implicitly’ (bump to open — now that I think of it I might be able to make a general ‘bump to open’ rule). Here are the corresponding methods in World.

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

    def open_door_implicitly(self, x, y):
        if self.cell_has_closed_door(x, y):
            for thing in game.world.things:
                if (thing.x, thing.y) == (x, y) and thing.name == 'closed door':
                    thing.name = 'open door'

Though I set the name directly here, I think I’ll change this later to call a method on Thing to change its name. I’m trying to keep World as a state object only, changing its state from outside this object.

In player.ui.chars I have this:

        self.chars = {
                        'player'    : '@',
                        'monster'   : '?',
                        'ground'    : ' ',
                        'wall'      : '#',
                        'window'    : libtcod.CHAR_DHLINE,
                        'lamp'      : 'Q',
                        'open door' : '/',
                        'closed door'   : '+'}

So when I change the name to ‘open door’, the symbol changes, and the movement test for a closed door will pass as well.

Overall, not too bad. I think I’m going to have to generalize the field-of-view code a bit, as I can forsee adding a lot of special cases as I add objects if I keep doing what I’m doing. So far I’m happy with how the rulebook and rules works too.

update:

To make a close doors command required a few more changes. This requires either a command then command input (like a ‘c’ key then direction) or a combination key like command + command. I’ve decided to go with the latter, and I’m using CTRL + direction. I think I like the idea of extending this in the future into a context sensitive command as well. As libtcod doesn’t currently have an easy way to test for a combined key press (I think it’s slated for 1.5) I just made a boolean in player.input like so:

class Input(object):
    def __init__(self):
        self.update_state = self.intro_update
        file = open('keys.cfg', 'r')
        self.keycfg = yaml.load(file)
        self.ctrl = 0

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

        if key.c:
            return chr(key.c)
        else:
            return key.vk

Every time I call get_key() (when a key is pressed) I check if the left control is pressed and then set the self.ctrl value accordingly. Then in Command I can do this:

    def north(self, enactor):
        if player.input.ctrl:
            self.close_door(enactor, 0, -1)
        else:
            self.move(enactor, 0, -1)  

And then add the rules and a command for close_door() like normal.

Up to now I’ve been running the demo in a rather small window (about 40×20 cells) with a small viewport (19×19). Actually I like the idea of a game this size, but with the demo I’d like to try something bigger. Since I’m scrolling I knew I might run into issues with how fast the screen redraws (as I’m redrawing the whole thing every turn).

So first I put the level in a text file and made it much bigger (it’s now about 80×50), and then I increased the window size, and the viewport size to 40×40. As I found out the game really got sluggish. Reducing the viewport to 30×30 improved things to make it playable, and so I wanted to see exactly where things were slowing down.

To start, I firmly believe in first writing without optimization in mind. Much of what I write is very verbose, using strings insteads of integers for properties and so on. I think that for what I’m doing the bottlenecks are going to come in specific cases, and it’s not really necessary to bitshift when I can just multiply integers, or whatever real programmers do, I’m sure I’m getting the terms wrong here.

As with many things Python makes it really easy to use support modules and tools, at least for basic things. So what follows here is an idiot’s guide to profiling the bottlenecks in your code.

The cProfile module is dead simple to use and in the standard library. I used it in two ways. First, from the command line, you can do this:

python -m cProfile -o nameOfYourOutputFile nameOfYourGameFile

Your output file doesn’t need to exist first. What this will do is start up your game using the cProfile module to time how many seconds are spent in each function call. When you exit your game you’ll find the output file in the game’s directory. Then you can create a simple .py script like so (this is all in the Python documentation for cProfile by the way) — let’s say your output file was called test_profile:

import pstats
p = pstats.Stats('test_profile')

p.sort_stats('time').print_stats(10)

Running this script will give you a breakdown of time spent. You can sort this output in various ways, see the docs for details.

Now what if you want to profile only one function in your code? When I ran the first script I saw that the viewport draw call was taking a significant portion of time, but the output doesn’t break down the draw function itself. All you need to do is something like this, where you call your draw function:

        PROFILER.runcall(self.view.update)
        PROFILER.dump_stats('test_profile')

Remembering at the top of your game file to import cProfile and set up the profiler like so:

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

import os
import random
import yaml
import cProfile

import libtcod.libtcodpy as libtcod

PROFILER = cProfile.Profile()

That’s it. Then you just run the pstats script above in the same way.

These are the calls that take the most time in my draw function:

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
      202    7.430    0.037   16.854    0.083 diana.py:427(draw)
   194171    1.873    0.000    4.267    0.000 C:\Documents and Settings\GO\My Documents\dev\diana\libtcod\libtcodpy.py:58(__mul__)
   194171    1.393    0.000    2.036    0.000 C:\Documents and Settings\GO\My Documents\dev\diana\libtcod\libtcodpy.py:74(int_to_col)
   182002    1.360    0.000    1.647    0.000 C:\Documents and Settings\GO\My Documents\dev\diana\libtcod\libtcodpy.py:448(console_put_char)
   181800    0.926    0.000    0.926    0.000 C:\Documents and Settings\GO\My Documents\dev\diana\libtcod\libtcodpy.py:454(console_set_back)
   194171    0.642    0.000    0.642    0.000 C:\Documents and Settings\GO\My Documents\dev\diana\libtcod\libtcodpy.py:50(__init__)
   181800    0.496    0.000    0.496    0.000 diana.py:415(viewport_ij_to_world_xy)
   181800    0.494    0.000    0.494    0.000 diana.py:117(cell_type_get)
    94940    0.390    0.000    0.390    0.000 diana.py:421(xy_in_viewport)
    83478    0.380    0.000    0.380    0.000 C:\Documents and Settings\GO\My Documents\dev\diana\libtcod\libtcodpy.py:1050(map_is_in_fov)
   194171    0.358    0.000    0.358    0.000 {isinstance}
   203134    0.345    0.000    0.345    0.000 {method 'append' of 'list' objects}
   182002    0.288    0.000    0.288    0.000 {ord}

So it looks like multiplying colors together takes a significant portion of time. I may have to look into precaching this information somehow. However there is an even easier way to speed things up, though it requires a third-party module — the Psyco module.

All you need to do to get Psyco working (after downloading and installing it) is put in your game file like this:

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

    game = Game()
    player = Awesome()

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

You can also have Psyco optimize only specific functions in your code — as it uses more memory in its overhead, this may be important for some people.

I did notice a speed improvement with Psyco, but as it’s an external dependency my first line of attack will be speeding up the routines in the draw code itself. It may be enough to keep the viewport a reasonable size, thus drawing less to the screen. Of course I haven’t added any real gameplay yet…now that can’t take much time to compute, can it?

In working on adding player memory to the map (so cells not immediatly in field-of-view but previously seen are drawn) I realized something. My scrolling/camera code looked like this:

    def scroll(self):
        self.x_offset = min(max(0, player.thing.x - self.width//2), game.world.level_width - self.width)
        self.y_offset = min(max(0, player.thing.y - self.height//2), game.world.level_height - self.height)

        self.x_left_offset = min(player.thing.x, self.width//2)
        self.x_right_offset = max(0, (self.width//2 - (game.world.level_width - player.thing.x) + (self.width % 2)))
        self.focus_x =  self.x_left_offset + self.x_right_offset

        self.y_top_offset = min(player.thing.y, self.height//2)
        self.y_bottom_offset = max(0, (self.height//2 - (game.world.level_height - player.thing.y) + (self.height % 2)))
        self.focus_y =  self.y_top_offset + self.y_bottom_offset

When it really only needs to look like this:

    def scroll_update(self):
        self.anchor_x = min(max(0, player.thing.x - self.width//2), game.world.level_width - self.width)
        self.anchor_y = min(max(0, player.thing.y - self.height//2), game.world.level_height - self.height)

The problem was I had been treating where the player was rendered as a special case — in effect putting the player and the camera focus position in the same basket. This wasn’t necessary at all — all you need to know is where the camera or view is positioned on the screen (I chose to keep track of the top left corner of the view with the variables anchor_x and anchor_y). Then you just need to translate world coordinates to view coordinates when you deal with the viewport.

I knew the previous code was too complicated. It feels good to get it into shape!

As I began in the last few days to add more things to the map with a field-of-view (starting with some lamps) it seemed like it was getting harder to work in the field-of-view structure I had. Most of this had to do with translation of world to viewport coordinates, and I realized I was calculating things in terms of viewport coordinates in the field-of-view code. Conceptually this seemed a little strange — I decided to keep all game calculations in world coordinates, and only clip to the view port when drawing to the screen.

After a day of thinking and a night of rewriting I think I have it!

Some more notes after the cut.

The full source in quite a rough state is below. As I mentioned the basic idea of the rewrite is to keep everything in world coordinates until I draw to the player’s view. So let’s start with the Fov class.

In the Fov update method I call cells_get(), which now is a method of World. This function grabs a section of the map depending on how big the field-of-view radius is; that’s another change from the old Fov, where for each update I would make an fov_map as big as the viewport.

Most of the code in cells_get deals with clipping off the section in case it’s near the level borders. Also I made provision for calling the function with no arguments (though I may get rid of that).

Whereas before this function returned a mapping of viewport coordinates and world coordinates, now it just returns world coordinates.

The next step in the Fov update is to account for the possibility that the thing calculating field-of-view is up against the level border, in which case the fov_map won’t be its full size. Finally with the size determined I allocate the map.

Next I needed to take the world coordinates returned by cells_get and determine field-of-view properties; by incrementing coordinates for the fov_map at the same time I create a mapping of world coordinates and fov_map coordinates, which I put in self.fov_map_to_world_coordinates (take these long variable names as my method of commenting!).

With this done, the next step was to rewrite the View’s draw method. So far this is what I’m doing; first, I make sure the viewport is updated with self.style() (I imagine I’ll get rid of this property before long and just directly call self.scroll()). Then I create a structure with maps that holds each fov_map with its mapping of fov and world coordinates.

I append the player’s maps last, as this ensures their view is drawn on top of everthing else. I think once I’m fully blending affects this may not be as important as it is now, though I’m still hazy on how this will work.

Next I look at each set of maps and the world coordinates in the maps structure, first determining if the coordinates are actually in the viewport at all; if not, I skip the following calculations for now (though I may want to do them later depending on what affects I have). Then I run the usual calculations for affect and cell types, finding the appropriate colors. I added a utility function to find viewport coordinates from world coordinates, though I could easily fold that into this code (which I may still do).

Currently I just draw all field-of-views, and of course I’ll change this to hide those not visible to the player.

That’s pretty much it. I like the logic of this much better.

And now I have lamps!

It feels good to get this done.

#!/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 libtcodpy as libtcod

#############################################
# be things
#############################################

class Thing(object):
    def __init__(self, name, x=-1, y=-1):
        self.name = name
        self.speed = 'normal'
        self.x = x
        self.y = y

    def update(self):
        pass

class World(Thing):
    def __init__(self):
        self.cell_types = {
                            ' ' : [' ', 'transparent', 'walkable'],
                            '#' : ['#'],
                            '=' : ['=', 'transparent']}

        super(World, self).__init__('world')

        self.things = []

        self.level_width = 46
        self.level_height = 31
        self.level = [
        '##############################################',
        '#######################      #################',
        '#####################    #     ###############',
        '######################  ###        ###########',
        '##################      #####             ####',
        '################       ########    ###### ####',
        '###############      #################### ####',
        '################    ######                  ##',
        '########   #######  ######   #     #     #  ##',
        '########   ######      ###                  ##',
        '########                                    ##',
        '####       ######      ###   #     #     #  ##',
        '#### ###   ########## ####                  ##',
        '#### ###   ##########   ###########=##########',
        '#### ##################   #####          #####',
        '#### ###             #### #####          #####',
        '####           #     ####                #####',
        '########       #     #### #####          #####',
        '########       #####      ####################',
        '##########   #################################',
        '##########   #################################',
        '###########  #################   #############',
        '############  ###############   ##############',
        '#############   ###########     ##############',
        '###############  #########      ##############',
        '################   ####                  #####',
        '################   ###   ###########   #######',
        '###############   ##   ##############  #######',
        '#############   ###  #################   #####',
        '#############       ##################       #',
        '##############################################',
        ]

        self.level_make()

    def level_make(self):
        self.level_state = []
        for line in self.level:
            line_data = []
            for cell in line:
                line_data.append(self.cell_types[cell])
            self.level_state.append(line_data)

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

        r = 0
        if radius:
            r = radius

        y_start = 0
        x_start = 0
        y_end = game.world.level_height
        x_end = game.world.level_width
        if thing:
            y_start = max(thing.y - r, 0)
            x_start = max(thing.x - r, 0)
            y_end = min(game.world.level_height, thing.y + r)+1
            x_end = min(game.world.level_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 game.world.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 game.world.level_state[y][x]:
            return True

class Actor(Thing):
    def __init__(self, name, x=-1, y=-1, *handlers):
        super(Actor, self).__init__(name, x, y)

        self.brain = Brain()
        self.brain.add_handlers(self, *handlers)

        game.world.things.append(self)

    def update(self):
        self.brain.update()

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

class Brain(object):
    def __init__(self):
        self.handlers = []

    def add_handlers(self, thing, *handlers):
        for string in handlers:
            handler = eval(string)
            self.handlers.append(handler(thing, self))

    def remove_handlers(self, *handlers):
        for handler in handlers:
            self.handlers.remove(handler)

    def update(self):
        for handler in self.handlers:
            handler.update()

class Command(object):
    def __init__(self):
        self.rulebook = {
                        'move' : ('cell has monster', 'cell is unwalkable')}

        self.rules = {
                        'cell has monster' : 'game.world.cell_has_monster(thing.x+dx, thing.y+dy)',
                        'cell is unwalkable' : 'game.world.cell_is_unwalkable(thing.x+dx, thing.y+dy)'}

    def north(self, thing):
            self.move(thing, 0, -1)          

    def south(self, thing):
            self.move(thing, 0, 1)          

    def east(self, thing):
            self.move(thing, 1, 0)          

    def west(self, thing):
            self.move(thing, -1, 0)  

    def move(self, thing, dx, dy):
        if True in [eval(self.rules[rule]) for rule in self.rulebook['move']]:
            pass
        else:
            thing.x = thing.x + dx
            thing.y = thing.y + dy

class Fov(object):
    def __init__(self, thing, brain):
        self.thing = thing
        self.brain = brain
        self.fov_map = None
        self.fov_radius = 1
        self.fov_map_to_world_coordinates = []

    def update(self):
        self.fov_map_to_world_coordinates = []
        cells = game.world.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 = game.world.level_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)

            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)

        self.brain.fov_map = self.fov_map
        self.brain.fov_radius = self.fov_radius
        self.brain.fov_map_to_world_coordinates = self.fov_map_to_world_coordinates

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

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

class Light(object):
    def __init__(self, thing, brain):
        pass

    def update(self):
        pass

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

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

        game.view = self.view
        game.input = self.input

        if os.path.isfile('centaur.sav'):
            file = open('centaur.sav', 'r')
            game.world.things = yaml.load(file)
            for thing in game.world.things:
                if thing.name == 'player':
                    self.thing = thing
            file.close()
        else:
            self.thing = Actor('player', 26, 16, 'Fov')

class UI(object):
    def __init__(self):
        self.width = 40
        self.height = 22

        self.state = self.intro_draw

        self.chars = {
                        'player'    : '@',
                        'monster'   : '?',
                        'ground'    : ' ',
                        'wall'      : '#',
                        'window'    : '=',
                        'lamp'      : 'Q'}

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

        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_credits()

    def draw(self):
        self.state()

    def intro_draw(self):
        libtcod.console_clear(0)
        libtcod.console_set_foreground_color(0, libtcod.white)
        libtcod.console_print_center(0, 20, 8, libtcod.BKGND_NONE, "A Python Demo")
        libtcod.console_print_center(0, 20, 11, libtcod.BKGND_NONE, "press any key")
        libtcod.console_flush()

    def gameplay_draw(self):
        libtcod.console_clear(0)

        libtcod.console_set_foreground_color(0, libtcod.white)
        libtcod.console_print_left(0, 1, 1, libtcod.BKGND_NONE, "HJKL move around")
        libtcod.console_print_left(0, 20, 3, libtcod.BKGND_NONE, "speed: %s" % player.thing.speed)
        libtcod.console_print_left(0, 20, 4, libtcod.BKGND_NONE, "game turn: %d" % game.turns)
        libtcod.console_print_left(0, 20, 5, libtcod.BKGND_NONE, "phase: %s" % game.phase)
        libtcod.console_print_left(0, 20, 6, libtcod.BKGND_NONE, "phase count: %d" % game.phase_count)

        libtcod.console_set_foreground_color(0, libtcod.black)

        libtcod.console_blit(
                                player.view.screen,
                                0,
                                0,
                                player.view.width,
                                player.view.height,
                                0,
                                0,
                                self.height - player.view.height,
                                255)
        libtcod.console_flush()

class View(object):
    def __init__(self):
        self.width = 19
        self.height = 19
        self.focus_x = None
        self.focus_y = None
        self.style = self.scroll

        self.screen = libtcod.console_new(self.width, self.height)
        libtcod.console_set_foreground_color(self.screen, libtcod.black)

    def update(self):
        self.draw()

    def scroll(self):
        self.x_offset = min(max(0, player.thing.x - self.width//2), game.world.level_width - self.width)
        self.y_offset = min(max(0, player.thing.y - self.height//2), game.world.level_height - self.height)

        self.x_left_offset = min(player.thing.x, self.width//2)
        self.x_right_offset = max(0, (self.width//2 - (game.world.level_width - player.thing.x) + (self.width % 2)))
        self.focus_x =  self.x_left_offset + self.x_right_offset

        self.y_top_offset = min(player.thing.y, self.height//2)
        self.y_bottom_offset = max(0, (self.height//2 - (game.world.level_height - player.thing.y) + (self.height % 2)))
        self.focus_y =  self.y_top_offset + self.y_bottom_offset 

    def world_xy_to_view_xy(self, x, y):
        x = x - self.x_offset
        y = y - self.y_offset
        return (x, y)

    def draw(self):
        libtcod.console_clear(self.screen)

        self.style()

        maps = []
        for thing in game.world.things:
            if not thing.name == 'player':
                for handler in thing.brain.handlers:
                    if 'Fov' in str(handler):
                        maps.append((thing.brain.fov_map, thing.brain.fov_map_to_world_coordinates))

        maps.append((player.thing.brain.fov_map, player.thing.brain.fov_map_to_world_coordinates))

        for tuple in maps:
            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.x_offset <= x <= self.x_offset+self.width and
                    self.y_offset <= y <= self.y_offset+self.height):
                        fov_map_x, fov_map_y = cell[0][0], cell[0][1]
                        i, j = self.world_xy_to_view_xy(x, y)

                        affect, cell_type = 'dark', 'wall'

                        if libtcod.map_is_in_fov(fov_map, fov_map_x, fov_map_y):
                            affect = 'visible'

                        if libtcod.map_is_walkable(fov_map, fov_map_x, fov_map_y):
                            cell_type = 'ground'

                        color = player.ui.cell_colors[affect] * player.ui.cell_colors[cell_type]
                        libtcod.console_set_back(self.screen, i, j, color, libtcod.BKGND_SET)

                        if player.ui.chars['window'] in game.world.level_state[y][x]:
                            libtcod.console_put_char(self.screen, i, j, libtcod.CHAR_DHLINE, libtcod.BKGND_NONE)

                        for thing in game.world.things:
                            if not thing.name == 'player' and (thing.x, thing.y) == (x, y):
                                libtcod.console_put_char(self.screen, i, j, player.ui.chars[thing.name], libtcod.BKGND_NONE)

        libtcod.console_put_char(self.screen, self.focus_x, self.focus_y, player.ui.chars[player.thing.name], libtcod.BKGND_NONE)

class Input(object):
    def __init__(self):
        self.key = None
        self.keyboard = Keyboard()
        self.update_state = self.intro_update

    def update(self):
        self.update_state()

    def gameplay_update(self):
        if player.input.key:
            self.keyboard.update()

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

class Keyboard(object):
    def __init__(self):
        self.keycfg = {
                        'k' :   'north',
                        'j' :   'south',
                        'h' :   'west',
                        'l' :   'east'}

    def get_key(self, key):
        if key.vk == libtcod.KEY_CHAR:
            return chr(key.c)
        else:
            return key.vk

    def update(self):
        key = self.get_key(player.input.key)
        if key in self.keycfg:
            command_name = self.keycfg[key]
            command = getattr(game.command, command_name)
            command(player.thing)

        player.input.key = None

#############################################
# game
#############################################

class Game(object):
    def __init__(self):
        self.world = World()
        self.command = Command()
        self.view = None
        self.input = None
        self.update_state = self.intro_update

        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[0]
        self.phase_count = 0
        self.turns = 0

    def update(self):
        self.update_state()

    def intro_update(self):
        player.ui.draw()

        self.input.update()

        if os.path.isfile('centaur.sav'):
            for thing in game.world.things: thing.brain.update()
        else:
            self.monster = Actor('monster', 20, 9, 'AI')
            self.lamp1 = Actor('lamp', 29, 7, 'Fov', 'Light')
            self.lamp1.brain.update()
            self.lamp2 = Actor('lamp', 41, 7, 'Fov', 'Light')
            self.lamp2.brain.update()
            self.lamp3 = Actor('lamp', 29, 12, 'Fov', 'Light')
            self.lamp3.brain.update()
            self.lamp4 = Actor('lamp', 41, 12, 'Fov', 'Light')
            self.lamp4.brain.update()

        player.thing.brain.update()
        player.view.update()

        self.update_state = self.gameplay_update
        player.ui.state = player.ui.gameplay_draw
        player.input.update_state = player.input.gameplay_update

        libtcod.console_clear(0)

    def gameplay_update(self):
        self.input.update()

        for thing in game.world.things:
            if game.phase in game.phases_for[thing.speed]:
                thing.update()

        self.view.update()

        self.phase_count += 1
        self.phase = self.phases[self.phase_count % 5]
        if game.phase in game.phases_for['normal']: self.turns += 1

#############################################
# get it started & run
#############################################

if __name__ == '__main__':
    game = Game()
    player = Awesome()

    while not libtcod.console_is_window_closed():
        game.update()
        player.ui.draw()

        if game.phase in game.phases_for[player.thing.speed]:
            player.input.key = libtcod.console_wait_for_keypress(True)
            if player.input.key.vk == libtcod.KEY_ESCAPE:
                file = open('centaur.sav', 'w')
                yaml.dump(game.world.things, file)
                file.close()
                break

I’ve been taking a stab at how to structure commands and effects of commands…Up to now I’ve done something simple where the command processing is all done in a function contained in the instance of Command.

So the other day I started trying something like this:

class Command(object):
    def __init__(self):
        self.rulebook = {
                        'move' : ('cell has monster', 'cell is unwalkable')}

        self.rules = {
                        'cell has monster' : 'game.world.cell_has_monster(thing.x+dx, thing.y+dy)',
                        'cell is unwalkable' : 'game.world.cell_is_unwalkable(thing.x+dx, thing.y+dy)'}

    def north(self, thing):
            self.move(thing, 0, -1)          

    def south(self, thing):
            self.move(thing, 0, 1)          

    def east(self, thing):
            self.move(thing, 1, 0)          

    def west(self, thing):
            self.move(thing, -1, 0)  

    def move(self, thing, dx, dy):
        if True in [eval(self.rules[rule]) for rule in self.rulebook['move']]:
            pass
        else:
            thing.x = thing.x + dx
            thing.y = thing.y + dy

The structure of commands/rules/rulebook is a little hazy at the moment, but the idea is that you write a command in the rulebook with a structure of keys. Each key in the rules points to a function, and some functions return True if it’s a simple check — if any are true, the command fails. However some functions could affect the game world, schedule events, create new objects, and so on as well.

This is basically the same as making these checks in the function of the command — calling the functions there. It’s a little easier for me to read the rulebook though to see what rules each command uses, and the list comprehension in the function of the command takes care of adding new rules.

I don’t really want to get too crazy with processing commands (such as calling before and after routines, or checking a bunch of generic ‘can I/am I’ functions for each command), though it remains to be seen if the idea above will be easy enough to work with as I start adding commands and effects.

I’ve started to experiment more with cell coloring. Up to now I’ve defined cell colors explicitly — if a cell is of the ground type and visible for example, it was a ‘visible ground’ color, and similarly for a ‘dark wall’ and so on. However I felt this wasn’t a very good way to do colors, especially when you start mixing light and dark and other affects, like mist, smoke, fire, and so on. I don’t want to get too crazy here but I do like the look of colors and it’s one of libtcod’s strengths.

So after a few experiments I have a first pass at what I want to do. It looks like this:

If you look at the samples.py file included with the libtcod Python wrapper you’ll see a similar thing going on in the field-of-view sample with the torchlight (though that is more sophisticated, using noise — I hope to do that soon).

My colors dictionary now looks like this:

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

And what I do now when figuring out the color of a cell is find the distance of that cell to the field-of-view origin (for example, the player) and use that distance as a scalar for the affect color. I should note that affects are colors like ‘dark’, ‘lit’, and so on. Also you don’t really need to find the distance, just the distance squared to get the appropriate scalar — this will save a bit on computation, or so I’ve heard.

In other words, the ‘visible’ affect is most intense at its point of origin, and least at the maximum distance of the field-of-view radius. I think it does look better than using hard edges on affect boundaries.

This scalar is linear at the moment, so it creates a somewhat odd but not displeasing affect to my eyes. However I think I do want to randomize it a little with noise as done with the torchlight for samples.py.

I knew there was a reason I liked Python. In the last post I was going back and forth some on the readability of pickled files, so later tonight I looked a little closer at the PyYAML module. All I needed to do was change the pickle function calls to yaml function calls (as in, change pickle.dump to yaml.dump — that’s it!) and the files now look like this:

!!python/object:__main__.Actor
brain: &id001 !!python/object:__main__.Brain
  fov_map: 9773936
  handlers:
  - !!python/object:__main__.Fov
    brain: *id001
    fov_map: 9773936
    fov_radius: 8
    light_map: 9773904
  light_map: 9773904
  speed: normal
name: player
speed: normal
x: 32
y: 16

Of course I don’t know very much about the differences of pickle and yaml at this point (I knew I liked yaml from earlier exposure to it in some mud codebases) but this file format is at least looking much more to my taste!

I’ve been having a go with saving and loading in the Python demo. It may seem a little silly to do this before I have a game or for that matter, any content at all, but I’m following a bit of advice I read on rgrd and I’m glad I’m doing it…especially with loading the save state back in, it makes you think of how you structure the data to be saved in the program in the first place.

Luckily this first try is rather simple given Python’s pickle module. To save on exit I put this in the main loop:

            if player.input.key.vk == libtcod.KEY_ESCAPE:
                file = open('centaur.sav', 'w')
                file2 = open('player.sav', 'w')
                pickle.dump(game.world.level_state, file)
                pickle.dump(player.thing, file2)
                file.close()
                file2.close()
                break

This saves the level data and the player object to two separate files, then closes the game — though game.world.level_state doesn’t actually change at all currently, the x,y position of the player object does change, and saving it allows you to start the demo, move the player, then restart the demo with the player in the new spot.

For a quick test I just did this in place of the creation of the player thing object;

        if os.path.isfile('player.sav'):
            print 'player file found'
            file = open('player.sav', 'r')
            self.thing = pickle.load(file)
            game.world.things.append(self.thing)
            file.close()
        else:
            self.thing = Actor('player', 26, 16, Fov)

Note that I needed to add the player object back to the game.world.things list — otherwise, the player object brain’s update method will never be called (nor its field-of-view handler), as you aren’t adding it to the list by instancing the Actor class! Not doing this at first was a strange sight, as I moved and changed the player’s position without the screen updating.

As I mentioned, this test was a good thing to do early, as now I’m looking at how to arrange these saving and loading methods in the code. It seems like it would be a good idea to consolidate the saving and especially the loading as much as possible. Furthermore I’m not completely sold on the pickle module, as it creates files that look like this (in ASCII mode):

ccopy_reg
_reconstructor
p1
(c__main__
Actor
p2
c__builtin__
object
p3
NtRp4
(dp5
S'y'
I6
sS'x'
I18
sS'speed'

I’m envisioning a case where I have a save file and I want to examine it without too much fuss. A simple text format would be much more readable. On the other hand, the pickle module is dead simple, and it is readable (and unpickle-able, of course).

The Python demo has seen a lot of small changes as I attempt to drag it kicking and screaming into something a little more usable for a real game.

It’s at about 500 LOC at the moment and not yet incomprehensible to me — a good thing I think since I’m not working on it every day — and posted in full below, but I’ll try to highlight the bigger changes first.

One big change is I’m now using a different structure to hold the level information. I still have a hardcoded level, but when I initalize the world object I run the level through this function:

    def level_make(self):
        self.level_state = []
        for line in self.level:
            line_data = []
            for cell in line:
                line_data.append(self.cell_types[cell])
            self.level_state.append(line_data)

The function level_make() uses the self.cell_types dictionary, which at the moment looks like this:

        self.cell_types = {
                            ' ' : [' ', 'transparent', 'walkable'],
                            '#' : ['#'],
                            '=' : ['=', 'transparent']}

So instead of an array of strings as I had before with just the hardcoded map, now cell data is in an array of arrays. When I want to add a new cell type I’ll add it to the dictionary, and when I want to add new properties to the cells I can include it in the array. I don’t need to add a new property to each cell type — just the one where it counts. I hope this won’t get too confusing in the future.

I felt like I needed this structure to handle cases where the walkability or transparency of an individual cell was changed due to some area affect — it wouldn’t really do to just hope all ground cells always would be walkable.

As you would expect this level structure changes how you test for certain things — for example, in the field-of-view code, I now have code like this:

if 'walkable' in cell and 'transparent' in cell:
                libtcod.map_set_properties(self.fov_map, j, i, True, True)
            elif 'walkable' in cell:
                libtcod.map_set_properties(self.fov_map, j, i, False, True)
            elif 'transparent' in cell:
                libtcod.map_set_properties(self.fov_map, j, i, True, False)

whereas before I tested the cell type directly.

In the screenshot you can see the colors have changed — it’s just temporary at the moment, but I’m trying to add better looking lights to the view. Currently I’m mocking it up with some ad hoc light code in the Fov class, with the goal of keeping track of a separate light map later down the road.

Of course, I can’t not point out that other little creature scampering around — the fearsome ‘?’.

Mr ‘?’ is running on this behaviour handler:

class AI(object):
    def __init__(self, thing, brain):
        self.choices = ['up', 'down', 'left', 'right']
        self.thing = thing

    def update(self):
        choice = random.randint(0, 3)
        command_name = self.choices[choice]
        command_func = getattr(game.command, command_name)
        command_func(self.thing)

and I created it with an instancing of the Actor class in the setting up stages of the game object. It’s pretty dumb, as it chooses a direction randomly on each update.

One last small thing is the first attempt to hold all the game’s things in a list — the Actor class adds each new instance of itself to this list, for example. I’m unsure at the moment if the player should be in this list, though at the moment it is — I might change that to keep things simpler.

My next goal is to get some rudimentary saving and loading going.

Here’s the complete demo:

#!/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, random

import libtcodpy as libtcod

#############################################
# be things
#############################################

class Thing(object):
    def __init__(self, name, x=-1, y=-1):
        self.name = name
        self.x = x
        self.y = y

    def update(self):
        pass

class World(Thing):
    def __init__(self):
        self.cell_types = {
                            ' ' : [' ', 'transparent', 'walkable'],
                            '#' : ['#'],
                            '=' : ['=', 'transparent']}

        super(World, self).__init__('world')
        self.walkable = [' ']

        self.things = []

        self.level_width = 46
        self.level_height = 31
        self.level = [
        '##############################################',
        '#######################      #################',
        '#####################    #     ###############',
        '######################  ###        ###########',
        '##################      #####             ####',
        '################       ########    ###### ####',
        '###############      #################### ####',
        '################    ######                  ##',
        '########   #######  ######   #     #     #  ##',
        '########   ######      ###                  ##',
        '########                                    ##',
        '####       ######      ###   #     #     #  ##',
        '#### ###   ########## ####                  ##',
        '#### ###   ##########   ###########=##########',
        '#### ##################   #####          #####',
        '#### ###             #### #####          #####',
        '####           #     ####                #####',
        '########       #     #### #####          #####',
        '########       #####      ####################',
        '##########   #################################',
        '##########   #################################',
        '###########  #################   #############',
        '############  ###############   ##############',
        '#############   ###########     ##############',
        '###############  #########      ##############',
        '################   ####                  #####',
        '################   ###   ###########   #######',
        '###############   ##   ##############  #######',
        '#############   ###  #################   #####',
        '#############       ##################       #',
        '##############################################',
        ]

        self.level_make()

    def level_make(self):
        self.level_state = []
        for line in self.level:
            line_data = []
            for cell in line:
                line_data.append(self.cell_types[cell])
            self.level_state.append(line_data)

class Actor(Thing):
    def __init__(self, name, x=-1, y=-1, *handlers):
        super(Actor, self).__init__(name, x, y)

        self.brain = Brain()
        self.brain.add_handlers(self, *handlers)

        self.speed = self.brain.speed

        game.world.things.append(self)

    def update(self):
        self.brain.update()

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

class Brain(object):
    def __init__(self):
        self.handlers = []
        self.speed = 'normal'

    def add_handlers(self, thing, *handlers):
        for handler in handlers:
            self.handlers.append(handler(thing, self))

    def remove_handlers(self, *handlers):
        for handler in handlers:
            self.handlers.remove(handler)

    def update(self):
        for handler in self.handlers:
            handler.update()

class Command(object):
    def __init__(self):
        pass

    def cell_has_monster(self, x, y):
        for thing in game.world.things:
            if (thing.x, thing.y) == (x, y):
                return True

    def up(self, thing):
        if not self.cell_has_monster(thing.x, thing.y-1) and 'walkable' in game.world.level_state[thing.y-1][thing.x]:
            thing.y = thing.y - 1

    def down(self, thing):
        if not self.cell_has_monster(thing.x, thing.y+1) and 'walkable' in game.world.level_state[thing.y+1][thing.x]:
            thing.y = thing.y + 1

    def right(self, thing):
        if not self.cell_has_monster(thing.x+1, thing.y) and 'walkable' in game.world.level_state[thing.y][thing.x+1]:
            thing.x = thing.x + 1

    def left(self, thing):
        if not self.cell_has_monster(thing.x-1, thing.y) and 'walkable' in game.world.level_state[thing.y][thing.x-1]:
            thing.x = thing.x - 1

class Fov(object):
    def __init__(self, thing, brain):
        self.brain = brain
        self.fov_map = None
        self.light_map = None
        self.fov_radius = 8

    def update(self):
        player.view.cells_get()

        self.fov_map = libtcod.map_new(player.view.width, player.view.height)
        self.light_map = libtcod.map_new(game.world.level_width, game.world.level_height)

        for cells in player.view.cells:
            x, y, j, i = cells
            cell = game.world.level_state[y][x]

            if 'walkable' in cell and 'transparent' in cell:
                libtcod.map_set_properties(self.fov_map, j, i, True, True)
            elif 'walkable' in cell:
                libtcod.map_set_properties(self.fov_map, j, i, False, True)
            elif 'transparent' in cell:
                libtcod.map_set_properties(self.fov_map, j, i, True, False)

            if 'walkable' in cell and 'transparent' in cell:
                libtcod.map_set_properties(self.light_map, j, i, True, True)
            elif 'walkable' in cell:
                libtcod.map_set_properties(self.light_map, j, i, False, True)
            elif 'transparent' in cell:
                libtcod.map_set_properties(self.light_map, j, i, True, False)

        libtcod.map_compute_fov(self.fov_map, player.view.focus_x, player.view.focus_y, self.fov_radius, True)
        libtcod.map_compute_fov(self.light_map, 15, 10, 2, True)

        self.brain.fov_map = self.fov_map
        self.brain.light_map = self.light_map

class AI(object):
    def __init__(self, thing, brain):
        self.choices = ['up', 'down', 'left', 'right']
        self.thing = thing

    def update(self):
        choice = random.randint(0, 3)
        command_name = self.choices[choice]
        command_func = getattr(game.command, command_name)
        command_func(self.thing)

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

class Awesome(object):
    def __init__(self):
        self.thing = Actor('player', 26, 16, Fov)
        self.ui = UI()
        self.view = View()
        self.input = Input()

        game.view = self.view
        game.input = self.input

class UI(object):
    def __init__(self):
        self.width = 40
        self.height = 22

        self.state = self.intro_draw

        self.chars = {
                        'player'    : '@',
                        'monster'   : '?',
                        'ground'    : ' ',
                        'wall'      : '#',
                        'window'    : '='}

        self.cell_colors = {
                            'dark wall' : libtcod.Color(0, 0, 0),
                            'visible wall' : libtcod.Color(130, 110, 50),
                            'dark ground' : libtcod.Color(0, 0, 0),
                            'visible ground' : libtcod.Color(180, 180, 180),
                            'lit wall' : libtcod.Color(244, 199, 18),
                            'lit ground' : libtcod.Color(244, 231, 18)}

        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_credits()

    def draw(self):
        self.state()

    def intro_draw(self):
        libtcod.console_clear(0)
        libtcod.console_set_foreground_color(0, libtcod.white)
        libtcod.console_print_center(0, 20, 8, libtcod.BKGND_NONE, "A Python Demo")
        libtcod.console_print_center(0, 20, 11, libtcod.BKGND_NONE, "press any key")
        libtcod.console_flush()

    def gameplay_draw(self):
        libtcod.console_clear(0)

        libtcod.console_set_foreground_color(0, libtcod.white)
        libtcod.console_print_left(0, 1, 1, libtcod.BKGND_NONE, "HJKL move around")
        libtcod.console_print_left(0, 20, 3, libtcod.BKGND_NONE, "speed: %s" % player.thing.brain.speed)
        libtcod.console_print_left(0, 20, 4, libtcod.BKGND_NONE, "game turn: %d" % game.turns)
        libtcod.console_print_left(0, 20, 5, libtcod.BKGND_NONE, "phase: %s" % game.phase)
        libtcod.console_print_left(0, 20, 6, libtcod.BKGND_NONE, "phase count: %d" % game.phase_count)

        libtcod.console_set_foreground_color(0, libtcod.black)

        libtcod.console_blit(
                                player.view.screen,
                                0,
                                0,
                                player.view.width,
                                player.view.height,
                                0,
                                0,
                                self.height - player.view.height,
                                255)
        libtcod.console_flush()

class View(object):
    def __init__(self):
        self.width = 19
        self.height = 19
        self.focus_x = None
        self.focus_y = None
        self.style = self.scroll
        self.cells = []

        self.screen = libtcod.console_new(self.width, self.height)
        libtcod.console_set_foreground_color(self.screen, libtcod.black)

    def update(self):
        self.draw()

    def cells_get(self):
        self.cells = []

        self.style()

        for i in range(self.height):
            y = self.top_view_frame + i
            for j in range(self.width):
                x = self.left_view_frame + j
                self.cells.append((x, y, j, i))

    def scroll(self):
        self.left_view_frame = min(max(0, player.thing.x - self.width//2), game.world.level_width - self.width)
        self.top_view_frame = min(max(0, player.thing.y - self.height//2), game.world.level_height - self.height)

        self.x_left_offset = min(player.thing.x, self.width//2)
        self.x_right_offset = max(0, (self.width//2 - (game.world.level_width - player.thing.x) + (self.width % 2)))
        self.focus_x =  self.x_left_offset + self.x_right_offset

        self.y_top_offset = min(player.thing.y, self.height//2)
        self.y_bottom_offset = max(0, (self.height//2 - (game.world.level_height - player.thing.y) + (self.height % 2)))
        self.focus_y =  self.y_top_offset + self.y_bottom_offset 

    def draw(self):
        libtcod.console_clear(self.screen)

        for cells in self.cells:
            x, y, j, i = cells

            affect, cell = 'dark', 'wall'
            if libtcod.map_is_in_fov(player.thing.brain.fov_map, j, i): affect = 'visible'
            if libtcod.map_is_walkable(player.thing.brain.fov_map, j, i): cell = 'ground'

            if (libtcod.map_is_in_fov(player.thing.brain.light_map, x, y) and
                libtcod.map_is_in_fov(player.thing.brain.fov_map, j, i)): affect = 'lit'

            color = player.ui.cell_colors['%s %s' % (affect, cell)]
            libtcod.console_set_back(self.screen, j, i, color, libtcod.BKGND_SET)    

            if player.ui.chars['window'] in game.world.level_state[y][x]:
                libtcod.console_put_char(self.screen, j, i, libtcod.CHAR_DHLINE, libtcod.BKGND_NONE)

            for thing in game.world.things:
                if not thing.name == 'player' and (thing.x, thing.y) == (x, y):
                    libtcod.console_put_char(self.screen, j, i, player.ui.chars[thing.name], libtcod.BKGND_NONE)

        libtcod.console_put_char(self.screen, self.focus_x, self.focus_y, player.ui.chars[player.thing.name], libtcod.BKGND_NONE)

class Input(object):
    def __init__(self):
        self.key = None
        self.keyboard = Keyboard()

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

    def update(self):
        if player.input.key:
            self.keyboard.update()

class Keyboard(object):
    def __init__(self):
        self.keycfg = {
                        'k' :   'up',
                        'j' :   'down',
                        'h' :   'left',
                        'l' :   'right'}

    def get_key(self, key):
        if key.vk == libtcod.KEY_CHAR:
            return chr(key.c)
        else:
            return key.vk

    def update(self):
        key = self.get_key(player.input.key)
        if key in self.keycfg:
            command_name = self.keycfg[key]
            command_func = getattr(game.command, command_name)
            command_func(player.thing)

        player.input.key = None

#############################################
# game
#############################################

class Game(object):
    def __init__(self):
        self.world = World()
        self.command = Command()
        self.view = None
        self.input = None
        self.state = self.intro_update

        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[0]
        self.phase_count = 0
        self.turns = 0

    def update(self):
        self.state()

    def intro_update(self):
        player.ui.draw()

        self.input.intro_update()

        game.state = game.gameplay_update
        player.ui.state = player.ui.gameplay_draw

        self.monster = Actor('monster', 30, 16, AI)

        player.thing.brain.update()
        player.view.update()

        libtcod.console_clear(0)

    def gameplay_update(self):
        self.input.update()

        for thing in game.world.things:
            if game.phase in game.phases_for[thing.speed]:
                thing.update()

        self.view.update()

        self.phase_count += 1
        self.phase = self.phases[self.phase_count % 5]
        if game.phase in game.phases_for['normal']: self.turns += 1

#############################################
# get it started & run
#############################################

if __name__ == '__main__':
    game = Game()
    player = Awesome()

    while not libtcod.console_is_window_closed():
        game.update()
        player.ui.draw()

        if game.phase in game.phases_for[player.thing.brain.speed]:
            player.input.key = libtcod.console_wait_for_keypress(True)
            if player.input.key.vk == libtcod.KEY_ESCAPE:
                break