Sunday, December 28, 2008

DMG Based Dungeon Generator

In my current 3.5 campaign the players will be shortly chasing after the Keys of Time, which are spread all over various alternate dimensions. Since I totally got bit with the old-school bug I've decided one of the keys will be found in an old-style Dungeon Crawl Dimension. The characters will start in a 10'x10' dark room(hope they have someway to make light). In the corner will be a 10' pole, a lantern, bundle of torches and a backpack filled with 3 flasks of oil, 10 spikes, a hammer, 50' rope, flint&steel, 1 wk iron rations, and a potion of healing. In each wall will be a wooden door, stuck of course. From there I planned to use the random dungeon generation tables from the DMG. But they turned out to be too unwieldy for use during game. So, I whipped up this simple program to do all the rolls and table lookups for me.

After doing a couple of test runs, I'm a little disappointed with appendix A. Not enough stuff (monsters/treatures/traps), too many freaking wide passages. Too many levels up/down (for my purposes).

For v2 I'll change passages widths to 50% 5', 30% 10', 20% other. Make Traps/Treasures/Monsters more common. Add in room types and dungeon dressings from the other appendixes. Maybe simplified tables to generate magic items, wandering monsters.

There's probably a million of these, this one is mine. Python source

Python is keen, by far my favorite programming language. It's a bit like modern rules lite RPG's, there's very little syntax and "rules" to it and what there is has a consistency. Makes it easier to tinker with. For instance the ability to redefine how objects are converted to strings, __str__, lets me define random tables that "roll" themselves when printed. Like so
Door = table_d20(
  ( 6, "Door left leading to a", Beyond_Door, ),
  (12, "Door right leading to a", Beyond_Door, ),
  (20, "Door ahead leading to a", Beyond_Door, ),
Beyond_Door = table_d20(
  ( 4, Passage_Width, "parallel passage extending 30' in both directions. Or 10'x10'.", ),
  ( 8, Passage_Width, "passage straight ahead.", ),
  ( 9, Passage_Width, "passage ahead/behind 45deg.", ),
  (10, Passage_Width, "passage behind/ahead 45deg.", ),
  (18, Room, Contents, ),
  (20, Chamber, Contents, ),
The simple python statement print Door will randomly roll a d20, say 11, look up matching row in Door table print "Door right leading to a ". Then roll another d20 this time on Beyond_Door table, which leads to other tables and text and so on.

Those are interpreted (along with a few helper classes/functions) by this relatively short class. Not stupendous but I like how simple/clean/flexible the table definitions are.
class Table(object):
  """Object that when evaluated into string will return random result from table"""
  def __init__(self, dice, *table):
      """@param dice: callable that returns something comparable to x.
      @param *table: list of tuples (x,foo1,foo2,fooN) where x is comparable to return value of dice and foo? are evaluatable into strings.
      self.dice = dice
      self.table = table
  def __str__(self):
      """@return: foo1,foo2,fooN stringified and space separated, from row in table where x >= return value of dice.
      return " ".join(str(s) for s in self.get_result())
  def get_result(self):
      roll = self.dice()
      for row in self.table:
          if row[0] >= roll:
              return row[1:]
      return self.table[-1][1:]

def table_d20(*table):
  return Table(lambda: random.randint(1, 20), *table)
The table_d20 is a helper function to return a Table object preset to use d20 for its dice rolls. It takes a list of arguments, *table, which in our case are the rows of the table. It passes those along with a lambda function that returns a number between 1 and 20 (our d20 die). We need to wrap the random.randint in a lambda so it's callable, since we want a new random number every time we "roll" on the table.

The Table classes __init__ is nothing special. And the __str__ function just applies the str builtin to each item in the list that self.get_result() returns. It then compiles them all into one string, added a space between each one. If you did now know __str__ gets called whenever the object is converted to a string. e.g str(obj) is basically obj.__str__()

The get_result has all the action. It "rolls the dice" then iterates over the table rows looking at the first item until it finds a match. It then returns all but the first of that row's items. There's a fail safe, if no matching row is found it returns items from the last row.

All Time Most Popular Posts

Follow by Email