Simplifying Large Battles: a Dice Pool approach

The problem I'm trying to solve

Large battles, involving 15+ combatants, are exciting on the page or screen. But running them at the tabletop takes a long time and involves a painful level of bookkeeping, even in OSR games.

Tracking individual attack bonuses, AC, HP levels, special abilities, status effects and, in some systems, initiative order is a lot of work. It's particularly annoying when the battle involves monsters / NPCs on both sides, with or without the PCs joining in.

Sure, you can always handwave the ebb and flow of a large battle. But I couldn't help feeling that there must be some way of resolving it in a simple, fast and fun way that doesn't entirely sacrifice the detail of what's happening round by round.

So I've invented a dice pool system to speed it up. My design goals for this were:

• Fast and simple - ideally zero prep
• Fun
  
• Tracks round by round attrition to each side
• Allows tactical / positional factors to be reflected
• Allows a mixture of creatures on each side of the battle
  
• Allows PCs to take part using the regular combat rules of the game

I haven't found any other systems which tick all these boxes for me. Having said that, it feels like my solution is so obvious and intuitive that someone must have come up with it before. Please let me know who!

The Glint RPG mass combat system

Each side gets one die for each of its members. The size of the dice are determined with the following rule:

• d4:    The weakest creature in the battle, with X HD (e.g. 2HD)
• d6:    1.5X HD creature (e.g. 3HD)
• d8:    2X HD creature (e.g. 4HD)
• d10:  2.5X HD creature (e.g. 5HD)
• d12:  3X HD creature (e.g. 6HD)
• d20:  5X HD creature (e.g. 10HD)

If you have a wider range of creature strengths in the game than that, you might want to start with a d4 representing two or more of the weakest creatures or by giving the strongest creatures more than one die (see the Potential Issues section below for discussion of that).

For really large battles, each die could represent 5, 10 or 100 creatures.

Once you've created the dice pools for each side, roll them. Then do the following:

1. If one side outnumbers the other side by Y dice, put that side's Y dice with the lowest results to the side.
2. Now that each side has the same number of dice, create a series of 1v1 dice contests, facing off one side's lowest result with the other side's highest result and proceeding like that down the line.
3. Take the Y excess dice and add them, one by one, to their team's side of the dice contests. The highest excess die joins its side's strongest die, the next highest joins the next strongest, etc. If you reach the end of the line and have dice left over, start again by adding the highest remaining excess die to its side's strongest die, and so on. Continue like that until you've allocated all the dice.
4. Now compare each team's total score in each contest. If one side beats the other by at least 3 points, all the losing dice/creatures die and are removed from their dice pools.

And that's a round of combat. Repeat, removing dead creatures from the dice pools until the battle is over.

Worked example

Ten Gnolls (2HD) are fighting three Tigers (6HD). Let's assign d6s to the Gnolls and d20s to the Tigers.

Rolling each pool, we get:

• Tigers (d20):     14, 13, 7
• Gnolls (d6):       6, 6, 6, 5, 5, 4, 3, 1, 1, 1

The Gnolls outnumber the Tigers by seven, so we put aside their lowest seven dice and then pair the remaining three Gnoll dice with the three Tiger dice, with each team's largest result facing the other team's smallest:

• 14 (Tiger) vs 5 (Gnolls)
• 13 (Tiger) vs 6 (Gnolls)
• 7 (Tiger) vs 6 (Gnolls)

Now we assign the excess Gnoll dice which we put aside earlier to the contests we've just created. We put the highest remaining Gnoll die with the highest Gnoll die from the last step, and so on. When we've assigned one excess die to each contest, we repeat this step. This leaves us with the following match-ups:

• 14 (Tiger) vs 5 + 4 + 1 = 10 (Gnolls)
• 13 (Tiger) vs 6 + 5 + 1  = 12 (Gnolls)
•  7 (Tiger) vs 6 + 5 + 3 + 1 = 15 (Gnolls)

In the first contest, the Tiger won by 4. That's one above our kill threshold, so that Tiger's three Gnoll opponents die.

In the second contest, the Tiger won by 1. That isn't enough to kill a Gnoll.

In the third contest, the Gnolls won by 8. A Tiger dies!

After that round, we're down to two Tigers and 7 Gnolls. A new round starts so we roll these reduced dice pools again:

• Tigers:      19, 9
• Gnolls:      6, 4, 3, 2, 2, 1, 1

Now we put the five excess Gnoll rolls aside, like before, to create new match-ups:

• 19 (Tiger) vs 4 (Gnolls)
• 9 (Tiger) vs 6 (Gnolls)

Then, we assign the excess Gnoll dice as before:

• 19 (Tiger) vs 4 + 2 + 1 = 7 (Gnolls)
• 9 (Tiger) vs 6 + 3 + 2 + 1 = 12 (Gnolls)

So the first Tiger kills the three Gnolls it was facing, while the other Tiger dies. There is now one Tiger left, facing 4 Gnolls. It's not looking good for the Tiger!

With only one creature left on one side, the process for the final round is simplified. We just compare the other team's total roll to the last Tiger's. This gives us: 

• 16 (Tiger) vs 4 + 3 + 3 + 3 = 13 (Gnolls)

The tiger kills the last four Gnolls and wins the battle!

I appreciate that this looks a little complex on the screen. I promise that it's vastly simpler when you're just rolling and pairing up dice. You don't have to write anything down at all.

Reflecting tactical or other advantages

If one side has a significant defensive advantage (e.g. is holding a strong position or has unusually good armour), you can increase the 3 point threshold the other team needs to get a kill. This can be useful for modelling situations like the storming of a castle wall.

If one side has a significant offensive advantage (e.g. powerful magic weapons or spells), you can reduce the 3 point threshold it needs to get a kill.

If one side is armed with ranged weapons and the other has to cross open ground to meet them, give the ranged side one or more rounds of combat in which only they can inflict kills before the groups meet.

How do we work the PCs into these battles?

It's actually quite easy. Simply decide how many creatures are going to be directly engaged with the PCs. Then remove those creatures' dice from their side's dice pool and run the PCs' part of the battle like any other fight. Each round, if the GM feels it's appropriate, more creatures can leave their side's dice pool to engage with the PCs.

If the PCs use AoE attacks which take out more creatures than they're directly engaged with, just remove more dice from the pool. If they do something which gives their wider team an advantage (or the enemies a disadvantage), play with the kill thresholds as described above.

My simple Glint RPG Horde rules can also be used to good effect in this system. I'll write about them separately.

Playtests

So far, I've only tested this with my wife rather than in an actual game. But we were both struck by how smooth and fun the system was, and by the cool stories it tells as the creatures fall during the battle. You can see small creatures ganging up to bring down larger ones, and larger creatures killing multiple little ones with a single blow. It's pretty cool.

Battles with around 20 creatures generally seemed to take around 4 rounds to resolve, which I think works pretty well with the usual length of OSR fights. If it's a bit too fast (or slow) for you, the kill threshold can be tweaked up or down from 3.

Potential issues with the system

You need quite a lot of dice. But most RPG tables have a lot of dice.

It doesn't work very well on VTTs, so the GM would probably still have to use physical dice. Having said that, it should in theory be possible to build a simple app for this.

Sometimes, combatants' HD values won't fall perfectly into the d4-d20 system. But in practice, I think almost any combination can be made to work by slightly fudging the numbers. Extremely strong individuals can be modelled with multiple dice, but you do then have to roll them separately to keep track of them. You can either use them as a block or assign them separately to individual dice contests, increasing that creature's killing power but allowing it to lose individual dice over time.

There's a slight issue whereby the strongest creatures / dice are the last to receive extra opponents when outnumbered, which means they don't tend to kill multiple targets per round. I'm still thinking about that one.

The biggest omission from the system so far is probably guidance on how and when to use Morale Checks in large battles. I think the answer is probably to give every creature/dice unit on one side a Morale Check when half their team's dice are gone, and potentially also when any champion / leader dice die (e.g. the d20 in the middle of all the d6s and d8s). But I need to play around with that a bit more.

Please give this a try!

I'd love people to try this out - either in a real game or just with a handful of dice on their own - and let me know how they get on. And please let me know if the rules aren't clear. Thanks!