Theoretical & Practical Proceduralism

 

Proceduralism is, first, a method of reading rules texts to understand the structures of play activity that they prescribe, rather than according to any particular rules or mechanics for specific (or even universal) situations within those play structures. Rolls for searching a room or forcing open a door are operations or rules; the dungeon crawl is a structure or procedure of play wherein these situations take place.

One way to understand procedures as the structuring logic of play is to imagine that you were playing a digital game on a console. The basic structure is that the console prompts you to act, you tell the console what you do, and the console determines what happens next before prompting you again. Any calculations that occur underneath the console interface to determine the outcome of situations etc. is merely a rule, i.e. an operation performed by the console or perhaps by the player. It is not an ordering principle of the back-and-forth conversation itself.

The conversation between player and referee or game-master is considered by some to be the atomic structure of a game, such as by Vincent Baker with respect to PBTA games [1] or by Prismatic Wasteland with respect to OSR games [2]. As such, it is never the distinctive feature of a game or rulebook. There are variations in the conversation as to when one party asks questions and the other answers, but it is here we begin to see differences in rulebooks and play cultures on the elaboration and expansion of the atomic conversation which is itself only an exchange, a discourse, between two parties. The systematic elaboration of this exchange, i.e. the ways in which that exchange is structured, is what we term ‘procedures’.

Base Terminology

To discuss the structures of tabletop games, it is useful to establish a broad vocabulary with which to discuss and compare different games. You can disagree with my definitions, but they are my working ones for the sake of building upon them later.

An agent is an entity that executes actions based on perceived internal and external circumstances. We can use the word ‘party’ to refer to a collection of cooperating agents, or as one side of a dispute against one or more other parties. It is intuitive then to use the term ‘agent’ with respect to the capability to act, and ‘party’ with respect to opposition towards other parties, even if these terms interact and intersect.

Also, agents are often represented with formal attributes (quantitative or qualitative) through which they relate to each other or to their own activities. The classic six ability scores, for example, quantify a character’s attributes within the scope of fantasy role-playing. Some characters are charming, others are dexterous, others are intelligent, and so on; this is represented through quantitative scores which tend to impact their chance of success at attempting certain tasks. We can refer to the set of such attributes and their formal representation, in general, as data and data structures; however, this is a different topic than the structures of activity, or the actions which agents take, even if the specifics of those actions are informed by their attributes (or the attributes of other factors).

A game is a set of circumstances and relations through which parties accomplish their aims as or through agents. It includes the fictional game-world, the operating procedures, the rules for operations, the actual or hypothetical agents who exist in it, data structures, et cetera. A game is the discourse in action along with what it is being acted upon and the various rules according to which it is structured. A game is distinct from a text which prescribes a game, but we can parse game materials as being representatives of games in practice with whatever caveats necessary (e.g. is the material self-contained or does it rely upon other materials or fiat to produce the activity described or, perhaps, implied?).

A player is a participant external to the game who animates an agent with desire. A player-character is the agent itself with respect to the external circumstances perceived and actions that can be performed; it is the player’s interface with other agents. Using Lacanian terms, the player is the subject who desires things whereas the player-character is the master signifier that interacts with and relates to other signifiers [3]. The player-character is part of a party insofar as the party is an assembly of agents with its own collective aims toward which the agents cooperate. The 'bleed' between players and their game characters can be described precisely in Lacanian terms through discourse as the interplay between the symbolic, the imaginary, and the real; see [3].

There is not a definition of referee or game-master that would be agreeable to everyone. One referee is external to the game but acts to simulate the game-world and to facilitate the events thereof, to inform agents the circumstances of their perception and then actions; in such a case the referee is not a player at all but specifically the non-player. Another referee is antagonistic to the player-characters as a party; in such a case the referee is a party themselves, and perhaps even a player as a desire which animates agents in the game-world. This is worth further discussion, but here I am looking at the referee fulfilling the specific function of determining the outcomes of player actions and simulating the game-world. Refer to [3] for a discussion on the difference between the symbolic role of the referee versus the individual inclinations of a particular referee; the simplest formal difference is that regardless of what a referee desires or does specifically, the referee-role is distinguished from the player-role precisely as the stand-in for the game world in which a player acts through their character(s), such that the referee-role is one which can be distributed among multiple individuals or even among individuals participants who also act in their capacity as players with characters. A referee is a structural feature of discourse, not an individual who takes on that feature.

Having set all these working definitions, we can begin to talk about how procedures factor into a game.

Theoretical Proceduralism

A procedure is the diachronic (i.e. sequential, as opposed to in-place), ordering logic of interactions between agents and the other system elements. It is like a subroutine in a program, and often has the structure of a loop. It is diachronic because it is an order of operations, where individual operations can be prescribed specifically or can be slotted into a space.

Here I consider a variety of different procedures and related concepts insofar as they structure play, with a view to distinguishing procedures as the ordering logic of interactions from the ordering logics of other aspects of role-playing games.

Combat Rounds in Dungeons & Dragons

For example, consider the combat procedure of Dungeons & Dragons, Fifth Edition. Each agent has a score, their initiative, that determines their order of action compared to other agents. Each round of combat, agents take their turn in order of their initiative scores. A turn is comprised of a movement and an action, as well as a bonus action (if given by the specific action) or a reaction on another agent’s turn (if provoked or prepared).

The order of agents taking their turns in a single round is the procedure of that round. It is not very complex, ordered only by the logic to put agents in order.

We can even represent this procedure as pseudo-code. The start of the encounter has its own procedure for determining initiative and queuing participants. Below, I use a certain notation to represent arrays (ordered lists) of elements: the big letter represents the array itself e.g., below, P is an array of characters. The small letter or number in brackets represents an index which points to a specific member of that index; for example, P[1] represents the first element in the array P (i.e. the first character in the list), whereas P[i] represents some element in P indexed by some numeric value i.

----------------------------------------------------
Header: InitiateCombat(P, n, I)
Input:
- P, array of participants (P[i] is a participant)
- n, number of participants
- I, array of initiative scores (I[i] is the score of participant P[i])
Output: T, turn order of all participants from 1-n

1. For all i from 1-n:
2.     I[i] ← d20 + initiative bonus of P[i]
3. T ← [1, 2, ..., n]
4. Sort T according to values of I[i]
5. CombatRound(P, T, nil)
----------------------------------------------------

Then the combat round itself has a procedure.

----------------------------------------------------
Header: CombatRound(P, T, R)
Input:
- P, array of participants
- T, turn order of participants
- R, set of reactions with conditions
Output: N/A

1. For each turn in T:
2.    current ← P[turn]
3.    P[turn] moves, acts, etc.
4.    If P[turn] prepares a reaction, add it to R
5.    If any r in R is triggered, do r and remove from R
6.    Remove any participants from T if killed, capitulated, inactive, etc.
7. If count of T > 0:
8.    CombatRound(P, T, R)
----------------------------------------------------

The procedure above continues until the turn order is empty due to participants becoming unable or unwilling to act. Even with such a relatively simple procedure, it is apparent that there are procedures of the game that structure it diachronically, versus operations of the game that are atomic or synchronic (e.g. ‘move’, ‘attack’, ‘react’). Procedures can also be nested and call upon other procedures alongside operations, such that a whole procedure is abstracted as an operation from the vantage of an overarching procedure. Consider, for example, how multiplication is simply adding a number to itself multiple times, or how exponentiation is multiplying a number by itself multiple times. There, obviously, exists a grammar that represents each of these things as singular operations (and you can, for example, memorize a multiplication table to avoid having to do simple multiplication); yet they are indeed subroutines unto themselves, if only abstracted for the benefit of the reader.

The procedure of a single combat round in Dungeons & Dragons Basic Rules a.k.a. B/X (Moldvay 1981) is much more simple yet specific. The overarching combat encounter loop is as follows:

----------------------------------------------------
Header: Combat(S)
Input:
- S, sides of the encounter
Output: N/A

1. T ← empty priority queue
2. For each s in S:
3.    initiative ← d6
4.    add s to T, ordering based on initiative score
5. For each s in T:
6.    s.checkMorale()
7.    s.moveMembers()
8.    s.fireMissiles()
9.    s.castSpells()
10.   s.doMelee()
11.   Remove any element of S as appropriate
12. If count of T > 0
13.   Combat(S)
----------------------------------------------------

The designation of specific phases to any individual side’s turn of combat (morale, movement, missiles, melee, magic) introduces additional complexity into the scope of a turn. For this game, it acts almost like a checklist of actions. Have we checked morale? Has everyone moved who wanted to move? Are any of us casting spells?

However, the procedure seems to be a faulty misreading of the one prescribed in Chainmail and by extension the original Dungeons & Dragons a.k.a. OD&D (above is the equivalent description from my forthcoming retroclone of both, Fantastic Medieval Campaigns):

----------------------------------------------------
Header: Combat(S)
Input:
- S, sides of the encounter
Output: N/A

 1. T ← empty list
 2. For each s in S:
 3.   initiative ← d6
 4.   add s to T, ordering based on initiative score
 5. For each s in T:
 6.   s.checkMorale()
 7.   Remove any element of S as appropriate
 8. For each s in T:
 9.   s.moveMembers()
10. For each s in T:
11.   s.fireMissiles()
12.   Remove any element of S as appropriate
13. For each s in T:
14.   s.castSpells()
15.   Remove any element of S as appropriate
16. For each s in T:
17.   s.doMelee()
18.   Remove any element of S as appropriate
19. If count of T > 0
20.   Combat(S)
----------------------------------------------------

The most compelling use of combat phases is not when they are subdivisions of a turn, but when they are subdivisions of the round so that the different sides take staggered actions. Both sides check melee, then both sides move figures, then both sides fire missiles, and so on. Only in this case are the effects of taking fast actions first apparent, since e.g. casting a spell puts one at immediate risk of being first hit by an enemy missile or melee blow.

Having considered the above cases, it is apparent that the procedure of a combat round greatly impacts the outcomes of that round as much as do atomic operations performed during the procedure (rolling to-hit, rolling damage, etc.). In fact, the procedure does a great deal more to shape the course of play both on a turn-to-turn basis, i.e. between each exchange in the discourse between agents, and on the sequence of turns in total.

Exploration in Dungeons & Dragons

Previously, I made use of pseudo-code to illustrate the differences between OD&D and B/X dungeon exploration procedures [4]. Here they are again, first OD&D (Fantastic Medieval Campaigns above):

----------------------------------------------------
Header: odndExploreCycle(p)
Input:
- p, the party
Output: rested, which is true or false

 1. rested ← false
 2. For turns 1-6:
 3.    duration ← 0
 4.    while duration < 0:
 5.       action ← p.doSomething()
 6.       duration ← duration + action.getDuration()
 7.       if action is a rest:
 8.          rested ← true
 9.   checkWanderingMonsters()
10. return rested
----------------------------------------------------

It should be apparent that the procedure I have depicted is not of an individual turn, but of a cycle of six turns encompassing one hour. Meanwhile, individual turns really have their own procedure (lines 4-10) where the party does actions until the referee has judged that enough time has passed to make a wandering monster check at the end of the turn. This could be represented as a separate subroutine, i.e. a separate procedure which appears as an operation to the overarching procedure, but it is useful to see how a single turn factors into the larger cycle of exploration [5].

As it were, a cycle of OD&D exploration is only valid if one turn is spent resting, and so there are really five turns per cycle as far as player actions go and one additional ‘turn’ for wandering monsters. Understanding a turn as a duration of time is no longer adequate to understand the relationship between actions and abstract time, as shall be discussed.

The procedure for B/X is as follows, which I have corrected since my original treatment (with the equivalent description above, from the B/X retroclone Old School Essentials):

----------------------------------------------------
Header: bxExploreCycle(p)
Input:
- p, the party
Output: N/A

 1. exhausted ← true
 1. turns ← 0
 2. Until broken:
 3.    turns ← turns + 2
 4.    turn1 ← p.doSomething()
 5.    turn2 ← p.doSomething()
 6.    If turn1 is a rest:
 7.       turns ← 1
 8.    If turn2 is a rest:
 9.       turns ← 0
10.    exhausted ← turns ≥ 6
11.    checkWanderingMonsters()
----------------------------------------------------

There is a structural difference between the exploration cycles of OD&D and B/X. The first is that B/X does not strictly define a cycle with respect to rest. If the number of turns since a rest is 6+, then party members receive a -1 to all rolls. This is very different from saying that a cycle must contain a ‘turn’ of rest (is it really a turn?) regardless of the party’s decision. A cycle of exploration in B/X is better understood as the duration of a torch, which is the shortest lasting light source that can be carried into the dungeon. That is the maximal unit of time for which a party can be in a dungeon without expending a resource (of the lowest quality).

Also, the wandering monster check no longer bookends a turn, but it is done after two turns. This seems to be because the turn is no longer defined as the duration of time between wandering monster checks (duh), but now as the abstract duration of any significant action taken by the party. B/X simply operates on a different understanding of what a turn is than OD&D, even though in both cases they represent the party’s capacity to act in the midst of a larger loop. OD&D sees a player action as taking up any amount of time where a turn is the interval between checks, whereas B/X focuses on the action as having the duration of a turn. We cannot refer to both as having the same notion of a ‘turn’ with respect to what the word means in the game procedure. For more extensive commentary on differences between OD&D and B/X exploration procedures, see footnotes [4] and [5].

The overloaded encounter die as originated by Necropraxis [6] is a popular way to consolidate the different mechanics of the dungeon crawl into one basic procedure which encapsulates them all. Below is how the equivalent ‘event die’ appears in Errant [7]:

----------------------------------------------------
Header: errantExploreTurn(p)
Input:
- p, the party
Output: exhaustion

 1. duration ← 0
 2. While duration < 1:
 3.    duration ← duration + p.doSomething().duration
 4. event ← d6
 5. If event is 1:
 6.    Random encounter procedure.
 7. Else if event is 2:
 8.    p decides between resting or gaining 1 exhaustion
 9. Else if event is 3:
10.   Light sources burn and ongoing effects end.
11. Else if event is 4:
12.    The dungeon has a local effect.
13. Else if event is 5:
14.    There is a sign of an encounter.
15. Else if event is 6:
16.    Nothing.
17. If p is still exploring:
18.    errantExploreTurn(p)
----------------------------------------------------

There is not a larger explicit cycle for the event die. The events which might be handled by actual durations of simulated time in the above exploration procedures, such as torches or spells, are modeled statistically as the random outcome of a turn. There is thus a statistically likely cycle of each outcome 1-6 occurring once per 6 iterations of the procedure, but this is not a cycle of certain steps. It reduces bookkeeping that necessarily results from overarching time management and keeps players on their toes since each turn has some sort of consequence. Gus L characterizes this as being useful for smaller dungeons or for play sessions which now tend to last 2-3 hours rather than entire days, since something is always about to happen [8].

In all these cases, the same terminology is applied and reapplied loosely to describe things that are alike in narration but not structurally equivalent with respect to the happenings of the game. Nevertheless, the procedure is at the root of the play activity itself in how it provides a grammar to player action as an overarching frame for those actions performed. We have long discussed isolated rules, operations, as being ‘games’ when they are secondary to the ordering logic in which they occur.

Moves in Apocalypse World

It is not incorrect to say that the base procedure of Apocalypse World is the conversation between the game master and the players. Moves can be understood as subroutines called by the overarching conversation routine, where a condition in the conversation is met such that a move necessarily occurs [9].

This is not necessarily the interesting part of the rulebook, though. In fact, it’s either implicitly or explicitly how any rulebook prescribes a game by play structure, i.e. a plan of activity. What interests me more is the great care that Apocalypse World takes to define its major activities through stringently structured actions triggered by characters, rather than through overarching repetitive routines. There are no loops here, but there are still procedures nonetheless. They are just located in character action rather than in structures that rule over characters. My friend at Retired Adventurer pointed out to me that apocalypse games have much in common structurally with object-oriented programs where functions are specific features of object-classes that are abstracted away from any overarching program, as opposed to programs more like those written in C where there are no object classes, but only overarching programs acting upon data structures.

Let us define the conversational loop first. I am treating the set of characters as a single block C, rather than as individual characters, just to reduce any visual complexity.

----------------------------------------------------
Header: conversation(P, gm, C, M)
Input:
- P, the set of players
- gm, the game master
- C, the set of characters
- M, the set of moves
Output: N/A

1. response = P.respond(gm.hardMove(C))
2. If response corresponds to some m in M
3.   m.do(C, response)
4. conversation(P, GM, C, M)
----------------------------------------------------

Keep in mind that although moves will often result in the game master making a move anyway, the conversation loop nevertheless calls itself at the end of each iteration. This is my reading of what it means for the game master to make a move whenever the conversation-game has slowed down, meaning that any consequences resulting from previous moves made have been resolved. Now the game master asserts another hard move, and the conversation starts anew.

The ‘go aggro’ move is triggered when a character does something that qualifies as going aggro on someone else. Meguey and Vincent Baker explain in more detail:

Going aggro means using violence or the threat of violence to control somebody else’s behavior, without (or before) fighting. If the character has the drop on her enemy, or if the enemy won’t fight back, or if the character is making a show of force but isn’t disposed to really fight, it’s going aggro.

The subroutine called when going aggro is below. The variables c1 and c2 are “determined” by the function call above, move.do(Characters, response), which is not worth formalizing since it is ultimately just determining which move is triggered and for which characters. We’ll say that that information is abstracted and decided for us. Thanks, game master (and, also, Bakers)!

----------------------------------------------------
Header: goAggro(c1, c2)
Input:
- c1, the acting character
- c2, the targeted character or agent etc.
Output: A set of outcomes imposed on the game-world

 1. roll := 2d6 + c1.hard
 2. If roll >= 10:
 3.   c2 does what c1 says or forces c1's hand.
 4. Else if roll >= 7:
 5.   option := c2.input()
 6.   If option is 1:
 7.      c2 gets out of the way
 8.   Else if option is 2:
 9.      c2 barricades themselves
10.   Else if option is 3:
11.      c2 gives you what they think you want
12.   Else if option is 4:
13.      c2 backs off calmly
14.   Else if option is 5: 
15.      c2 tells you what you want to know
----------------------------------------------------

We can see here the basic structure of the move which has since been adopted by many later apocalypse games. After the situation has been judged to have triggered a move (and we are past that point), the acting player rolls dice and decides which outcomes they prefer to inflict on the characters involved. This move takes that very simple two-step template for a procedure, and fleshes it out with particular decision points.

This is also another useful opportunity to see how procedures can be abstracted as operations within the scope of a larger routine. That is, although moves have their own particular structuring logic or order of operations, they can seem to be, on higher levels of system-representation, singular operations. Moves appear as atomic segments with respect to the game when represented from a higher level, but upon individual inspection they have their own ordering logic and are themselves procedures.

Scenes in Logan

Ordering logic appears in yet other contexts than overarching loops of activity, or subroutines of player-triggered character actions. In Logan, you play through a certain version of the titular character’s life (where the character is also the author himself). You play out scenes or categories of scenes in order; in the latter case, you select a particular scene to fulfill a category. What sets apart each instance of the game is the resolution of scenes, i.e. how they turn out, as well as the selection of particular scenes.

The order of scenes is as follows, with categories of scenes being represented by brackets to indicate that they are swapped out by an appropriate scene of the player’s choice:

1. Birth
2. [Peace]
3. Milestone: The First of Many
4. [Growth]
5. [Self Care]
6. [Peace]
7. [Turmoil]
8. [Self Care]
9. [Growth]
10. Milestone: The Lightbulb Moment
11. [Turmoil]
12. [Turmoil]
13. [Self Care]
14. [Peace]
15. Milestone: Kurama Onsen
16. [Growth]
17. [Growth or Peace]
18. Milestone: My Beard Shape
19. Epilogue

In comparison to the other rulesets, Logan has a much more strict (even regular) grammar. The order of play is set: you play through scenes in that order, and you select scenes depending on what type is called for. One interesting factor is that certain scenes call upon other scenes as prerequisites: for example, you cannot select the [turmoil] scene about Logan coming out to his parents without first having passed through the milestone called “The Lightbulb Moment”. This sets Logan’s life as a narrative along a certain pathway, the specifics of which are only determined or discovered by the player. Even with such a simple grammar, and one that is very deterministic at that, Logan excels at structuring activity to impact the player or reader. It has more to offer than do often sets of rules for characters (usually data structures and singular operations, like a resolution rule): it offers a course.

Logan, by strictly defining a narrative course, takes the principle of diachronic structure in directions not considered by D&D or even to an extent by apocalypse games (which structure individual actions in a narrative, but not the narrative itself). We see deterministic narrative, both regards to content and structure, as characteristic of traditional or neo-traditional play, whereas the other sorts of play we have seen do not anticipate any specific course of specific action as much as a structure of actions through which players interact. This is the difference between telling a story versus playing to find out, or between acting out a drama (even on the fly) versus acting in one’s own capacity as an agent.

The Five-Room Dungeon

We can challenge our own preconceptions about what constitutes ordering logic by looking at the common session structure for D&D Fifth Edition, the five-room dungeon. A five room dungeon is a locale with five rooms, which are less rooms than they are narrative scenes which are sequenced to provide a particular challenge and satisfying narrative to the players. The rooms are as follows:

1. Entrance: Where a guardian awaits those who try to break inside. The guardian is the reason why no one has already made it in yet.
2. Puzzle: A role-playing challenge to whet the players’ appetite to act out their characters, rather than a ‘gamey’ challenge.
3. Setback: Something that will prevent the characters from delving deeper, like an encounter.
4. Boss Fight: The big climatic fight at the end.
5. Reward: The treasure room or a room that offers some other satisfying conclusion to the characters’ adventure.

It is apparent from this list that the rooms are less representations of an actual navigable space, as much as they are containers for narrative scenes which are sequenced to provide a particular challenge and a satisfying narrative to players. It is not dissimilar to the structure of Logan in as much as it prescribes a particular sequence of events, or categories thereof, to result in a specific experience of play. You can even see how the order of rooms resembles the typical path of a narrative with a introduction, rising actions, a climax, and a conclusion. The location, therefore, is not designed with a view to natural existence or to game interactions per se, but to facilitate a specific narrative pattern that gives the session the structure of a story.

I need only cite Gus L. about how the five room dungeon is quite different from a classic dungeon crawl [10]. One is a structure of narrative, and the other is a structure of activity. One defines the expected interactions characters will have, the other defines the environment with which characters will interact. Both are diachronic structures, but they structure different relations to different effects and with different implications for player participation. This distinguishes procedures, then, from narrative-based adventure design since procedures do not guide players’ characters down a specific path, but they are tools with which to structure courses of action taken by those characters. A five-room dungeon tells a story. The Caverns of Thracia describes a place.

Practical Proceduralism

It is apparent that games, as structured activities of play, are organized according to synchronic and diachronic rules. They have particular grammars, though grammars can exist on the levels of activity, of time, or of place. In the latter two cases, grammars seem particularly restrictive as they are used to enforce particular narrativized outcomes on the participants; this is not without some benefit or without literary significance, so to speak, but it gives the activity less the structure of a game (where actions are executed with a goal have consequences) and more that of a story (where scenes are constructed in the service of a narrative already determined). Thus, for many it is desirable to ‘break free’ from traditional and neo-traditional paradigms of games which seem to not be games at all. A structure for activity, one that results in play whose outcome is non-deterministic and perhaps even recursive, provides guidance and context without restricting activity. In fact, it makes activity more interesting.

Yet there is much work to be done in figuring out how games, proper, are structured. It is clear that structures of activity are a boon to player creativity, in how they pose certain risks and restrictions that proffer interesting problems (resource and time management being chief among them) which then proffer creative problem-solving, which for us is the telos of play. Then it is best to understand how to incorporate logic which compliments player decision-making, contextualizing their agents’ actions and making interesting situations to deal with, rather than eliminate player decision (and thus the game itself) altogether. Understanding procedures then as the structures of play activity helps us to understand how best to make play fun. Proceduralism, therefore, serves as practical theory alongside interpretive theory to play games with a conscious effort to structure them in compelling ways.

There already exist practical, conscious efforts to better facilitate the diachronic structure of play. We have already seen how particular hobbyists have developed their own solutions [4] [5] [6] [7] [8]. There is work being done to keep building upon those solutions, themselves elaborations upon earlier solutions, and also to apply this thinking to new situations not considered by earlier rulebook authors [11] [12] [13] [14] [15]. What follows here, then, is commentary on how other aspects of a system (as a set of interactions and circumstances for play) can facilitate play activity by complimenting that activity’s very structure.

Synchronic Operations

I have discussed before how named editions of D&D have never actually incorporated stringent resource management as a formal game, or as a component of the dungeon game itself [16]. It is worth discussing then how newer rulesets, which try to make resource management a game proper, accomplish this through procedure and complimentary features of the ruleset.

The procedure is, perhaps oddly, not the novel part here. Since Gygax’s additions to the D&D ruleset, the limited duration of light has become a central feature of the dungeon game. The innovation of Necropraxis in the context of resource management then is not to proceduralize it, since it always has been proceduralized, but to reduce the bookkeeping required to facilitate it by making the depletion of resources a random outcome that occurs at random intervals statistically equivalent to the non-random depletion of resources (i.e. on a timer). This means that, structurally, this solution is not on the level of procedure per se (except insofar as light extinguishing is no longer considered as a step in a cycle), but on the level of individual events structured by a procedure. This particular rule, then, is not a procedure itself but an event or operation; it is something being ordered by a procedure above it.

Yet this particular solution poses a fantastic lesson for proceduralist design of rulesets in general. This particular aspect of the hazard die system is not itself a procedure, but it is designed (like the rest of the system) to simplify the procedural dungeon crawl so it does not require as much mental load to keep track of. As discussed above, there is no longer an overarching cycle; there are only atoms of activity, now with random events to emulate the non-random events of the earlier cyclical solution (in particular, character exhaustion and light source depletion).

This is not without tradebacks: most obviously, since there is no longer an overarching procedure or cycle of exploration, the course of events is much more unpredictable. This particular solution can prove restrictive on possible events, depending on how one interprets it in practice. For example, consider how random encounters and becoming exhausted are now mutually exclusive random events, rather than one random event which can potentially coincide with a deterministic event. It would be too much work to roll d6 for each random event, so that is not an option. My own solution, which might be what Necropraxis intended but I have seen is not often considered in discussion, is that a rest lasts for the whole duration of a turn and then some: thus, by choosing to rest, the party risks being caught like sitting ducks by a random encounter. This does not account for the mutual exclusivity of the events in general, but realizing this made the hazard die more palatable to me.

It’s these sorts of considerations that must be made in order to facilitate the flow and course of play activity. There’s not a right way to do anything, but there are ways that require more effort for less satisfaction. By systematizing individual events within the scope of a procedure, we can make those events more meaningful and the procedure more impactful.

Data Structures

Talking about diachronic structures and synchronic elements is talking about the grammar of play activity, i.e. what interactions are possible and what goals are agents trying to work towards. There is a missing piece to this: what are the subjects and objects of those interactions? This might seem a silly question since most rulebooks begin by describing, in more detail than anything else, how characters and their possessions and so on are formalized within the system. This is most often through qualitative or quantitative attributes which contextualize characters by making them comparable to each other; for example, the traditional six ability scores allow us to judge who is more charming or who is more intelligent or who is more physically capable.

As discussed above, this player interface is worth nil if it is not animated within interesting relationships and with interactions. In other words, what’s the point of all these numbers and labels if I don’t know what to do with them? What are we playing, exactly? What is the goal and what avenues are there to try to accomplish it? However, like with individual events or operations, it is possible to make character records and other data structures that facilitate the flow of play activity. One example of this, related intimately to our discussion of the hazard die, is the slot system for inventory management and encumbrance.

Official versions of D&D have always prescribed pseudo-realistic inventory management systems, asking players to keep track of the weight carried by their characters (as often measured in coins, each 1/10 a pound). Yet only two things were really tracked: martial equipment and treasure. Resources were encapsulated in a catch-all “miscellaneous” unit of weight, always 80 coins or 8 pounds heavy [17]. It didn’t matter, on paper, how many torches or rations or whatever you carried; it all weighed one amount, and so you could carry as much as you want. The only important part was remembering to carry them at all.

Slot inventory systems abstract encumbrance so that the player does not count so many pounds of weight their character is carrying, but how many discrete items (with small items often taking the space of one regular item, and big items often taking up the space of two or more regular items). On one hand, this is much less math to worry about; you’re not counting pounds, but only how many things you have in a numbered list. This also means, however, that individual items have much more weight (proverbially). One torch is not a blip on your character sheet, but it represents a not-insignificant amount of carrying capacity your character chooses to occupy with a torch as opposed to anything else (say, treasure or armor). Having discrete items this way also makes it easier to facilitate procedural resource depletion, since the items themselves are abstract and easier to track by virtue of being ‘bigger’, as opposed to being small trivial things which could be handwaved.

Abstraction of data facilitates procedural play, in comparison to more ‘realistic’ and in-depth data, by making data less complex and easier to approach. The focus shifts from trying to accurately model an object with various qualities and quantities, to creating a model with the specific goal of facilitating the flow of play. It is no coincidence that the rise of slot inventory, with its focus on simple encumbrance and resource management, has corresponded with the rise of more diegetic role-playing (not having to look at your character sheet all the time). All these concessions help us as players to more freely participate in the game through natural language, where the structuring role of procedures becomes more apparent as guides for play activity. Abstraction, then, is a very useful tool to facilitate procedural play by simplifying what all needs to be considered for specific actions or data management of play.

Conclusion

Proceduralism is a useful perspective from which to understand the play activity prescribed by rules texts, as well as a useful theoretical toolbox with which to prescribe more effective and compelling play by structuring player activity itself. Often, rules texts only provide in-depth prescriptions of player interfaces via character records and isolated rules; such texts do not prescribe as cohesive or as compelling experiences as do texts which provide a premise for a game and avenues of activity through which to achieve the aims of that premise. Moreover, it is preferable to have atomic rules and data structures which facilitate play as a dynamic sequence of events and decisions, rather than having those systemic aspects exist in isolation from procedure or from each other. Proceduralism as a theory for producing useful game materials, then, is a properly systematic approach to develop experiences which elevate player agency through interesting decision-making as made possible by a contextualizing activity structure.

 

[1] https://lumpley.games/2019/12/30/powered-by-the-apocalypse-part-1/

[2] https://www.prismaticwasteland.com/blog/the-universal-procedure-of-the-osr

[3] https://chiquitafajita.blogspot.com/2021/06/critique-3-emergence-of-traditional-game.html

[4] https://chiquitafajita.blogspot.com/2021/08/structural-analysis-of-exploration.html

[5] As I have mentioned in a prior article, OD&D does not yet prescribe a duration for torches or for light sources in general. I suspect that a torch has a duration of 6 turns precisely because that duration was already understood as the atomic cycle of exploration. https://chiquitafajita.blogspot.com/2022/02/double-feature-movement-light.html

[6] https://www.necropraxis.com/2014/02/03/overloading-the-encounter-die/

[7] https://errantrpg.carrd.co/#procedures

[8] https://alldeadgenerations.blogspot.com/2021/10/a-structure-for-classic-exploration.html

[9] It is worth noting that later PBTA games played telephone with the text of Apocalypse World. The latter says that if a move is triggered in conversation, it is performed; likewise, if a move is declared without it having basis in the conversation, the player who wants to do the move is queried about what exactly they want out of it. This has been reinterpreted by subsequent rulebooks as language-policing players to narrate all their actions diegetically and only perform moves at the behest of the game master. Apocalypse World only asks players to be mindful of what doing a move means in the game-world.

[10] https://alldeadgenerations.blogspot.com/2021/08/classic-vs-five-rooms.html

[11] https://chiquitafajita.blogspot.com/2022/04/turn-post-mortem.html

[12] https://www.prismaticwasteland.com/blog/your-taverns-need-a-procedure

[13] https://www.hypertextcorner.com/shore

[14] https://www.hypertextcorner.com/micetown

[15] https://mindstorm.blot.im/2021/12/6/how-to-set-a-dc-in-a-d20-dungeon-game

[16] https://chiquitafajita.blogspot.com/2022/04/cyclical-resource-management.html

[17] As discussed in [16], Advanced D&D had a slightly different approach that was more dependent on referee judgement.