Process Optimization in TTRPGs, or How I Learned To Start Worrying and Love the Operation

November 8, 2024

So one thing where I feel like I don’t have like…authority in but at the very least have thought about is the concept of performance loss (and specifically avoiding it through process optimization) in TTRPGs: the kinds of things that bog down a situation in a process.

WARNING: This post started as me making a little comment on a great, concise post on Fool’s Pyrite. Then I decided to make it a fun little post on its own. Then I thought about it some more. Then I drilled down and kept drilling. This starts simple enough but quickly becomes a True Sicko Post. You have been warned.

Dropping Frames #

So anyone who plays AAA-ish video games regularly probably understands the concept of framerates.¹ In case that’s not you, this is how frequently the graphical state refreshes. Typically a game aims for a particular target, like 30fps (refreshing 30 times a second) and 60fps (refreshing 60 times a second). Faster is obviously going to feel more responsive but that means the code needs to be able to refresh everything that quickly, meaning it needs to be much more performant: when the computer is expecting to spend 33ms vs 17ms, it can fit a lot more calculations in there. So the tradeoff for a developer is understanding what the hardware can do as far as visual fidelity, physics work, and so on.

Now, what happens if you try to cram too much in there, or the processor isn’t good enough? Well, it starts dropping frames - it skips around a bit or slows down, and both of them make the game not feel good or work half as well.

TTRPGs work the same way. There’s a million posts about optimizing video game processes; this is a post about optimizing your TTRPG process. I don’t have any profiler stats or anything half as objective as that, I just have my own observations and hot takes.

Overhead #

So I reckon the big first step to thinking about this is: what are you willing to put up with? Continuing that analogy, this is the answer to things like: Does this game only run on a proper, current desktop computer or can it run on some shitty chromebook from 5 years ago? Are we making a 30fps, 60fps, or 120fps kind of game?

Obviously we’re not talking about computing in the technical-specs sense here. But we can be talking about very similar things, such as:

• How accessible do you want this to be to someone who’s never played a TTRPG and doesn’t know the ins and outs of how to act socially in that kind of space?
• How accessible do you want this to be to someone who just flatly doesn’t play like, most games at all and just flat doesn’t know what “common” terminology means?
• How easily do you want this to be playable without a specialized program, auto-fill sheet, VTT, etc?
• How easily do you want this to be playable without a computer of any kind?

Instead of CPU cycles and RAM and GPU output, people have cognitive load, which is similar conceptually but not as good at the same things: for instance, computers are really good at math and drawing triangles and holding things in memory. Nobody is that quick at that kind of stuff. But they’re quite bad at synchronous, “close enough” style approximated communication, which people are VERY good at. Part of any design discipline is understanding the strengths of the field in which you are working: art and design are flexible enough that certainly can jam a square peg into a round hole if you’re trying hard enough, but there are best practices to keep in mind that can make things go better in the design process. So overhead is the bucket you can reasonably fill with process: how much performance loss from any given mechanic are we willing to tolerate? It might be ok if a game is just intended for Hardcore Gamers only and/or you basically intend to ship it with a VTT module as the primary way in which you play it - in that case, your overhead is very high because either the intended audience is expecting that so it’s not a problem or you have a mitigating factor. But if you want something to be more accessible and flexible with regards to platform, etc. then your overhead is going to need to go down.

Generally speaking, I will assume that if you’re reading this, you want to aim at least more towards the “runs on a potato” end of things, if not fully there. If you just want to make something fully indulgent that only caters to the most hardcore of hardcore people who already know what they’re all about, godspeed, go in peace. (If you just wanna do what you wanna do in general, then yeah I’m not gonna stop you.) I’m not going to get into how the sausage is made because frankly, how it’s made isn’t remotely rigorous enough to examine and a lot of folks just kinda wing it. I’m going to get into what the sausage IS. I’m going to attempt to break that sausage down at the molecular level.

So let’s talk about operations.

Operations #

I’m going to outline a traditional extremely basic D&D “damage on hit, nothing on miss” attack roll:

1. The attacker rolls a d20. They add several kinds of default bonuses to it depending on the edition: stat, proficiency, weapon, etc. They often add conditional bonuses or penalties to this roll: temporary effects, buffs, penalties, conditions, etc.
2. They tell the sum to a the defender, who checks against their AC value. While usually static, this can often fluctuate depending on similar conditional bonuses or penalties.
3. If that hits, then the attacker rolls damage. There’s a default amount based on weapon di(c)e + attribute. Often it has conditional bonuses or penalties to this as well. Sometimes abilities will have effects on a miss as well that are distinct from hit effects.
4. The enemy subtracts that damage from their HP. Sometimes there’s a resistance, vulnerability, etc that changes this.

Simple, right? Well. Let’s get more granular and break it down into several operations.

• Roll dice and get a value from them. (Includes similar operations like drawing cards, etc.)
• Look up numbers from varying places.
• Calculate values.
• Compare values.
• Determine qualitative results.
• Transmit information between players.
• Record information.

(Everyone will probably have a different taxonomy for these, this is all just from my observation. We’ll get into them in more detail later but there’s a lot of overlap.)

Using this taxonomy, let’s break that D&D² attack roll down in the most excruciating way possible:

1. Attacker looks up the attack die.
2. Attacker looks up permanent bonuses/penalties to that roll.
3. Attacker looks up (and maybe rolls) temporary bonuses/penalties to that roll.
4. Attacker calculates attack roll modifier.
5. Attacker rolls to attack.
6. Attacker transmits the result of that attack roll to Defender.
7. Defender looks up permanent AC.
8. Defender looks up temporary AC bonuses/penalties.
9. Defender calculates modified AC.
10. Defender compares modified attack roll to modified AC.
11. Defender transmits if this is a hit/miss to the Attacker.
    • Process ends here on a miss.
12. Attacker looks up default damage.
13. Attacker looks up (and maybe rolls) modifiers to damage.
14. Attacker calculates modified damage.
15. Attacker rolls damage.
16. Attacker transmits modified damage.
17. Defender looks up modifiers to incoming damage.
18. Defender calculates modified damage.
19. Defender calculates change in HP based on modified damage.
20. Defender records change to HP.
21. Defender determines if they are down based on this change.

This is for a basic attack. It doesn’t account for:

• What if the attack does something on a miss?
• What if the attack adds a non-damage effect to either the attacker or the defender on a hit or miss?
• What if the attack uses a consumable resource (spell slots, inspiration, one-time buffs, and so on)?
• What if either the attacker or defender has some kind of reaction?

Now. This may seem incredibly pedantic, and you’re right! These operations are not all created equal and depend a lot on varying factors. Again, we don’t have a profiler, so we have to play this a little by ear: but the more you engage with these kinds of ideas, the more you get a feel for it. Let’s go into each.

Roll #

You have dice, cards, whatever. Roll ’em or draw ’em, get the value. Easy, right?

Well, not all rolls are created equal. Rolling can easily get into calculate territory once you start adding operations to do TO the rolls to get out secondary results: adding rolled dice together for a total, picking out a number of successes for a dicepool, picking out doubles or triples or combinations, the wild poker dice thing that Cthulhutech was doing, and so on. So be wary. Some tips I can give:

• The fastest additive-die result (aka D&D’s d20 or damage rolls) is going to be a single die, for obvious reasons of “not actually adding”. The fastest dicepool-style result is going to be “roll X and take the highest or lowest” because it’s pretty scannable and you don’t usually have to track multiple values.³ Results where one die is tens and another is ones (d100, d66) are pretty quick too. What I will say about d100-style rolls, though, is that they can very often feel like a d10 roll in practice, so think about if you can just do that.
• If you’re adding dice together, keep them small, ideally around a d6, but if you must use a different die, aim for d10 or lower. (Adding single digits together is quickest and easiest, generally, the lower the better, but if you have too many dice because you stuck to d4’s you’re often adding too many values together.)
• If you can use a roll in more than one way as opposed to rolling more than once⁴ then even better.
• Making roll resolution into some kind of choice is inherently slow because then you’re getting into the transmit category. Adding conditional rolls is even slower - interpreting the result of a roll, spending resources for rerolls, exploding dice, and so on. This isn’t to say universally avoid it, just understand that this is where things can and will really drag over time if everyone is doing this like, every roll.
• Dice tricks are fun but they will often bog stuff down. Unless you’re really getting something out of them, I’d avoid.

Look up #

So you can probably guess what “look up” generally means: I believe in you. But if you’re reading that example above, you’ll understand that I mean it in a very broad sense. From low-impact to high-impact:

• Basic mechanics. This is where “roll a d20 and add stuff” generally comes from. You hopefully don’t have to look up the d20 every time so this is roughly as low impact as it gets.
• Conditional mechanics. Remember when I said the basic resolution was as basic as it gets? Well, sometimes you have multiple resolution mechanics for similar actions, in which case it can get a little hairy. As few as you can get within a certain category to reduce this kind of friction is best. For instance, the 4E house style of “all attackers roll, all defenders have defenses” is preferable in this regard to “some things provoke attack rolls, some things call for saves” because you’re always sure who’s doing the rolling and if high is good. This can easily stray into discrete active/received effects if you’re not careful - especially when you start getting cute about a ton of different procedures.
• “Permanent” values. Permanent in the sense of “within a scene”. This is your skill or attribute value, your primary attack’s damage dice, your AC, your saves, that kind of thing. The kind of stuff that definitely should be written down somewhere on your character sheet. Odds are most people will just remember this over time.
• “Temporary” values. This is where situational modifiers, buffs, and debuffs come in. In the best situation, this is something where the value is just like…give advantage, give disadvantage, give a +2/-2. In the worst case, see “Discrete received effects” at the bottom of this list.
• Discrete active effects. Powers, spells, and so on. In the best case, this is stuff that a player picked and has written down and knows by heart. In the worst case, it’s a 20-30 entry list of spells that a monster has that exists somewhere else in a different book entirely and most of them are not worth using in a pinch.
• Discrete received effects. Lookup-style things, but more passive. These can be where a lot of those temporary values come from. Depending on how organized and compiled and concise they are and how well documented their interactions are, conditions are either a very effective way to increase the depth of combat or the bane of your existence. Do you remember exactly what Shaken does in 3E? How about Fatigued? How about the increased versions of either of those that you get from stacking them twice? If you don’t know those, do you know the quickest place to look them up? How about if you can’t google quickly? I’ve focused a lot on combat stuff, but for noncombat example, I would posit PbtA-style Moves fall into this category rather than active: bear in mind that the way The Conversation is supposed to go is that a player is supposed to say what they want to do, then the MC says that triggers a Move for them based off of that. Does the GM have all those off the top of their head to know what move to trigger? Does the player know what they’re doing when they roll a move? How about something like Root where you have 6 basic moves, some of which have a ton of permutations, and each playbook is going to be selecting 3 moves on top of that? If not, well, get to looking up.⁵

Things that help mitigate lookup slowdown: aids like good character sheets, good cheatsheets, and good tools go a long way. But just putting down what a thing does instead of relying on tags, keywords, conditions, etc is even better than that: if you can keep the number of concepts referenced to a minimum, so much the better.

Calculate #

I want you to think about a few things for me.

• How quick can you add two values? Do 2 + 6 in your head, how long did that take? How about 21 + 67? How about 217 + 687? How about adding three values? How about four, five, six values?
• Now in your head subtract some values. How fast did that go? Is this a system that cares about negatives? If so what happens when we do 21 - 67? How about 21 - 21? Does it change based on context?
• Ok, now multiply them - 2x, 3x, 4x. How quickly can you do that?
• Now instead, divide them in half, thirds, or quarters. How quick did that go? Did you round up or down? Which does the system recommend? Does it change based on context?
• You’ve just made an opposing check in a dicepool system. Both you and your opponent are rolling like, a double digit number of dice. How quickly can you tell what a success is? How about for anything that needs degrees of success?
• Your enemy rolls d66 as a grid-based hit location⁶ against you - how quickly can you tell if it hit and if you have to care that it hit?
• If you could do all of those pretty quick, imagine a person you know who’s the worst at math and imagine a table of 5 people are waiting impatiently for them to add it all up. How fast can they do any of these?

The more things throw numbers and values around to achieve sub-totals, the more time you’re going to spend figuring out where it all ends up. If there’s some kind of lookup table or complex result involved, well, no prizes for guessing what operation this intersects with.

Keep numbers lower (or remove them entirely) and things will move faster. Let those numbers balloon out and things will slow down. As far as actual calculation-operations, if at all possible, stick to addition. It’s going to be way faster and there’s fewer edge cases of negatives/zero/rounding. Multiplication is ok too sometimes if values are low - it gets sticky when they’re higher, like everything else.

Ideally when thinking about those kinds of floating modifiers that get calculated, it helps to limit where bonuses and penalties go: in the sample attack roll, for example you can have attack bonuses/penalties and AC bonuses/penalties, which are redundant but are calculated separately. Whenever you throw a modifier around, try to make it affect the direct roll rather than a value from which others are derived because on the fly you’re not likely to remember what derives from it, or if you do you’re not likely to remember to switch it back after.

This is the kind of thing where computers, VTTs, etc help a lot. Anyone can add in every bonus into roll20 or whatver and it’ll just add it all up while rolling, which is great, and if you have a particular module for a VTT it’ll do all that kind of busywork for you - even better! But if you lean on the fact of those kinds of tools existing too much in your designs, you’re going to have a hell of a time running the game WITHOUT one of them. Try out anything as analog as possible and see where it lands - if it can reasonably be run that way, that just means it’ll be even faster automated.

Compare #

Obviously this overlaps with calculate and determine and roll because you need to have things to compare them. But it’s an intersection-subset that comes up often enough to call it out specifically. Is this ability higher than this one? How about if they’re equal, what does that mean? How much of a disparity is there and does it matter?

A binary threshold - standard pass/fail, for example, despite all valid critiques about how pass/fail sucks - is fairly quick as these things go. Ternary thresholds - fail/partial success/full success or fail/success/crit are the most common ones - are slower because inherently you’re going to be comparing one value against multiple others, but it doesn’t mean they’re necessarily WAY slower or anything. For common rolls, the more unmoving the comparison target is, the better. If I always know a sure success is when the highest die is a 6 and a partial success is when it’s 4-5, it makes for a quick comparison. If double digits is always a success, that makes it scan pretty easily.

For less common situations where one roll has a lot of weight, you can be looser with this: I’m quite taken by Inevitable’s showdown roll and Troubleshoot’s recovery/advancement roll, for example, because they both happen fairly infrequently so the drama and tension of setting up those thresholds can feel good.

Determine #

This one’s a little fuzzier than the rest, which are often more quantitative: this is my catch-all for “figure out if something qualitatively changed in the fiction”. As mentioned above, this is where you decide if states change: bloodied/staggered, knocked out, dead, etc. This is where “success/fail and there’s a consequence/complication” live too though.

On the first point because it’s quicker: A big thing you’re going to run into when you hit those kinds of states as a result of effects is, well, a double check after every action. Half health isn’t usually too hard to remember, and it’s not too hard to write. When there are rules like “X% damage in one sitting does something extra” or death spiral effects, that then gets into various other things like record or look up or calculate. Be judicious about these kinds of things being ambiently attached to anything because that’s an extra background process you’re going to have to mentally go through every time. It also helps if certaiin factors are personalized over generic: Pathfinder 2E making Attacks of Opportunity a class feature instead of something everyone has to think about, for example.

In general, the more nebulous the results of an action or outcome are, the more time this can take. The generalized “there’s a complication” is by a long shot the worst offender of this: if your GM is great at improvization or a situation has a very obvious outcome, fantastic, but if they’re not then, y’know, good luck. It’s also really hard to determine just how nasty a complication should be on the fly and it’s extremely easy to overshoot or undershoot, which can then have knock-on effects on whether a partial success feels more like a failure or a success: position/effect or similar concepts help with this but it’s all pretty subjective. Sometimes this kind of thing can be mitigated by knowing exactly what a partial success or a failure looks like: PbtA moves are half and half on this, for example, as a lot of them are great at defining partial success but leave failure as a more nebulous “something bad happens as a result”. LUMEN v1.0 combat complications do the thing of being like “usually this means an enemy can act” so you have a good baseline for what this looks like. A lot of games nowadays that use a generic-complication have big “here’s some ideas for what that means” charts. (FIST is a great example of this.) You can also nip that in the bud a little via “determine what the potential risk is before rolling”-style things but this is definitely a “you should just play the game differently to make my design make more sense” style of fix, so you’re going to have to decide if that’s enough.

Transmit #

A transmission is whenever you pass information between players. In our attack roll example, we have three transmissions:

1. The attacker tells the defender their attack roll.
2. The defender tells the attacker whether or not it hits.
3. If it’s a hit, the attacker tells the defender how much damage it does.

So we’re going back and forth between two people three times for one action. Every one of those transmissions can come with pitfalls like:

• Giving too little information.
• Giving too much information.
• The total information load just has too much baked in.
• Literal latency issues. A ton of us are playing online, after all!
• Requirements for clarification or misunderstanding what is being asked.

As anyone who’s had to deal with any of that knows, these can just suck up time like a sponge. So this one’s easy: When at all possible, reduce transmissions during a process. Ideally this goes as low as one transmission: the actor does their thing entirely on their end and informs other players what happened all in one go. When you do have a transmission, encourage it to be as clear an concise as possible.

Record #

So we’ve done something: now, we have to track it turn-to-turn. The part where this came up in our example was HP, but that’s just because this was one basic attack. Once you start getting into any kind of resource expenditure, this gets pretty sticky. Spells, powers, MP bars, ammo, different kinds of ammo, and so on and so forth. This also comes into play with state tracking: this is where systems that do everything by conditions or tags or descriptors or etc. can bog down hard, especially when you’re duration-tracking.

Whenever you can make something a yes/no state or something tracked with small numbers (i.e. small enough that you can put them on a clock or a series of checkboxes) instead of something tracked by larger numbers, that’s for the best. This is one of the better outcomes of Vancian-style one-and-done casting: you either have the spell or you don’t, so there’s not much in the way of paperwork, you just cross it out when you’ve used it and that’s that. Simplifying durations of effects goes a long way too.

When you do have a situation that involves a lot of changing states that need recording, understand that some things will slip. When you have to deal 1 damage to 5 targets as a result of an action, not only is this annoying and slow sometimes, it’s prone to rushing through and missing something big. When someone is getting 4 effects put on them at once, one of them might just get left out by accident. When you have to write something qualitative down, today’s shorthand will often not make any sense next week. So put a little thought into how flexible your design is to missing a beat: if something will really harm the experience by someone not changing a value or writing something down, try to make it as uncluttered as possible to avoid this.

Uncommon, High-Frequency, and Hidden-Information Processes #

Ok, so we’ve gone wildly in depth into these kinds of component operations of a process. You have one, it’s slimmed down to your overhead, you’re feeling good. But something’s still up. Let’s try to put two kinds of problematic processes in context.

1. Watch out for when the process is uncommon. It’s just not the kind of thing that comes up often and you’ll probably have to look up how to do it as a result even if you’re pretty familiar with things.
2. Watch out for when the process is high frequency. That attack roll’s not THAT bad, is it? Now how about if a character makes like 8-10 of those in one action and there’s three times as many characters as players?
3. Watch out for processes that involve hidden information. Two of those transmissions in our attack roll example are partially slower because a piece of information (the defender’s AC) isn’t just out there.

In all of these cases, the prescription is similar:

• Make processes like these simpler. Just flatly remove steps or configure things such that they’re easier to determine if they have to have one of these processes. Even if those extra steps might add depth, often it’s just not worth it!
• Add in early exits. Make processes that can easily short-circuit at an early stage due to criteria. If you often only do the first third of an inherently slow process, it’ll go faster.
• Make them more “regular”. For uncommon processes, fold them into another kind of more “normal” thing. For high frequency processes, figure out if there’s a way you can combine multiple processes into one. For hidden-information processes, think hard about why information is being hidden, and if you can, make that information public.

Your game will not be perfect at this and that’s OK (aka I should follow my own advice more often) #

So naturally as soon as I came up with those component features I plugged my own processes into them. Some of them came out pretty well! But I do have a few habits in there that bog things down.

First, thinking about operations:

• Roll: One thing I’ve been especially cognizant of is allowing rerolls: both APOCALYPSE FRAME and Valiant Horizon allow you to spend a resource on them, which you’ll note that I called out in the Roll section as being incredibly slow - guess how I figured that out! The truly annoying thing is I knew this about APOCALYPSE FRAME and still included them in Valiant Horizon. On the rolling front, though, I’m quite happy with how Total//Effect attacks work on this front, the attacker has all the information on their end to resolve an attack and just tell the defender what happens which cuts a lot of messing around. One place where this has come up a lot is actually the Drops roll in APOCALYPSE FRAME because everyone always asks around as to who needs it, etc and someone’s always not paying attention or doesn’t want to be that jerk who goes “yeah give me everything” - it’s an awkward system in a game that’s mostly streamlined enough, if not perfect.
• Look up: God, this is all over APOCALYPSE FRAME given its tag system. Tags: not even once. At least they’re all on one spread so you can largely just put a bookmark in that spread and go for it. For Celestial Bodies I actively avoided this by redefining each keyword every time it showed up, but eventually I pulled Disabled out to just be a common thing because it came up a whole lot and at a certain point you’re not gaining that much by having to redefine it. (Some looking up is fine! Helps when it’s a word that mostly does what it says rather than pure keyword-jargon.) Celestial Bodies avoids a lot of this in general by having your mech be defined almost purely by what’s in your Build - anything passive or active that we add outside of that paradigm (for example, Psychic abilities) risks diluting this advantage, so I’m trying to keep a pretty tight leash on those kinds of things for that reason.
• Calculate: I’ve done pretty good on this front because I like small numbers, but high level Valiant Horizon gets a little sticky here sometimes but all in all it’s not too bad. One thing that helps is I’ve found advantage/disadvantage are easier to use than a bunch of +/- 2’s because you’re not actually adding any more values that way, you’re rolling a little differently and just choosing your basis prior to totaling, which ends up being a little quicker.
• Compare: Ditch hit rolls, ditch AC, free your mind! Most everything I’ve done past 36th Way has done this and it’s good - when the value is static it makes things real quick. I feel pretty good about my solutions on this front. It’s not technically static in Celestial Bodies but it’s extremely scannable, which is the next best thing.
• Determine: APOCALYPSE FRAME is the biggest culprit here: it could do way better as far as providing pre-made complications/consequences that aren’t just “an enemy attacks too” for out-of-combat stuff. In a future edition I’d probably include a d66 table for ’em like I did in Liminal Void. Valiant Horizon and Celestial Bodies have this a little too but it’s basically always in a situation where a player both provokes it defines what the downside is so I think it works a little better. The Bloodied/Staggered example came to mind here because I pointedly tried to sidestep this in Valiant Horizon by providing Winded values for players and mostly keeping high-Vigor enemies at easily-dividable values. Celestial Bodies has a little bit of this with reliable reactors: in this case I feel like they mostly get away with it because Ultras aside, it’s mostly opt-in.
• Record: This is where I feel like I can definitely improve. A lot of my designs have a lot of different “meters” to track because I prefer resource expenditure over static values, but with enough of those going back and forth that can be a real burden. In general it’s probably not too-too bad but some of them could absolutely be simplified: for example, I like where attributes in Liminal Void have landed but charge/ammo on equipment probably still needs further simplification. Money in Liminal Void is something I’ve gone back and forth on quite a bit on this account too: I want to get that feeling of being nickel-and-dimed in there but without like…wasting everyone’s time. One reason amongst many that game is still in development. Celestial Bodies shield generators get particularly sticky here given each is tracked separately: heavy/ultra mechs can get pretty hairy in that regard, especially if some of the generators have Resilience processors and some don’t. Valiant Horizon gets a little annoying when a stack of 4 Vigor minions each takes 1 Harm over and over.

And thinking about those process types:

• Uncommon processes: I’ve mostly avoided this entirely in my post-36th-way stuff, mostly because I believe that if you have a resolution mechanic you should use it; there’s a few ones in there like Valiant Horizon’s reputations that are a touch far afield. Trespasser has that weird skill+equipment roll-two-dice mechanic too. Always something can be sanded down a bit more.
• High-frequency processes: This is a huge thing on my end because I like it when players can chain together more basic actions into a combo rather than just be given a power that does it for them, so all of my games can have some pretty intense action economy. Celestial Bodies lets you do a ton of attack rolls per action, but mostly this is mitigated by the fact that you don’t frequently get that in conjunction with positive accuracy so there’s relatively little choice per roll (and indeed, usually it’s negative, so a lot of those will miss). (And from the start I considered Celestial Bodies a higher-overhead game though so that’s fine by me usually.) Valiant Horizon’s higher tiers get into large numbers of actions per turn too - 3, 4, 5 actions before you get into “give X buddies an action” powers! For players this is mostly not a big deal because if you’ve been playing since the first tier you pretty much know your kit, but it can clog things up with enemies who get more. I mitigated this a little bit in the most recent version by changing how Elites work such that they can’t just spam one attack over and over, but can instead spend those extra actions charging up an attack. APOCALYPSE FRAME light Frames can act a TON during a turn, which is why I’m particularly keen on thinking about how to revise those - swapping to diceless resolution vs removing rerolls (diceless vs. dice is basically removing “roll” in favor of “record” and runs into oddities with scaling, so it has pros and cons), coming up with better defined material for complications, and so on.
• Hidden information processes: I’m a big fan of tension over surprise, so mostly I’ve avoided this one just by being fed up with traditional D&D “keep your cards close to your chest” shitty-GM moves to begin with! Celestial Bodies only works at all, even if you play with a GM, because information isn’t hidden - it’d slow to an absolute crawl otherwise.

I’m sure you can do the same to your games. If you find that something’s pretty high up there, it’s ok! Despite the title, there’s nothing to worry about. The truth of the matter is that this is a hobby made up of a lot of people who have simply not put that much thought into this, and that could be you - and that’s fine. If you want to improve it, though, the thing about games in the internet age especially is that you can always make another version and put it out, even if it’s already out. I’m going to try to keep improving my craft, making things tighter, making them better, optimizing processes as much as possible, and in general iterating to make my existing games continually better and improve future ones. I recommend you do the same.

Comments