diagramming play as conversation

Recently a friend (whom I respect and who is not Wrong — that’s not what this is: it’s a divergence not a rebuttal) posted a revelation inspired by a symbology for interactions in an RPG. They posted this:

conversation

…and noted that since each node is apparently equal (and certainly equal as humans ought to be) then the nodes were in fact interchangeable, allowing this:

reflexive conversation

EDIT: turns out I misinterpreted my friend’s diagram and conclusions. Not all that uncommon for me! Anyway, the following is still fun and relevant, it’s just that the above is hypothetical and not necessarily something anyone anywhere has actually concluded.

I think that while this is true, it’s trivially true because of the simplicity of the symbology. That is, it implies a truth that is in fact only revelatory because the symbology ignores so much that is interesting in the ref-player relationship of a traditional game. It’s revelatory but it doesn’t do any work for you. Let’s revise this diagram a little in order to understand the true design cost of implementing the egalitarian structure implied above.

My first cut would be to recognize that while this is a conversation, it’s a conversation with privileged roles. Rather than a simple two-way discussion, what’s really going on is this:

asymmetric conversation

That is, the player offers narration until an action triggers the ref’s response, and their response is to inform the player of an update to the shared world’s state. This might be as simple as:

PLAYER: “What colour are the walls?”

REF: “Orange.”

Until this exchange, every player and the ref have a different colour or no colour in mind. It’s not until the ref updates the formal state by declaring it that the walls resolve to a particular colour. So this implies that the ref is storing some state:

stateful conversation

We obviously need to do a bunch more work to make it as symmetrical as we want! Migrating the ref role is going to need some design work, even if it’s just a declaration that we are not going to care about this stored state beyond agreeing that everyone’s internal idea of what has gone on before is considered equal. When inconsistencies arise, perhaps the current declarator of the state is always considered correct. Or perhaps there’s a physical annotation of state that’s literally handed over. Whatever we agree, it’s necessarily part of the design and this richer symbology reveals that that work is necessary.

For example, if we wanted to imply that everyone’s internal idea of the world state is equal until revealed, we might diagram like so:

everyone has state

This choice of diagramming scheme, this symbology, encodes the fact that each player has a different state stored. That’s something you need to deal with (however easily — I’m not saying it’s hard or easy, just that it’s a design decision) and the symbology has made it absolutely clear: those are not the same state storage boxes.

And then, it’s not that simple. Nothing ever is. Let’s say everyone has an idea of what colour the walls are and it has not been declared. Now it may be the case that a current ref not only has an image of the walls as orange, but also has a reason for this. One that implies some future conflict or interesting reveal. If the ref role is handed over before that can be brought into play, and the wall colour is revealed to be green, then that future state (plans) would be obviated. So what we really have in trad ref structure is this:

stateful conversation with future state

Again, this is not an argument against ref migration but only that too simple a symbology will fail to reveal the work you need to do. The minimum work here would be to say that everyone’s plans are irrelevant until reveal: there are many possible future universes but only the current ref role (even if this is as simple as whoever declares a fact) gets to pick which one resolves as real and current. It also, happily, reveals alternate design possibilities: is it possible to somehow communicate future state ideas between people and therefore preserve some of the planning that naturally takes place as people converse about this fiction? Let’s say you note an exciting future state idea and put it on an index card in the center of the table and when someone takes a declarative (ref) role, they draw a card and decide whether or not to incorporate it. This implies further mechanism that might be fun — do you destroy the card or return it to the pile? Is there a reward for using it and how gets the reward? Is there a penalty for refusing it? Or even for using it? Again, a choice of meaningful symbology reveals the design space. Gives you clues.

While a simple symbology can be creatively stimulating, revealing (or more realistically suggesting, since it works because the symbology is incomplete and therefore possibly incorrect in practice) unexpected space on the map of all game design, it doesn’t really capture the work that needs to happen to open up and explore that space. You can do it by trial and error — just try sharing the ref hat around and see what happens — and that’s actually pretty good methodology for an RPG since testing is play and play is fun. But you can also extend the symbology and find out beforehand what the design work is going to be. Existing process diagramming tools are good for this (what I’m using here is a bastardized form of Data Flow Diagram or DFD (https://en.wikipedia.org/wiki/Data-flow_diagram) but any logical system for diagramming can be put to use to map for game design. I think the DFD is at once simple enough for anyone and also rich enough to be revelatory.

My patrons make these happen.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s