BogBoa

Zomborgs

2012-02-18T18:31:00.000-08:00

Known to use transmat beams to take brains directly from crewfolk skulls.

Failure is an Option

2012-02-18T08:20:00.001-08:00

This is the icon for a dead player

Character Work

2012-02-17T12:15:00.000-08:00

I have a notion of how I'd like the chat windows to flow using character portraits. Player and crew would appear left of chat boxes and encountered NPCs to the right. I suspect I'm channeling some Japanese RPG.

This is a Kthogin -- a Lovecraftian inspired hostile. I'm leaning towards giving each race a unique color for easy recognition.

Thoughts on Serialization

2012-02-12T10:33:00.000-08:00

The problem domain is short and sweet;

We need to write game data.
We need to read game data.

The only real snag is, being single threaded, we need these operations to block as little as possible -- as in thousandths of a second. I've even toyed with the idea of reading everything at server start and only performing writes during execution. That would cut our blocking problem in half but removes our ability to modify data externally.

The model in my head calls for very little of the R in RDBMS. Heck, MUDs have managed very well for decades using flat files on systems with less processing power than your dishwasher.

Lastly, given that this hobby-coding, I have the luxury of asking, 'is the solution fun?' Let's set a couple goals;

I don't want a crash to lose the overall state of the game -- which precludes saving writes for an extended period, or even worse, until server shutdown.
Simple to install. Freely available software that does not require a DBA to manage.
Simple to operate. No fretting dirty caches, scheduled housekeeping , etc.
I would prefer back-ups and restores to be file copies. Tar'ing a directory or two is fine.
Some external method to futz with the data while the game is running.

Flat files are certainly doable (and made crazy easy with Python's Pickle module). They meet goals #2, #3, and #4 but I cringe at the amount of runtime file-io needed to cover goal #1 and supporting goal #5 means we have to perform constant reads as well (plus some form of file-locking mechanism). Ick.

A lightweight dbms like SQLite would work except for goal #3. Wrapping Python CRUD in SQL statements is soul-destroying tedious. Yeah, I could tap a ORM like SQLAlchemy but let's look at that new sexy, NoSQL...

When I was a kid, one Christmas I got this electronics kit with 150 projects. It was awesome. You could build things like a crystal radio, lie detector, and light activated room alarm.

Python holds that same appeal for me. It's a big toy. Another one I've found is Redis -- a dead simple NoSQL data store. The distinguishing feature is all data is held in-memory which makes it wicked fast.

I'll admit, when I first read that it holds everything is RAM it struck me as rather pointless. I mean, wasn't I already doing that in my program? And who wants to hold everything in memory whether you need it or not?

Having played with it, the utility and genius starts to shine through. Redis has a clever system of serializing to a file based on the frequency of updates and you can copy this file at any moment without fear of corrupting it. The author also provides a really nice CLI tool with history and auto-complete similar to a Linux terminal.

We're pushing goal #2 a bit since it requires installing three packages, Redis, Hiredis, and Redis-py but they all loaded with minimal fuss. Hiredis needed the Python development libs you can get on Ubuntu using:

$ sudo apt-get install python-dev

...to be continued

Crawling a Graph

2011-06-27T18:53:00.000-07:00

I got the sector crawling code done. Then I used it to walk a sector and add every linked one to a set. This set is also added to a master set of visited sectors. I step to the next sector and, if it's not in the visited set, crawl it. Repeat for all sectors to generate a collection of sets. Each set contains either a group of linked sectors or a single orphan sector.

Here's a diagram of crawling from sector 12:

Next, I take the collection of sets, pop one off, and work through the remaining trying to find two sector that are adjacent. Once I do, I give them exits to each other and merge the popped set into the target set. I repeat this until the collection only contains one set -- the entire universe:

Lastly, I got my A* path finder working. This is the first time I've experimented with path finding. I tried a variety of heuristics and had the best luck (shortest path + least crawled sectors + fastest time) with the simplest one; Chebyshev. This is comparing ABS(X1 - X2) to ABS(Y1 - Y2) and use which ever is greater. One source I read said to add the number of hops from the starting point but, again, just Chebyshev alone gave the best results. Weirdness. Could have a glitch somewhere.

I had a funny bug during my testing. I was using random.seed() so that I'd generate the same initial links every time. I ran my path finding test; 24 hops. Ran it again; 20 hops. Again; 48 hops. What the heck? I neglected to consider that sets are unordered and was linking the orphaned sectors in varying sequence. Changing the set to a list fixed this.

Two options that I have not explored are one-way exits and links between non-adjacent sectors (wormholes). Not sure if the added complexity has value.

Visualizing Data

2011-06-25T18:56:00.000-07:00

To create the game space, I'm going to need to assign random sector connections, tweak those into usefulness, and eventually write an A* path finder. I really need some way to SEE this hooey.

Scaled Vector Graphics are an XML-based image format that I really like. Google suggested a couple of Python libraries but I ended up writing my own based on code to generate XHTML from a previous project. A few hours later I had my universe mapper. Here's a 25 sector uiverse with some random pathways. Notice that sector 23 is an orphan, with no way in and no way out. That's the issue I'm working on now.

You might notice the absence of NE and SE jumps to fit the hex paper scheme from my previous post. I decided that the center-most sector (in this case, 12) would be the hub, which will always get 6 exits. More on using this to cure orphanism later.

Just to be stupid, I generated a map with 40,000 sectors. The script ran for only a second or two but my image viewer choked so bad that I had to go read a book while it chugged through and finally produced this (zoomed out) mess:

The Universe is a Diamond

2011-06-25T08:48:00.000-07:00

Now that I've got the websocket server working I've got the itch to write a space rpg inspired by the classic BBS game Tradewars.

I especially liked the spatial system they used where sectors formed these baffling, mole-tunnel chains. Lucky exploration might find you a highly profitable port or, better yet, a nice dead-end sector to hide your ships and planets in.

Let's say we want each sector to link up to six others, proving a movement pattern like hex paper;

Internally, I plan on using a bog-standard XY array. Why? Because it feels like it would make things like pathfinding and NPC distribution easier. We'll see.

So let's say we're in Sector 54 (yellow) and can move to six adjacent sectors (blue):

I'm thinking that if I rotate the player's orientation slightly and omit Northeast and Southwest movement, I can fit the hex over the grid like so;

To the player's perspective, he's flying around a diamond-shaped space. Here's an example of moving from Sector 53 to 01. It was important to me that the sector you came from retain the proper orientation.

Virtual hex paper. Next step is to break all the links into twisty little passages -- not alike.

Python 3

2011-06-17T17:49:00.000-07:00

I've been ignoring Python 3K.

I code under Linux and have been perfectly happy with the 2.x versions that most distros include by default. But Python 3 nags at me like a late property tax of uncertain size.

A while back someone filed a bug that Miniboa didn't work with Python 3. "Get off my lawn", I thought to myself.

To switch gears for a second -- I've found that deleting big chunks of code (murder your darlings) is usually a sign that you're on the right track. I deleted the unfinished Telnet, co-routine, and character-at-a-time code from Netboa. Knowing that the codebase will never be this slim again, I thought it was a good time to take a shot at Python 3 compatibility and issued an 'apt-get install python3'.

Like the five stages of denial, I bet there's a sequence that Python coders go through to port their code to 3K that starts with "keep adding parenthesis", takes them mindless cutting and pasting from googles of error messages, and finishes with them sobbing over byte encoding. Python 3 has two types of strings; bytes and unicode. Oddly, byte sequences are very like Python 2 strings minus any formatting options but with all kinds of gotchas. Take this weirdness for example:

>>> '\x20\x20'[0] == '\x20'
True
>>> b'\x20\x20'[0] == b'\x20'
False

Following the advice of Armin Ronacher, I switched most everything to byte sequences as those play nice with sockets and the keys needed for handshaking. After a bit of import hackery, Netboa seems to work under both 3+ and 2.6+. Due to a change in exceptions using the "as" keyword, I lost 2.5 compatibility.

WebSockets

2011-06-15T17:02:00.000-07:00

Yes, long hiatus. Hi.

WebSockets have amazing potential for browser-based gaming. Unfortunately, they are also in a constant state of flux, partially because the draft spec keeps changing and partially because browser makers want to minimize the amount of dickery that internet doofuses can inflict on you. Firefox and Opera have temporarily dropped WebSocket support but they should be back in again in Firefox 6.

The last few nights I've been trying to fix a handshake bug with my implementation of draft76 handshaking. This is the version currently used by Chrome and Safari. Finally got it working again after writing the following test case:


#!/usr/bin/env python
#------------------------------------------------------------------------------
#   netboa/websocket/sanity_check76.py
#   Copyright 2011 Jim Storch
#   Licensed under the Apache License, Version 2.0 (the "License"); you may
#   not use this file except in compliance with the License. You may obtain a
#   copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#   Unless required by applicable law or agreed to in writing, software
#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#   License for the specific language governing permissions and limitations
#   under the License.
#------------------------------------------------------------------------------

"""
Wrote this to test that I'm correctly generating the responses for draft76
websockets.
"""

import struct
import hashlib


## From the draft76 docs:

REQUEST1 = (
    'GET /demo HTTP/1.1\r\n'
    'Host: example.com\r\n'
    'Connection: Upgrade\r\n'
    'Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r\n'
    'Sec-WebSocket-Protocol: sample\r\n'
    'Upgrade: WebSocket\r\n'
    'Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r\n'
    'Origin: http://example.com\r\n'
    '\r\n'
    '^n:ds[4U'
    )

CORRECT_RESPONSE1 = "8jKS'y:G*Co,Wxa-"

REQUEST2 = (
    'GET /demo HTTP/1.1\r\n'
    'Host: example.com\r\n'
    'Connection: Upgrade\r\n'
    'Sec-WebSocket-Key2: 1_ tx7X d  <  nw  334J702) 7]o}` 0\r\n'
    'Sec-WebSocket-Protocol: sample\r\n'
    'Upgrade: WebSocket\r\n'
    'Sec-WebSocket-Key1: 18x 6]8vM;54 *(5:  {   U1]8  z [  8\r\n'
    'Origin: http://example.com\r\n'
    '\r\n'
    'Tm[K T2u'
    )

CORRECT_RESPONSE2 = 'fQJ,fN/4F4!~K~MH'

def parse_request(request):
    req = {}
    segments = request.split('\r\n\r\n', 1)
    assert(len(segments) == 2)
    header, payload = segments
    lines = header.split('\r\n')
    line = lines.pop(0)
    items = line.split('\x20',2)
    assert(len(items) == 3)
    req['method'] = items[0]
    req['request_uri'] = items[1]
    req['http_version'] = items[2]
    for line in lines:
        parts = line.split(':\x20', 1)
        assert(len(parts) == 2)
        req[parts[0].lower()] = parts[1]
    req['payload'] = payload
    return req

def get_word(key):
    digits=''
    spaces=0
    for char in key:
        if char.isdigit():
            digits += char
        elif char == '\x20':
            spaces += 1
    assert(spaces)
    assert(digits)
    keynum = int(digits)
    assert(keynum % spaces == 0)
    wordval = keynum / spaces
    assert(wordval < 2 ** 32)
    return struct.pack("!I", wordval)

def create_token(req):
    key1 = req.get('sec-websocket-key1', None)
    assert(key1 is not None)
    word1 = get_word(key1)
    key2 = req.get('sec-websocket-key2', None)
    assert(key2 is not None)
    word2 = get_word(key2)
    salt = req.get('payload', None)
    assert(salt is not None)
    assert(len(salt)==8)
    return hashlib.md5(word1 + word2 + salt).digest()    

req = parse_request(REQUEST1)
print create_token(req) == CORRECT_RESPONSE1

req = parse_request(REQUEST2)
print create_token(req) == CORRECT_RESPONSE2

Please note that this version is scheduled to be replaced by a draft called Hybi-08 which features a way simpler algorithm (which I *think* I have it nearly ready to drop in).

My interests are clearly taking Netboa towards being a browser-based game server. The combination of HTTP + WebSockets is quite appealing. It's really time to knuckle down and learn some Javascript -- or, more likely, lots of JQuery.

Chrome WebSocket Protocol Update

2011-04-22T09:07:00.000-07:00

Just making a note here;

http://blog.chromium.org/2010/06/websocket-protocol-updated.html

HTTP Server

2010-08-22T10:53:00.000-07:00

In my previous post, I mentioned the goal of separating protocols from the client object. As an experiment, I started writing a HTTP service using the new code. This would let me run a light web server as a service in conjunction with something like WebSockets on the same, single-threaded server.

You definitely don't want to waste time serving big files in a single threaded application because it blocks but for little things like a login page it could be handy. Plus, I've written web based apps for years but never fully understood what was happening under the hood and here was a chance to find out.

The actual HTTP protocol is pretty simple. It only has eleven commands (or methods); HEAD, GET, POST, PUT, DELETE, TRACE, OPTIONS, CONNECT, and PATCH. Currently, I only support one, GET (which is easily 99.9% of the web). All other methods are responded to with a status code 501 Not Implemented.

Here's my index.html rendered on Chromium:

This actually represents three separate HTTP GET requests; the index.html file, the skull image, and the tiny skull favicon shown on the tab.

The skull is a compressed SVG, to get Chromium to display it I had to add Content-encoding parameter to my HTTP Response;

Netboa

2010-08-22T10:18:00.000-07:00

I've started the total re-write of my asynchronous network library Miniboa. The new code, in addition to being cleaner, is different in several ways.

What's New

No longer Telnet-centric; my aim is to keep connections generic and wrap them in protocol handlers.
Services; you can now run multiple services under a single server. Each service listens on a different port and can have unique protocols and events.
Added hooks for coroutine-based, character-at-a-time protocol handlers.
No longer line-based; the new API has get_ch() to get one character or get_input() to retrieve the entire input buffer. This is support users that want to write features like text editors and command completion.
New event; on_input() that is called when the data is received from the client.
When run under Linux, it uses the Epoll API introduced in Linux kernel 2.5.44. All other platforms user Select().

I kept the server polled from within the user's game loop. I know that event and callback driven designs are more efficient, but I really like the approachability of that pattern. It can be hard to think in terms of callbacks.

The Plague that struck Azeroth

2010-05-02T18:38:00.001-07:00

I ran across some old screen-shots from an event that occurred in the MMO World of Warcraft on September, 13 2005 after the opening of a dungeon called Zul'Gurub. One of the encounters involved a damage-over-time spell called Corrupted Blood that spread from the victim to anyone nearby. It was designed to be contained within the instance but players found that they could dismiss infected pets and later recall them with the effect still running, and massively contagious, regardless of where they went.

This is what the main Horde city of Orgrimmar looked like;

Like Morpheus said about The Matrix, this world was built on rules and it was fascinating to see those rules play out in completely unintended ways. Low level players running into town would die in a tick or two. Anyone high enough to survive the intitial damage only helped to spread it farther, including NPCs.

Not Actually Dead

2010-04-19T17:03:00.000-07:00

To the 1.2 people who actually follow this blog -- I've taken a new job as a county IT director which I'm enjoying but there's sooooo much stuff to unravel and mentally digest that it may be some time before my head is clear enough to code on my free time again.

Thinking about Miniboa 2.0

2010-03-21T09:49:00.000-07:00

In the early 90s, my hobby was running a computer bulletin board system (BBS) in Virginia called Grendel's Place. I started with a free package called RBBS and then bought a license for the more spiffy TriBBS. Like the joke said; a sysop is someone who spends thousands of dollars to let other people use his computer.

I spent a lot of time writing utilities and experimental games with Borland's Turbo C compiler. Man, I loved that program. Eventually, I bought their C++ compiler for Windows but the combination of the awful C++ language and Microsoft's hideous Foundation Class Library killed my hobby programming for years.

BBSes had a wealth of Door games, which were external programs that the BBS passed control of the serial port to while the user played them. Some of these were, like Tradewar 2000 and Solar Realms Elite were incredibly compelling. Since the typical BBS had only a single phone line, these games tended to be turn-based with only so many moves allotted to each player per day.

Having started to work with Telnet, I immediately lamented the absence of two features from my days coding for a BBS. The first was IBM's extended character set that let you draw lines and blocks. Check out this screen from Global War:

The second thing I missed was ANSI.SYS, a DOS driver from Microsoft that controlled character color and cursor placement. Most BBS clients either used ANSI.SYS directly or as the standard against their own implementation. You could safely make assumptions about the capability of your visitor's terminal and do neat things.

Telnet clients, on the other hand, are horrible.

They are horrible in two ways -- actually implementing the Telnet protocol and supporting those same ANSI control codes. Feature support across the various clients is so awful and quirky that it's impossible to rely on anything but the shallowest of implementations -- even little things like setting the background color.

While writing Miniboa, I scaled back many of my aspirations and focused on two areas; things that mostly worked regardless of client and things that were harmless if they failed. If your client supported NAWS, you got 'on-the-fly' terminal sizing. If not, you got 80 columns. This is one of the reasons Miniboa is line-based (as in, it gives you an entire line of client input rather than keystrokes). It worked by default on every client I tested.

Another reason I went line-based was I'm toying with the idea of writing a Jabber/XMPP server to support play from instant messaging and wanted to keep my interface to the clients duck-typed; client.get_cmd() and client.send().

Whew, that's too much background eh?

OK, OK -- Miniboa 2.0. I had a request to add character support to Miniboa and realized there was no way to do it without some really ugly hacks and the right thing(tm) was to decouple, decouple, decouple. Currently, Telnet is handled via a do-it-all class that stores the Socket object as a member property and performs a lot of state juggling. I think I want to switch things over to nested coroutines. Where the inner ones perform progressively lower level IO.

David Beazley, author of the excellent Python Essential Reference, gave a lecture entitled A Curious Course on Coroutines and Concurrency at PyCon 2009. You can watch a video of it here:

Part 1
Part 2
Part 3

Another development comes from Confuto and Stendec who have kindly donated code for implementing WebSocket and Flash servers with Miniboa. This is pretty exciting because of the potential for rich clients that both represent. Plus if I do write a Jabber server, it would benefit from the decoupling process as well.

Character Skills

2010-02-16T08:07:00.000-08:00

Now that I've covered Stats, I wanted to talk about Character Skills but let's start with a clear definition since skill has multiple meanings in the context of computer RPGs;

In Bogboa, Skill represents the actor's measure of talent when it comes to performing abilities within given categories.

So a player attempting to disarm a trap might rely on an comprehend_traps skill to provide the base number for the success check. Building on the stat post, that base number might be bumped up a few percent if they possess lots of cunning.

Skill Modifiers

The idea is to maintain a list of skill modifiers that vary per guild (character class). The rogue guild might have a comprehend_traps modifier of 1.0 while the warrior guild has .01. This results in a warrior having 1/10th of the trap removing potential of a rogue. If we set it to zero, warriors will always fail regardless of level and cunning.

You can imagine these modifiers like the sliders on an equalizer as we use them to control the relative power of each guild. Creating hybrid classes would be a simple matter of setting a ratio for primary skill modifiers -- a paladin might have a healing skill of .65 and a combat skill of .85 as compared to a cleric's (1.0, 0.5) and a warrior's (0.0, 1.0). If a guild does not list a given skill we treat the modifier as zero.

The potential power of a skill modifier is immense and, like a thermostat that goes to a billion, should be used great care. It's my intention to stick very close to 1.0 as the maximum modifier value*. This keeps power ratios cleanly defined across guilds and relative to mob level. Let's contrive an example to illustrate why this is probably a good idea. We have a designer that wants to create a Cavalier Guild and decides they're like warriors but better with swords. Assuming the warrior had 1.0 sword skill modifier, he gives his cavalier 1.2. Now they are 20% deadlier than mobs their level -- a level 40 cavalier attacks like he's 8 levels above his opponent. This makes them too easy, so our designer bumps up NPCs to compensate and now every other player guild has a rougher time of it.

The designer could try to balance this offense power with lower defense but it's tricky. Sustained damage output sets the rate of experience gain for the character. Unless you implement some form of downtime, almost dying is meaningless.

* An exception to this would be Wizard Guild defense and health modifiers, which will be something like 100000.0 to make them immortal. Conversely, their offensive skills should be 0.0 to discourage abuse.

Skill Caps

Skills are capped at;

actor_level * 10 * guild_modifier

Not much needs explained here; a level 20 warrior with a 1.0 combat modifier will have a maximum combat skill of 200.

Raising Skills

There are many ways to handle this but I've always been partial to raising skills through using them. Most of the skill rating functions (see below) have an optional tutor argument. If this is set to True and the player's current skill is not maxed, he gets a chance to increase his current skill during the check. The chance becomes progressively lower as the player closes in on his current max skill.

Rating Skills

This is the meat and potatoes of the skill system. Using a group of functions, we rate an actor's skill by looking up the current value and applying any stat related bonuses or penalties. The result is a rating: a numeric value used for comparisons and success/failure checks. Some ratings are derived by combining other ratings. For example, a player's hit rating is the average of his melee combat rating and the specific weapon rating for the type of weapon he's carrying. This is to accommodate scenarios like a level 20 warrior who has never touched a mace suddenly picking one up. Even though his skill in blunt weapons is zero, his melee combat skill provides some chance of landing a hit.

It's a small shift it perspective, but thinking in terms of skill ratings was something I found helpful.

Application

We've already covered that we'd use skill ratings for deciding success but not how those rolls will be calculated. Here's an example for striking with the player's primary weapon. Basically, we pick a random number in the range of 0 to (defender's defense rating + attacker's hit rating ). If the number is higher than the defender's defense, it is a hit. You can see how either value grows, probability will shift accordingly but the attack always has a chance to hit.

  
def primary_weapon_test(src, tar):
    """
    Test for a hit using Source's primary melee weapon.
    """
    hit = skill.primary_hit_rating(src)
    defend = skill.defense_rating(tar)
    return bool(random.randrange(defend + hit) > defend)

One of my goals is to avoid hard-coding rules as much as possible. So rather than telling a magician he cannot use plate armor, I'd rather use his guild's skill modifiers to provide more benefit and AC from a robe but, if he really wants to, he can dress up in heavy plate. Same thing for weapons.

Similarly, learned abilities wont be guild specific but will require certain skill values to obtain. A potent healing spell might be available to a cleric at level 10, a druid at 20, and a templar at 40 depending on their healing_magic modifiers.

Character Stats

2010-01-30T09:03:00.000-08:00

I have finally settled on a set of character stats to use for the game. I've been torn over using a generic (some may say tired) but immediately recognizable D&D inspired set like STR, DEX, INT, WIS, CON, CHR versus making up completely different ones with the risk they'd seem needlessly exotic and labored.

I wanted to split them evenly between physical and mental attributes with as little overlap as possible. For example, I've always found dexterity and agility awkwardly close to each other.

Physical Stats

Brawn - strength, heartiness, and balance.
Vigor - stamina, pain tolerance, and body recuperation rate.
Precision - dexterity, grace, accuracy, and physical reaction time.

Mental Stats

Knowledge - memory, education, and life experience (street smarts).
Faith - confidence, willpower, zealotry, and mental recuperation rate.
Cunning - intelligence, ingenuity, and mental reaction time.

An even split meant either 4, 6, or 8 stats -- 4 was too few and 8 was too many. We want different character guilds/classes to prize different stat combinations without things getting out of hand. Let's also try to make mental attributes appealing to melee classes. Monks should want faith and rogues cunning. Faith might seem like an odd word but it will fit in the setting I'm planning. Lastly, let's drop the wisdom versus intelligence caster meme.

Application

For every 10 points in a given stat, the character will receive a 1% bonus towards related skills. In the case of negative stats, characters will suffer a 1% penalty per negative stat point.

Key-Value Data Loading

2010-01-27T08:09:00.000-08:00

I wanted to follow up with an example of loading an avatar's persistent dictionaries from a key-value store in the SQLite database;


def load_account(client, name, uuid):
    """
    load a previously created account.
    """
    client.send('\nWelcome back, %s. Your last visit was %s.\n\n' %
         (name, last_on(name)))
    ## Create an in-game Avatar from stored data
    avatar = Avatar(client)
    ## Read from database
    avatar.profile = fetch_kv_dict(uuid, 'profile')
    avatar.resources = fetch_kv_dict(uuid, 'resources')
    avatar.skills = fetch_kv_dict(uuid, 'skills')
    avatar.worn = fetch_kv_dict(uuid, 'worn')
    avatar.carried = fetch_kv_dict(uuid, 'carried')
    avatar.abilities.update(fetch_kv_set(uuid, 'abilities'))
    play_account(avatar)

Just in case it wasn't clear. You may notice an absence of a 'stats' dictionary. Character stats will be computed based on race + gear, so aren't saved.

Persistence

2010-01-27T07:43:00.000-08:00

I've had a few questions about how I plan to handle persistence, as in saving the states of game objects in case the server is restarted. The quick answer is I'm not -- with the exception of player character data. Bogboa is using two forms of data storage; YAML files and an SQLite database. I'll discuss each.

YAML Files

Currently, YAML is the only third-party library used in Bogboa. I didn't want to use any really, but YAML is such a human friendly format that I went with it.

On startup, the world is created from one or more directory trees filled with YAML files that define individual rooms, items, races, etc. This is a one-way conversion where each YAML file is parsed into a Python dictionary that is used to set attributes of game classes. One of my long-term goals is to support reading these YAML trees from zip files so that designers could release adventure modules that contain complete dungeons with new monsters and items that load seamlessly into existing game worlds. This is one of the reasons I'm using UUID's for keys, since they don't require multiple developers to coordinate or negotiate around potential collisions like vnums do.

So restarting the server cleans every floor of dropped loot and every dead NPC is alive again. This appeals to me because it's simple and troubleshooting scripts is easier from known states.

SQLite Database

Starting in Python 2.5, SQLite3 is part of the standard library (and a kick-ass little SQL database) which makes using it a non-brainer.

My early tables were pretty vanilla with columns; (name, race, level, guild, stat1, stat2, etc) and I was always changing them. Also, I was using a lot of sub-tables to hold information like skills, inventory, and character flags. These sub-tables all had nearly identical structure; (character_uuid, skill_name) and (character_uuid, inventory_slot).

At the same time, I was making structural changes to how I split player from their avatars (which is why the codebase is currently b0rked). I knew that the closer I handled avatars like NPCs the easier things would be down the road. Moving all the various traits into dictionaries was helpful and this transition to key-value thinking migrated to how I stored character data as well.

What I wanted was a way to load whole dictionaries at a time but update individual key-value pairs on the fly. When you log in, your character's profile dictionary is retrieved containing (name, race, guild, level, ...) and when you gain a level, your characters (profile + level) record is incremented by one and if the server crashes a moment later you, hopefully, didn't lose it.

One of the nuisances of SQL is you often have to do a SELECT before you can save data because sometimes you cannot be sure if you need to use the INSERT or the UPDATE command. SQLite supports a non-standard but convenient variation of this called INSERT OR UPDATE. The catch is the key has to be unique.

What I did was make the key = (Character UUID + Some Catergory Name + Key Name);


CREATE TABLE IF NOT EXISTS key_value
    (
    uuid TEXT,
    category TEXT,
    key TEXT,
    value TEXT,
    PRIMARY KEY(uuid, category, key)
    );

In the above example, the category name would be 'profile'.

Reading all the rows of a category would look like;


SELECT key, value
FROM key_value
WHERE uuid = ? AND category = ?;

And saving an individual key-value would look like;


INSERT OR REPLACE INTO key_value (uuid, category, key, value)
VALUES (?, ?, ?, ?);

Everything I need to know I learned from D&D

2010-01-16T10:22:00.000-08:00

Clever presentation by a guy who compares software development to playing Dungeons and Dragons:

All I Need To Know About Life I learned From Dungeons and Dragons. An IgniteOKC Talk. from Chad Henderson on Vimeo.

MUD Game Programming

2010-01-07T16:14:00.000-08:00

I believe the only book ever written as howto for creating a MUD was MUD Game Programming by Ron Pelton. Originally published in late 2003, it's been out of print for a while and I finally managed to snag a used copy for a reasonable price. It even came with an unopened CD.

I don't expect to glean a great deal from it having already written an asynchronous server, plus Pelton is using C++ where I'm doing everything in Python. Still, it seems like a quality book with a lot of example code. Books on game programming tend to suffer a poor signal to noise ratio. There's a ton of dreck out there, especially garbage written by industry insiders who have no clue about programming but feel like they can help you with their experience interviewing other non-programmers. Ugh. Even worse are the ones aimed at teens -- clearly targeting the well-intentioned but useless gift from Mom category.

Pardon the rant.

Anyways, I've read the first couple chapters on networking and socket programming and Pelton is delivering the goods. He is specific and writes in an friendly, engaging manner. He gets extra points for covering Linux in addition to Windows. Recommended (if you can find it).

Work Around

2010-01-02T08:58:00.000-08:00

--start of edit

Well, it turned out that the approach listed below does not find methods from base classes. I revised it to use __getattribute__() instead which returns a bound instance of the class but that only lives for the scope of the cmd_driver() method:


def cmd_driver(self):
    ## call the driver method for current state
    self.__getattribute__(self.state)()

---end of edit

My last post detailed a garbage collection issue I was having when an instance of the User class referenced itself using a bound variable. I got around it changing my state property to a string variable holding the name of the method I wanted to call and then calling said method via some class introspection;

def cmd_driver(self):
    ## call the driver method for current state via class introspection
    self.__class__.__dict__[self.state](self)

That kind of introspection always feels like duct tape.

I should point out that Python's garbage collector probably would have deleted those User instances eventually and that I could have manually ended the connection by calling socket.close(). I prefer the immediate garbage collection closure because it's an indicator that everything is running smoothly.

Dynamic Methods and Garbage Collecting

2009-12-23T14:15:00.000-08:00

I really enjoy the Python programming language. Even when it bites you, it takes you on an interesting journey.

In the MUD, I use the term Client to refer to the session with the user at the other end of the wire. The Client is passed to a User object that represents the player in some state or another. When a User gets deleted it gets chomped up by Python's garbage collector which should delete the client which in turn should delete the socket which fires the socket's close() method on the way out and gives the cat a fish, err, drops the user resulting in the famous 'Connection closed by foreign host..'

Only it wasn't.

Deleted clients and "disconnected" users were hanging around typing to unmonitored, uncaring sockets. After a bit of poking I found the problem was some cheap hackery I was using for the login process. I was using a property called "cmd_driver" like a state machine, changing it to point to the next method I wanted input to go;

self.cmd_driver = self.get_password

Turns out, this was setting cmd_driver to a bound method; one that is wrapped inside a reference to the an instance of the class, which in this case was itself. This caused the reference count to increase by one and avoid the garbage collector.Here's a demonstration snippet;

>>> class A(object):
...     def __del__(self):
...             print "__del__ called"
...     def foo(self):
...             pass
...
>>> a = A()
>>> del a
__del__ called
>>> a2 = A()
>>> a2.bar = a2.foo
>>> del a2
>>>

So I need to work out a healthier version of the state machine.
Maybe one that calls unbound methods of the class or instance methods
via some introspection.

Random Name Generation

2009-12-18T14:23:00.000-08:00

A few years ago I was playing around with a random name generator. My approach was to cobble together random letter combination like;

leading consonants + vowels + inner consonants + vowels + closing consonants

Basically, I was aiming for something pronounceable with commons letters weighted to appear more often. It produced output such as;

Votharn Eristacark Iplortidot Birtoil Udaeteahieb Aceastoherk Reloist Tharnog Wasterk Femewelav Ublyrrielic Cekird Owritothol Hoogoh Obloukajarriem Sleebont Niestart Pekev Lirtooth Efentoidagix Klyckas Yryfesat Klooton

Yeah ... that's really, really awful.

So I decided to give it another whack. This time I started with the premise, 'what sounds most like a name?'

Names do!

I found a couple files with over a thousand of the most common male and female first names on the US Census Bureau's web page and started playing. I wrote a Python script that used regular expressions to slice a batch of words into three lists;

List 1 = Zero or more vowels + One or more consonants at the start of the word
List 2 = One or more vowels + One or more consonants inside the word (not at the start or the end). We can get 0 or more of these patterns depending on the word.
List 3 = One or more vowels + Zero or more consonants at the end of the word.

Side note: If you haven't dug into regular expressions yet I highly recommend you check them out. I avoided them for years and now they're an essential part of my programmer tool box. Another big plus is their utility spans multiple languages.

I also tracked the frequency of each pattern, sorting by most common first and discarding the rares. Finally, I dumped the output formatted as Python lists that I could paste right into the source of the next script.

import re
import operator


_FILENAME = 'data/elves2.txt'
_CULL = 1

## Match 0 or more vowels + 1 or more consonants at the start of the word
_LEAD = re.compile(r'^[aeiouy]*(?:qu|[bcdfghjklmnpqrstvwxz])+')
## Match 1 or more vowels + 1 or more consonants inside a word (not start/end)
_INNER = re.compile(r'\B[aeiouy]+(?:qu|[bcdfghjklmnpqrstvwxz])+\B')
# Match 1 or more vowels + 0 or more consonats at the end of a word
_TRAIL = re.compile(r'[aeiouy]+(?:qu|[bcdfghjklmnpqrstvwxz])+$')


def token_lists(names):

   lead, inner, tail = {}, {}, {}

   ## Populate dictionaries; key=pattern, value=frequency
   for name in names:

       match = re.match(_LEAD, name)
       if match:
           pat = match.group(0)
           count = lead.get(pat,0)
           lead[pat] = count +1

       matches = re.findall(_INNER, name)
       for pat in matches:
           print pat,
           count = inner.get(pat,0)
           inner[pat] = count +1

       match = re.search(_TRAIL, name)
       if match:
           pat = match.group(0)
           count = tail.get(pat,0)
           tail[pat] = count +1


   ## Convert dicts to a list of tuples in the format (pattern, frequency)
   lead_srt  = sorted(lead.items(),key=operator.itemgetter(1),reverse=True)
   inner_srt  = sorted(inner.items(),key=operator.itemgetter(1),reverse=True)
   tail_srt  = sorted(tail.items(),key=operator.itemgetter(1),reverse=True)

   ## Build lists of patterns ordered most to least frequent and cull rares
   lead_list = [ x[0] for x in lead_srt if x[1] > _CULL ]
   inner_list = [ x[0] for x in inner_srt if x[1] > _CULL ]
   tail_list = [ x[0] for x in tail_srt if x[1] > _CULL ]

   return lead_list, inner_list, tail_list


if __name__ == '__main__':

   names = open(_FILENAME, 'rt').readlines()
   lead_list, inner_list, tail_list = token_lists(names)

   print '#', len(lead_list), len(inner_list), len(tail_list)
   print '_LEADS = ', lead_list
   print '_INNERS = ', inner_list
   print '_TAILS = ', tail_list

Next I used a script to assemble random names from these lists. Here's the one for male names:

import random


_LEADS =  ['d', 'j', 'm', 'r', 'l', 'w', 'c', 'h', 'g', 'b', 'br', 't', 'k',
   'n', 's', 'cl', 'fr', 'f', 'p', 'st', 'v', 'ch', 'sh', 'gr', 'tr']
_INNERS =  ['er', 'ar', 'el', 'or', 'an', 'ic', 'arr', 'am', 'ol', 'on',
   'al', 'en', 'ill', 'in', 'err', 'and', 'il', 'om', 'et', 'arl', 'ev',
   'ac', 'ust', 'av', 'ert', 'enn', 'ent', 'ath', 'onn', 'it', 'os', 'enc',
   'yr', 'em', 'ist', 'anc', 'arc', 'ich', 'as', 'est']
_TAILS =  ['o', 'on', 'e', 'y', 'ey', 'er', 'in', 'an', 'ie', 'io', 'en',
   'is', 'el', 'us', 'es', 'as', 'ian', 'ed']


def namegen():
   syllables = random.randint(0,1)
   if random.random() > .85:
       syllables += 1
   name = random.choice(_LEADS)
   for x in range(syllables):
       name += random.choice(_INNERS)
   name += random.choice(_TAILS)
   return name.title()


if __name__ == '__main__':

   for x in range(100):
       print namegen(),

Which gives output like;

Tyron Frian Grathan Charcan Tren Garrian Stasas Cholian Dites Ris Tie Non Lin Lon Wian Wio Ramas Lo Larus Pan Cio Wasie Mely Chie Levey Bustel Lillen Ben Ponny Panian Nyrus Bre Raso Stel Fasis Konandas Starrin Hian Starlio Rey Jathen Frander Ven Talamio Samin Ches Handey Sterian Nencin Sathon Ponel Citel Momen Wus Rencey Dence Rencan Bevon Jo Bre Tis Non Heved Ne Shestas Lales Ferrus Werrus Foso Standie Ver Gis Giner Ver Nin Res Veled Clon Geler Mustin Gio Bry Juste Shanan Cled Trely Chon Trin Binis Jinen Jacy Ralio Bo Metel De Sian Brie Fanan Donen Jed

Seeding with female names, I get;

Alianne Cler Cishel Kroller Namie Dah Kyn Niton Hie Trosancel Cher Na Angy Sestin Jah Dathe Pin Traton Teris Dishon Goren Sheny Frindis Chalin Frie Lolleen Ware Chrena Hy Veannon Dyn Padica Sher Chie Kon Brollis Cisi Gy Chey Kreni Dulani Gancis Shancey Satheen Chreanny Shy Clin Cessia Kriner Shestie Hancah Ner Trorer Ger Tren Ramerrer Freanne Kaurah Frolah Kritah Harley Kisten Eleen Trellyn Chiannel Trosi Alisin Genery Cla Mie Jate Shosacey De Angoron Kis Gianon Mandite Chryn Wer Shadalie Polon Gita Ner Fron Va Chrabica Vatia Clia Tacel Rareen Treen Angia Henen Angin Poreen Eleannel Ken Brer Branca Hesta

MiniBoa

2009-12-17T05:36:00.000-08:00

Over on Mudbytes, Idealiad (aka Kooneiform) started a thread about creating a Python Socket MUD -- a very tiny socket library that Python coders could use as the basis for their MUD projects and experiments. There already were a few of these for other languages such as TeensyMud for Ruby but nothing for Python. I really liked this idea and, as I had a working Telnet server already, I decided to repackage my network modules as MiniBoa. Instead of the BogBoa's GPL licensing, I switched to the more permissive Apache 2.0 (one of the recommended licenses for maximum compatibility with the Python's own).

To be honest, the code was a lot messier to convert into a stand-alone library than I expected -- because this was the first code I wrote for BogBoa and I was hooking into it less than gracefully. Since I didn't want to maintain two copies of (mostly) the same modules, I decided to revamp BogBoa to use MiniBoa for networking.

You can find code and documentation at the project page and some discussion on this Mudbytes thread.

Days and Nights

2009-02-04T05:53:00.000-08:00

My first trip through Kithicor Forrest when like so:

"A Zombie Trooper begins to cast a spell."
"You have been slain by a Zombie Trooper."

Here I learned the lesson of not trying to pass through Kithicor Forrest at night. I would have to wait 12 hours for daylight (or 36 actual minutes). Kithicor is a zone in the online game Everquest. Days in Everquest are 72 real-world minutes long.

I've been thinking about how to handle the passage of time. I knew that I wanted days to be much shorter than real time. World of Warcraft uses actual time. As a player, I found EQ's system much more engaging. It would actually get dark, vendors went inside their homes, werewolves came out, and Kithicor Forrest filled with $*@#& zombie troopers.

WoW just lowers the gamma a touch. Boring. My guess is Blizzard chose real time to simplify the scheduling of in-world events with real-world holidays. The downside is you can't ask players to wait eight hours while an NPC goes to bed so vendors never sleep.

I decided to go with Real Time x 12 where a game day equals two real hours. That gives us an hour of daylight followed by an hour of night for sneaky rogue-style stuff.

I also wanted to (roughly) align game years to real months. I decided to junk game months entirely since they were only about two and half actual days long. You've probably seen the Chinese Calendar where they cycle through years named after animals. That's what I wanted. Named years that cycle as real months pass. You get an illusion of years passing contained within an endless, MUD friendly cycle.

Now, how to implement it?

Some games use a tick counter that tracks time but my design isn't based around game ticks -- plus I want time to pass even if the server is taken offline. Worse, I really don't want it to revert to 00:00:00 whenever I restart it like an unplugged VCR.

My scheduler was already polling time.time() which returns the number of seconds since Jan 1, 1970. Since this is an imaginary world, I can get away with a few things. Real years are about 365 and 1/4 days long, hence the need for leap days. If I use a solar year instead of a calendar year I can forget about leap days.


## Number of seconds in a solar year
SOLAR_YEAR = 31556925.215999998

To align the first game year I decided to define a mini-epoch of January 1st, 2009. Consulting the UNIX timestamp generator gave me:


## UNIX_ADJ is used to align the start of game time with Jan 1, 2009 00:00 GMT.
UNIX_ADJ = 1230768000.0

Next, I defined a game cycle that gave me a spot to speed up time in case I want to test things:


## GAME_CYCLE describes the relation of twelve game years to one real year.
## If you want to speed up or slow down time change the divisor.
GAME_CYCLE = SOLAR_YEAR / 1.0

Now, let's define some constants for computing relative days. As mentioned above, we probably wont use GAME_MONTH, GAME_DAY, or GAME_SECOND for anything. Instead, we'll describe the date in Julian terms like 'Day 240 of the Year of the Ominous Sounding Noun'. In our perfect orbit, game years are 360 game days long.


GAME_YEAR = GAME_CYCLE / 12.0
GAME_MONTH = GAME_YEAR / 12.0
GAME_DAY = GAME_MONTH / 30.0
GAME_JULIAN = GAME_YEAR / 360.0
GAME_HOUR = GAME_DAY / 24.0
GAME_MINUTE = GAME_HOUR / 60.0
GAME_SECOND = GAME_MINUTE / 60.0

The calculations are pretty simple. We can define CENTURY_OFFSET to tweak the displayed century in case you wanted the game to begin in 1100 or Stardate 26,301.


tstamp = time.time() - UNIX_ADJ
minute = int((tstamp % GAME_HOUR) / GAME_MINUTE)
hour = int((tstamp % GAME_DAY) / GAME_HOUR)
day = int((tstamp % GAME_MONTH) / GAME_DAY)
julian = int((tstamp % GAME_YEAR) / GAME_JULIAN) + 1
month = int((tstamp % GAME_YEAR) / GAME_MONTH)
numbered_year = int(tstamp / GAME_YEAR) + CENTURY_OFFSET
named_year= numbered_year % 12

Finally, we can also compute the current amount of sunlight for outdoor areas:


def sunlight(self):
  """
  Calculate the current sunlight level.
  Return an integer value in the range of 0 (Midnight) to 12 (Noon).
  """
  tstamp = THE_TIME - UNIX_ADJ
  hour = int((tstamp % GAME_DAY) / GAME_HOUR)
  return int(12 - abs(12 - hour))

YAML

2008-09-21T12:10:00.000-07:00

One of my goals was to have zero dependencies -- where all you would need is a recent released of Python to run the MUD.

I think I'm going to add one though - PyYAML. Because of how I'm doing object properties, I need to let designers script events for rooms, objects, and monsters. Which means a lot of text editing. Early on, I was considering XML for this, but it's a painful format to edit manually. YAML on the other hand, is a very tight, clean format meant for straight editing.

Subversion and Junk Files

2008-09-20T11:15:00.001-07:00

BogBoa is hosted on GoogleCode.com which uses Subversion for version control. I really like Subversion but often you need to tell it to ignore junk files like *.pyc (compiled Python programs) and *.aux (LaTex leftovers).

You can tell Subversion to ignore specific types of files by editing .subversion/config in your home directory and adding a line like:


global-ignores = *.pyc *.log *.out *.toc *.aux *.sqlite *.pdf

Test from Email

2008-09-19T14:40:00.001-07:00

This is a test message sent from email.

Signs, Portents, and Little White Stickers

2008-01-29T11:06:00.000-08:00

Remember that scene in Time Bandits when the giant creator's head was chasing them shouting, "RETURN WHAT YOU HAVE STOLEN"? Now picture the frozen noggin of Walt Disney saying it in the voice of a certain immortal/undead rodent.

I really like getting used books from Amazon. You can save a lot off the retail price and, so far, I've had great luck with regards to the condition of the books.

Last week I ordered Designing Virtual Worlds by Richard A. Bartle. Mr. Bartle famously co-wrote the first MUD. It arrived yesterday and I saw this sticker on the contents page:Interesting, eh? I sent Mr. Bartle an email and some scans which he added to his blog. He was even kind enough not to mention what a cheap bastard I was for buying it used.

I just hit chapter two and, so far, it is an excellent and entertaining read -- especially for someone like me that grew up on text adventure games and then bounced around MMORPG's.

"You are in a maze of twisty little passages, all alike"

2008-01-26T11:04:00.000-08:00

When I was a kid, a pack of us used to play Dungeons & Dragons and I was often coerced into the role of Dungeon Master. Yes, it was as nerdy as it sounds but hey, it was fun and really, really cheap entertainment. One adventure I ran my victims, err ... cohorts through required them jumping blindly into portals to go from the current section into the next (really, it was just a way to buy time as I made up the next part). Plus, I could make up anything without needing it be consistent with the previous setting.

They hated the portals.

They were right to. It was a cheap and crummy design.

I'm fleshing out the geography system for the MUD, e.g. moving from one location to another. Historically, these are called 'rooms' with simplistic, direction based linking between them. You're in 'The Dining Hall' and go 'north' to be in the 'The Kitchen'. The simplicity of this design lends itself to a text based MUD. I could sweat area dimensions and the coordinates of players, creatures, and objects but how do I convey that to a player in a meaningful way using words alone? If you have to kill the goblin king to get his scepter, do you really care what bearing and how many meters away he is?

One concern I had was dropping players into a lady and the tiger scenario where they type 'east' and suddenly find themselves in certain death. The answer to this is the same as it is in books. Foreshadowing. Alan Quartermain doesn't sail his canoe smack into the headhunters' camp. He finds skulls on sticks, burned settlements, gross nasty things that all say, 'turn the hell back, Dude.'

In other words, it's not a programming problem.

Parsing Commands

2008-01-20T11:02:00.000-08:00

This is a topic I thought about for a long time. My family thought I was just slacking about like a bum but I was really thinking. The challenge is converting what the player types into function calls -- only some function calls need more information than others and in differing order. I started with a huge, ugly IF-THEN sequence but quickly hated it. Plus, it wasn't very clean to expand.

I knew I wanted a dictionary lookup that would map verbs to functions and I wanted flexible control over which verbs different players could use -- 'equip sword' vs. 'cast fireball at Chadu'. The only common theme is every command begins with a verb.

I think my solution is both elegant and functional. I changed the dictionary to map verbs to functions and parsers. So the verb "tell" uses parser.dialogue (extract the recipient and the message) and "shout" uses parser.monoloque (no target, everything is the message).

Here's a snippet of where the Player class processes a line of input:

cmd = self.get_cmd()
verb, words = split_verb(cmd)

if self.has_ability(verb):
   parser, function = shared.ABILITY_DICT[verb]
   args = parser(words)
   function(self, *args)

Notice the call to self.has_ability? We can grant and revoke abilities easily.

More about the Event Scheduler

2008-01-14T10:42:00.000-08:00

In addition to the classic "main loop", the game will have an event scheduler. This is a queue for function calls. You pass it a command and the number of seconds from now in which to run it. This can be 1 / 1000 of second or years. Let's say you wanted to give a room some character by telling the players something like "You hear the scurrying of rats deep within the walls." Now, you don't want it to print every time someone enters or it seems canned and loses all effect. So you could do something like

event_scheduler.add(600, say_ambient, "You hear the scurrying of rats deep within the walls.")

So now the message will play in exactly 10 minutes. To make it even better, let's do this:

def the_rats():
  say_ambient("You hear the scurrying of rats deep within the walls.")
  offset = random.randrange(600,1200)
  event_scheduler.add(offset, the_rats)

We just made a function that, once called, continues to re-schedule itself forever in random intervals between 10 to 20 minutes apart -- and the best part is we can forget all about it.

Let's say we wanted to implement a four-hour game-day. We could write functions for noon(), dusk(), midnight(), and dawn() which did things like sent farmers to the fields and turned vampires to dust in the sunlight. Each one of these would re-schedule itself, just like the_rats() did, but with a four hour delay (14,400 seconds). So in our start up code we do something like:

# Call noon right now
noon()

# call dusk() in 1 hour
event_scheduler.add(3600, dusk)

# call midnight() in 2 hours
event_scheduler.add(7260, midnight)

# call dawn() in 3 hours
event_scheduler.add(10860, dawn)

And our world begins to spin.

An even more efficient version would have each daily event schedule the next one to fire in one hour, round-robin style.

Progress Check

2008-01-13T10:41:00.000-08:00

For the MUD, I have the following features done:

Asynchronous TCP communications -- Multiple Telnet clients can connect, send, and receive.
Event Manager -- Function calls can be scheduled to run (float X) seconds in the future.
Logging -- Log messages get recorded in a text file and displayed on the server's terminal.
SQLite Database storage -- SQLite3 is now part of Python 2.5 so I'm still on my track for my goal of zero dependencies.
ANSI Color Tokens -- This is something I did in my BBS days. If you want a message to show in color you can enter a simple code that begins with a caret. ^y is yellow and ^Y is bright yellow.
Word Wrap Function -- This takes a block of text and, given a target column width, formats it for easy reading.
Kicking Idle Clients -- Automatically drops clients who remain inactive for a period of time.

Here's an example of the word wrapping using four paragraphs from the Declaration of Independence. The first is the text simply dumped to the terminal:

Here's the thing run through the wrap_text() function:

I wanted it book-like and easy to read so we're padding the left and right and indenting the paragraphs slightly. A way more sophisticated function would break words with hyphenation.

MUD!

2008-01-11T10:37:00.000-08:00

Back in the early 90's I ran a computer BBS -- that's where someone spends thousands of dollars to let other people play with his computer. I ran a number of games like Tradewars 2002 , Global Wars, and Murder Motel where you had X number of moves to find a weapon, victim, and hiding spot. It was multi-one-player-at-a-time, but great fun. Joe and Bill Trebing took pity on some poor kid and invited them into their Tradewars corporation. The kid thanked them by activating the laser cannons, kicking them out of the company and into space, then blasting them to sparkley dust.

I wrote a chess game where people could play each other and some utilities like a message tosser that converted from RBBS format to TriBBS.

Last weekend I started writing a MUD in Python. It will be a text based game that you Telnet into. Yes, it's extremely retro but makes for an interesting geek project and, since I use a lot of Python at work, is a good way to brush up on my programming skills. And, unlike the old BBS games, this will be real multi-player.

At first, I was going to use a library called Twisted Matrix for networking but then decided to try writing the whole thing using only those libraries that come with Python 2.5.

The trick is to design it to be non-blocking. What is blocking, you ask? Imagine a restaurant with only one employee. He's the cook, waiter, busboy, dishwasher, and cashier. In walks Mr. Ficklehead who can never make up his mind. A blocking waiter has to stand there while Ficklehead reads the menu front to back. The food burns, the customers don't get seated, people run out on the check -- a mess.

A non-blocking waiter runs to every tables and goes, "Haveyoudecidedyet? No? That'soktakeyourtime, I'llbebackinasecond" and whoosh, moves on. Everything gets a split second of attention.

Another method is call multi-threading which would be like cloning yourself. That sounds good until your run into problems like telling three clones to wash the car, change the oil, and drive to the store for groceries. Keeping any two clones from flopping on the couch to watch reruns of Scrubs is just as tricky as it sounds. Besides, some of the Python libs are not thread safe to begin with.

So I'm going with single threaded asynchronous networking.