Midden of the Deep

Midden of the Deep is the third one-page adventure location.  Suitable for adding spice (or ammonia - eww) to any huge cavern that might once have held dragons (or other, magical, excreting creature).

Like its bretheren, Midden is systemless, but easily adaptable to crawly games like D&D, Torchbearer, Dungeon World and World of Dungeons.

UPDATE: Here's the map art, free for use under CC-BY-NC.

Map: Midden of the Deep

World of Dirty Dungeons

"World of Dirty Dungeons" blew my mind tonight. Our usual GM was out with a fractured shin. I was fresh off a weekend of West Marches-style World of Dungeons, so I volunteered to GM. I had nothing planned, though, so I figured this was as good a time as any to try out John Wick's "dirty dungeons".  So glad we did!

World of Dungeons + Dirty Dungeons

Really fascinating session.  To recap, dirty dungeons has the players create the scenario (we assume their characters have researched it during their downtime). In my off-the-cuff WoD adaptation, for every minor threat they added +1 to a party pool of one-time bonuses. For every major threat they got +2.  Players can draw up to +2 from the pool for any die roll.

For every five minutes they spend discussing, however, I get to place one major twist - their information is out of date, dangerously inaccurate in some way, or an unknown threat lurks within.


Mike suggested I come up with a title for the adventure, and I announced it was called 'Against the Fungus Queen' to groans all around, but in ten minutes the players had enthusiastically laid out an abandoned mansion surrounded by a stone wall, swarming with fungus men, atop a catacomb that leads to a magical lake where one can find the bizarre alien intelligence of the fungus queen.

Running a dirty dungeon was really strange for me - I was going through my usual cold sweats internally, trying to manage pacing, and really struggling because I didn't actually write this damned adventure!

In the aftermath, however, I learned that the players were actually quite engaged, despite this.  As invariably happens when people make things themselves, they're immediately hooked by it.  While I was thinking that the mansion's cellar was a bit of a slow point, the players already knew (via their session planning) that they still had to face the fungus queen's personal guards who milk the deathcaps for poisons,  the dangers of the underground watercourse they'd named, plus the queen herself. This was a suspenseful breather while they girded themselves for anticipated dangers, not a slow point! It's weirdly like DIY foreshadowing.

The other surprise is that I initially felt constrained by the fact that they only spent ten minutes planning, since that gave me only two twists.  Turns out I needn't have worried - welding all their ideas into a coherent situation (which took me about 15 minutes after they were done) gave me so much latitude, and the players themselves had already contributed ten points worth of dangers. This adventure was no slouch before I even got started!

In play, the players got about halfway through the stuff they'd designed.  WoD characters are not durable at level one, it's very much like B/X in that regard.  

I've gotta say it's terrifying as a longtime BW GM to roll d6 damage against someone who's only got d6 hit points.

Still, slow-moving fungal zombies can be managed until you get trapped underground, and a confined stairwell eventually claimed the life of Stephen's hatchet-wielding thief. It was a gross, inglorious death, but nods all around affirmed this was how we were going to play.

Dirty Dungeons also doesn't feel collaboratively "spongy" - once the players have had their input, the dungeon quickly coalesces into a place that feels totally under GM control, a place of unyielding walls and tangible dangers.  (I believe that one of the fundamental ingredients of tangibility is resistance.)  That was a surprise for me.

In practice, it feels like I'm getting something for free - I get weird ideas to make an interesting dungeon out of, I get license to make it my own and render it as an tangible, dangerous place, but the players are engaged to a degree that's normally only possible through deft GMing.

So, now my mind is boiling over with all manner of ideas - this totally feels like a suitable platform on which to inject a lot of stuff that I've been yearning for, namely "geographic advancement". I will write more about this in the weeks to come!

The Steeps of Ur-Menig

Here's another one-page dungeon, The Steeps of Ur-Menig.  This time it's a dark, wet hole in the ground - in the words of one reviewer, "a place devoid of meaning."

As with Stellarium, the Steeps is a system-neutral one-page adventure. With a few notes in the margin it will adapt easily to low-prep games like B/X D&D, Dungeon World, Torchbearer, or World of Dungeons.

UPDATE: Here's the art for the adventure. Like the adventure itself, it's CC-BY-NC.

Map: The Steeps of Ur-Menig

Stellarium of the Vinteralf

Just in time for the bone-chilling cold we're experiencing here in Toronto, Michael Atlin and I have put together a winter themed one-page dungeon, the Stellarium of the Vinteralf.

It's system neutral, and will adapt easily to games like D&D, Pathfinder, or Torchbearer with a few notes in the margin.

Enjoy!

UPDATE: To see other adventures we've made, check out the sidebar!

UPDATE: Here's the map art from the one-pager:

• Map: Stellarium of the Vinteralf
• Player's Map: Stellarium of the Vinteralf

Finding Prime Numbers with Leaping Frogs

Imagine a pond that contains a long line of lily pads, each labelled with a number, starting with '2', '3', and so on.

A scary stork enters the pond, looking for frogs!  Each turn, the stork will move to a new lily pad, starting with lily pad 2.

When the stork reaches a lily pad, it looks for frogs:

• If the lily pad has no frogs on it, the stork finds one in the water. Take a new frog token and write the lily pad's number on its back. Put it on the lily pad with the stork.
• If the lily pad already has frogs on it, the stork won't look in the water, so this lily pad does not get a frog of its own.

The stork then shouts, "Boo!"  This scares the frogs, who jump away. All the frogs jump forward a number of lily pads equal to the number written on their backs.  Frog #2, for example, will make the first leap from lily pad #2 to lily pad #4, and then later to lily pad #6. (It's okay for frogs to share lily pads.)

Stop after however many turns you like.  When you're done, the numbered frogs represent all the prime numbers that you found (at least from numbers 2 to whatever lily pad you stopped at).

When a stork first reaches a lily pad, all the frogs there are the prime factors of that number.  For example, when the stork reaches lily pad #20, the stork will find frogs 2 and 5 there.  (20 = 2 x 2 x5.)  Lily pad 19, however, is empty when the stork arrives arrives: the newly minted frog 19 indicates that 19 is a prime number, and there are no other prime factors (other than 1).

To summarize:

1. Move the stork forward one lily pad (on the first turn, place it on lily pad 2).
2. If the lily pad has no frogs on it when the stork gets there, make a new frog with the lily pad's number.
3. All the frogs on the stork's lily pad jump forward a number of pads equal to their number.

Consider a Simple Mathematical Process

Consider a simple mathematical process, like an algorithm that generates the digits of Pi. Pi never stops, so in a way, the algorithm provides a window into an arrangement of information that's infinitely long.

Now look at a slightly more complicated process, such as Conway's Game of Life. Much like the Pi-computing algorithm, this is just another mathematical process, but the arrangement of information it describes is somehow richer: the game represents a 2D space evolving over time, with gliders, glider guns generating them, and so on.

What's interesting about both of these is that the "world" defined by the algorithms is in some way independent of actually running the simulation. Two people who calculate Pi will come up with the same answer. You can calculate 1000 digits of Pi and come back half an hour later, and calcluate another 1000 digits, and you'll have the same 2000 digits as someone who did 2000 at once.

Similarly, two people who run Conway's game (from the same starting conditions) will watch the same set of events unfold. Just as with Pi, they can stop the simulation, take a coffee break, and turn it on again, and the world inside continues completely unaware. You can rewind it, run it again, and it's all the same.

So in a way, simulations are a way of exploring a mathematical space. The existence of that space, in some ways at least, is independent of whether and when we explore it. The fact that a certain collision between 13 gliders happens on turn ten billion of a particular game seed is independently discoverable - it's already there, encoded in the rules, awaiting our discovery.

Now consider simulated worlds that are rich enough to develop artificial life, sophisticated enough to be self-aware. (By this, I mean that the simulated beings have an internal model of their world that includes a representation of themselves.) If you're a materialist, I think it's a short step to imagine that such beings could have an experience of themselves that's as rich and as convincing as ours is.

Nevertheless, we could pause that simulation, rewind it, run multiple copies, and none of this would affect the experience of the beings inside, because their experience is wholly encoded in the interplay of information that the simulation rules describe.

Much like the glider collision, or the 100th digit of Pi, their consciousness is already there. Running the simulation just allows us to experience it. Their world is real, to them. Even if we don't run the simulation.

Even if we don't .. invent it?

Now, if we discover that our world is based on a set of principles that could, in theory, be simulated, then what follows is that our world might not be 'real', either. Nobody's running it - nobody needs to!
Maybe somebody is running it, somewhere in another universe, but all that means is that they're exploring part if it. It doesn't mean that they're creating us, just that they know what we're up to (if they've run it this far).

Actually, this line of reasoning pretty much guarantees that an infinite multitude of different meta-worlds are exploring our universe through simulations, as well as all possible other universes, just exploring different parts of it.

Autocomplete & API Design

Autocomplete Rocks

As an avid Eclipse user, I love auto-complete.  It feels like it's a big, easily overlooked boost to how I program.  Not because it saves a few keystrokes here and there, but because it provides such a boon to explorability of the APIs that I use.  Essentially, I'm querying my programming environment to see what my options are.

Seeing a list of IntelliJ's top 20 auto-complete features, there are some really neat ones - chain completion is particularly cool.  IntelliJ will inspect in-scope variables several levels deep, so it's able to suggest methods of in-scope objects that I hadn't even considered.

Basically, this is a specific, but handy, limited method of querying my codebase/libraries.  I can envision more complicates ones, such as a completion that would help me with that perennial Java I/O plumbing problem of how I get from a FooWriter to a StringInputStream.  Could an IDE make a few suggestions?

Auto what?

I'm also a frequent user of Apache Tapestry, and one of the things that occasionally confounds me about it is that whenever I get rusty with a particular component, I need to look at the documentation to see what I can do with it.

Not docs accessed through my IDE, but actually busting out a web browser, and navigating through some documents meant for humans to read.  Actual essays!

This is because, in Tapestry, you write event handlers by giving an ordinary method a special name:

public void onSelectedFromMyWidget() { ... }

Tapestry uses reflection to make the association between the this method, and the "selected" event thrown by the component with the name 'MyWidget'.

But here the IDE knows nothing about the meaningful names.  There's no object to inspect, no interface that defines all the callback methods.  If I forget that the event type is 'selected' for LinkSubmit components but 'action' for ActionLink components, I have to go to the documentation.  If I don't realize I've misremembered, my event handler simply never gets passed any events.

I recently learned that HLS codes in Emacs, I wonder if this is related!