Working through Seclusium, each game entity tends to draw from multiple random tables. The number of input tables can get rather large. For example, a single magical item requires around 20 tables. I think this is part of what makes using Seclusium feel somewhat cumbersome in practice, despite the large number of interesting juxtapositions.

This leads me to a hypothesis: the optimal number of tables needed to create a complex, unique game entity is around 7, probably at least 5, and almost certainly less than 10. Beyond 10, I suspect there will be diminishing returns from the the extra degrees of freedom. Less than 5 inputs, though perhaps useful for many things, seems to offer more room for elaboration (given that you are trying to create something that will play a large role and thus should have a decent amount of detail). It is probably not a coincidence that this seems related to the magic number seven.

What constitutes a single table is somewhat mutable, as two d6 tables could be combined into a single d66 table (36 entries), thus “number of tables” here is really a proxy for some other category relating to complexity, so you cannot take this “rule” too literally. That said, such combination of tables can be a technique in and of itself, as it allows the author to potentially do more work for the end referee at the cost of using slightly more storage (two d6 tables require 12 entries, while one d66 table requires 36 entries).

In general, I think this comes down more to an issue of layouts than anything else, but it is still worth considering the various tradeoffs when creating a tool. Compare the somewhat pre-integrated d100 tables of Vornheim to the many small tables required by Seclusium, for example. Another related technique is tables with multiple columns that can either be used with one roll (just read across all columns) or multiple rolls (one per column), as can also be seen in the Vornheim table below.

Part of the Vornheim aristocrats table, for comparison

Abulafia, if you are not already familiar with it, is a Wikipedia-like site for automating random tables. It allows you to create tools like this page, which is an automation of Patrick’s excellent experimental complex generator. However, Abulafia is not always a good solution. Specifically, it:

1. Requires the internet
2. Is not appropriate for automating tables from books that are not free
3. Needs a human to activate an account
4. Has a format that is not as elegant as it could be

This is not to say that it should not be used, but just to point out that there is space for alternative tools. This became particularly salient to me recently when I was using Seclusium, which has a large number of tables for each entity generated, on the order of 10 or 20 tables per thing. Rolling dice and pondering at the same time can be a useful technique for creativity, and I don’t want to discount that process entirely, but when there are this many tables I prefer some automation. For this reason, I hacked together an ugly little Ruby script which would allow me to do this locally with minimal hassle.

I created* my own random table format because I wanted minimal syntax. Why should every item require programming language cruft? That is not very accessible to non-programmers. What is my format? One file per table, one entry per line. This ends up being barely any format at all, which is perfect.

Without further ado, here is the core engine of the script. I will explain below how to use it, and provide an example.

<%-
Dir.foreach('tables') do |item|
  next if item == '.' or item == '..'
  instance_variable_set(
    "@#{item}_table",
    File.readlines('tables/' + item).map(&:chomp)
  )
  define_method("#{item}") do
    instance_variable_get("@#{item}_table").sample
  end
end
-%>
<%- # Place template below this line -%>

Now, that may look like a mess, but you don’t really need to understand it. In english, what it does is read each text file in the tables directory into an array, which is also wrapped with a random accessor function (that’s what the define_method call does).

Just download this example, which is an automation of Telecanter’s magic item spur. You will need to have ruby and erb installed** and be willing to open up a terminal. I use the ‘$’ character to denote a shell prompt.

$ unzip telecanter_magic_item_spur-2014-01-20.zip
$ cd telecanter_magic_item_spur-2014-01-20
$ ls tables/
descriptor
noun
power
range
type
verb
$ make open

The “make open” command will generate random results, write them to a datestamped file, and then open that file in your default browser. You should see output like this:

1. bright clothing that animates shadow of power level 4 (out of 10) with range touch
2. wondrous/weird clothing that deludes space of power level 6 (out of 10) with range area effect
3. scarred armor that dispels demi-humans of power level 1 (out of 10) with range area effect
4. ornamented clothing that evokes earth of power level 8 (out of 10) with range area effect
5. mundane weapon that conjures animal of power level 3 (out of 10) with range wielder
6. scarred weapon that shields fire of power level 8 (out of 10) with range touch
7. bright uncommon item that deludes monsters of power level 9 (out of 10) with range wielder
8. ornamented armor that conjures mineral of power level 3 (out of 10) with range wielder
9. ancient clothing that distorts animal of power level 3 (out of 10) with range distance
10. dark clothing that divines mineral of power level 10 (out of 10) with range wielder

You can also delete all generated files by running “make clean” within the directory (but don’t do that unless you actually want to remove the result files).

To create your own generator:

1. Copy the zip file to a new file and then uncompress it
2. Rename the resulting directory to whatever makes sense for your new generator
3. Create the new random table files within the tables directory
4. Rewrite the random_table.erb template to reflect the output you want
5. Zip that new directory if you want to store it as a single file or share it

The template is standard ERB format (you can google that), but the core of what you need to know is that to generate a random value, use:

<%= tablename =>

Hopefully it should be clear from the example random_table.erb file. The full generator-specific code for Telecanter’s magic item spur is, ignoring the loop:

<%= descriptor %> <%= type %> that <%= verb %> <%= noun %>
of power level <%= power %> with range <%= range %>

Given that this is ERB, you also have the full power of Ruby at your disposal if you want to do something complicated.

Remember, there’s nothing special about the random table files. They are just text files with one entry per line. Given that the template generates HTML output, the format of the resulting output can be customized using HTML however you like. You can see in the magic item spur example that it uses an ordered list.

Unfortunately, making this work on Windows is beyond the scope of this post, and for that I apologize. I suspect that all you would need to do is install Ruby though. Similar code in JavaScript would be more portable, but for various reasons the table file format would not be able to be as simple (because of browser security models not allowing direct access to filesystems), and I’m not really interested either in writing JavaScript data structures directly for the tables or in writing a converter.

I also know this is pretty janky beta-level code, and there are probably many ways to break it, but it has been really useful to me so I thought I would share it in any case.

One known issue: don’t include strange characters in the ERB file directly, as Ruby has some Unicode issues. Strange characters should be fine in the random table files, but may look ugly. You have been warned.

* “The nice thing about standards is that there are so many of them to choose from.” — Andrew S. Tanenbaum

** This should be true on all Macs with a relatively recent OS, I think.

Thanks to Josh Symonds for answering a few Ruby questions.