Why Does RPG Combat Take So Long?

The door opens and six very surprised goblins find themselves staring at four equally surprised adventurers.

The fighter draws his sword. The rogue dives toward the wall. The wizard is already thinking about which spell will catch the most goblins without setting the fighter on fire. One of the goblins shouts something that probably isn't complimentary, another reaches for a bow, and the biggest one charges.

For the characters, the next minute is going to be frantic.

For the players, it could take an hour.

We've all been in combats like this. The fight begins with everyone leaning toward the table, but somewhere along the way the energy starts to fade. Someone checks their phone. Someone gets a drink. Someone starts a conversation that has nothing to do with the game. Then a player suddenly hears their name and looks up.

“Wait. What happened?”

The strange part is that nothing has necessarily gone wrong. Nobody is arguing about a rule. The GM isn't struggling. The players know their characters. The game is working exactly as designed.

It's just taking a very long time to do it.

So why does RPG combat take so long?

The obvious answer is complexity, and sometimes that's true. A game with lots of modifiers, charts, special cases, and calculations can certainly slow things down. But we've played relatively simple games where combat still dragged, and complicated ones where a fight moved surprisingly well.

The number of rules isn't the whole problem.

A much bigger problem is what we're doing with the time.

Six Seconds at a Time
Think about what a fight actually looks like.

Nobody waits.

The fighter doesn't swing his sword and then politely step aside while the goblin considers its options. The rogue doesn't freeze halfway across the room because the wizard hasn't finished casting. The archer isn't standing motionless with an arrow drawn while everyone else completes their attacks.

They're all doing something.

The fighter advances while the goblin backs away. The rogue moves around them both. The wizard begins casting while an archer tries to interrupt the spell. Someone falls. Someone else sees an opening and takes advantage of it.

A fight is a collection of overlapping events.
At the gaming table, however, we often take all of those simultaneous events and put them in a line.

The fighter goes first. They decide what to do, make the appropriate rolls, determine the result, apply damage, and resolve any effects. Then perhaps the rogue goes. Then the wizard. Then a goblin. Then another goblin. Then another.

A few seconds in the imaginary world can require ten or fifteen separate stops at the table. Each stop may be quick. That's what makes the problem difficult to notice. Thirty seconds doesn't feel slow. Neither does a minute.

But give twelve participants a minute each and your six-second combat round just took twelve minutes.
Now do it again.

The Player Who Had a Plan
There's another problem hiding inside that line of turns.

Imagine you've just finished yours.

You know exactly what you want to do next. The ogre is near the doorway, your companion is keeping it occupied, and you've got the perfect attack ready.

Then you wait.

Another player acts. An enemy moves. Someone casts a spell. One of the goblins falls. The ogre charges across the room. Your companion follows it. The wizard creates something unpleasant where you were planning to stand.

Five or ten minutes later, your turn comes back around. Your brilliant plan is now completely useless. So everyone waits while you make another one. That's not because you're a slow player. You were ready. The battle changed while the game required you to wait.

This is where slow combat can begin feeding on itself.

The longer players wait, the harder it becomes to remain completely focused on everything happening at the table. Once someone stops paying attention, their next turn takes longer because they need to catch up. That makes everyone else wait a little longer, which makes it easier for the next person to lose focus.

Eventually we reach that familiar moment.

“Your turn.”

“Already?”

It wasn't already.

It just felt that way because they weren't really part of the game for the last ten minutes.

How Many Rolls Does It Take to Swing a Sword?
Waiting isn't the only place combat time disappears. A surprising amount vanishes after the player has already made the interesting decision. The fighter decides to attack the ogre.

Good. That's the decision.

Now we need to find out what happened.

Depending on the game, we may roll to hit, apply modifiers, compare the result against a defense, roll damage, add another modifier, subtract armor or resistance, determine whether some additional effect occurred, make a saving throw, check whether another ability triggers, and perhaps resolve a reaction from someone else.

None of those procedures is necessarily bad. Some may provide exactly the kind of detail the game wants.

But there's a useful question hiding underneath them:

How many times does the game need to stop to answer one question?
The fighter swung a sword at the ogre. That's one event in the story.

If resolving that event requires several separate procedures, each procedure costs a little time. Ten seconds here and twenty seconds there don't seem important until we multiply them by every attack, by every participant, by every round, by every combat during the evening.

Suddenly a significant portion of game night is spent determining the results of decisions players already made.

That's where we think the distinction between tactical and complicated becomes important. They aren't the same thing.

Don't Remove the Decisions
There's an easy way to make almost any combat system faster: remove things.

Make weapons mostly the same. Ignore hit location. Simplify armor. Reduce movement choices. Remove reactions. Reduce the number of spells. Abstract positioning. Give characters fewer combat options. (Sounds like a system I grew up playing)

Eventually combat becomes extremely fast.

It may also stop being the kind of combat your players enjoy.

That's never been the direction we wanted for Mayhem (our upcoming rpg system). We like tactical combat. We want a player deciding whether to advance, defend, maneuver, cast, attack, retreat, take a risk, or help someone else. We want the difference between weapons and armor to matter. We want injuries to matter. We want circumstances on the battlefield to change what the smart decision is.

Those decisions are playing the game.

So when we started looking at combat speed, we didn't ask how many decisions we could remove. We asked how much unnecessary time we could remove between those decisions. That led us to start looking at individual mechanics differently.

If an attack is one event, for example, why should we necessarily need several rolls to describe it?

In Mayhem, a combat roll can tell us whether an attack hit, where it hit, how much damage it caused, and what kind of damage it caused.

One roll tells us what happened.

The tactical decision is still there. The weapon still matters. Armor still matters. The circumstances still matter. We haven't removed the things the player was thinking about when they chose to attack.

We've simply tried to make the answer arrive faster.
Make the decision. Roll the dice. Keep the battle moving.

Did It Hurt, or Did It Hurt?
Damage presented us with a similar problem.

Role-playing games have spent decades finding different ways to represent injury, and there are good reasons for that. A sword cutting across someone's arm should feel different from a harmless glancing blow.

But tracking every little injury can also create bookkeeping.

Mayhem uses a Damage Threshold to help separate injuries that need to be recorded from all the pain and punishment that happen during a fight. A hit serious enough to cross that threshold creates an injury worth tracking. A lesser hit doesn't necessarily become another number that needs to be carefully recorded.

That doesn't mean it did nothing.

Stub your toe on a table leg. You aren't going to die. For the next few seconds, however, you may become deeply interested in your toe, the table, whoever manufactured the table, and possibly several words you weren't planning to say in polite company.

Pain matters.

We can let it matter without pretending every painful event is a life-threatening wound. Again, this isn't about removing detail. It's about deciding which details deserve bookkeeping and which can be handled more quickly. That's a distinction we keep returning to in Mayhem.

Detail should earn the time it costs.

The Epic Battle Problem
All of these little improvements help, but eventually we run into something much larger.

Suppose the GM wants to create the biggest battle of the campaign. There are the player characters, a few allies, a dozen enemies, perhaps a spellcaster or two, and some enormous creature everyone has been hearing about for the last six sessions.

This should be magnificent.

Unfortunately, traditional turn structures can punish us for making the battle bigger. Every creature we add doesn't merely add danger. It adds another place in line.

More enemies mean more turns. Allies mean more turns. Summoned creatures mean more turns. Eventually the battle we've been looking forward to all night becomes the battle where each player waits the longest before doing anything.

That's a strange relationship between scale and excitement. The bigger the battle becomes, the less often an individual player participates. A climactic battle shouldn't feel like standing in a longer line. And this is where simply making attack rolls faster can only take us so far.

We can resolve an attack in seconds. We can simplify damage bookkeeping. We can make individual actions flow smoothly.

But if the player still has to wait while fifteen other participants take their turns, we've only solved part of the problem.

What Are We Actually Trying to Make Faster?
Maybe we've been asking the wrong question. “Why does combat take so long?” makes it sound as though the goal should be shorter fights. That isn't necessarily what we want.

If players spend an hour fighting the great dragon that has terrorized the kingdom for half the campaign, an hour might feel exactly right. If that hour is filled with plans, desperate attacks, unexpected reversals, clever maneuvers, horrible mistakes, and someone somehow pulling off the impossible at exactly the right moment, nobody is going to look at the clock and complain that combat took too long.

The problem isn't the hour. The problem is what happened during it.

If a player spends most of that hour waiting for their next opportunity to participate, then combat feels slow regardless of how simple the rules are.

If that same player spends the hour watching the situation change, making decisions, reacting to enemies, helping companions, changing plans, and looking for opportunities, an hour can disappear remarkably quickly.

That's what we want from combat. Not necessarily less time.

Less waiting.
Because the fastest combat system in the world isn't doing much good if most of the players are still waiting for permission to use it.

And that leaves us with a much bigger question.

Next from the Engine Room

We've looked at initiative. We've looked at the little delays that can turn a few seconds of imaginary combat into an hour at the table.

But eventually all of those problems lead back to one of the oldest assumptions in RPG combat:

One player acts. Then the next. Then the next.

Turns keep combat organized—but they're also responsible for much of the waiting we've just been talking about.

So what happens if we get rid of them? Does combat become faster and more immediate?
Or does the whole thing collapse into six people shouting, “I attack!” at the same time?

There are ways to make it work. And once turns are gone, combat starts to feel very different.

Next time: Can RPG Combat Work Without Taking Turns?