Thread by @colewehrle

Yesterday I had a few folks ask me about the changes coming to the combat system in #oathboardgame. I don't have time this week to write a longer article, but I think I can manage a twitter thread.

I should say at the start at this change is the sum of a 4 or 5 week investigation and several weeks of heavy design work that I began while performing the game's final mechanical review.

Basically, as we mapped out the last stage of our production schedule, I had a few weeks free up, and I wanted to use that time well. After reviewing the whole design, I felt a little dissatisfied with the game's combat engine and felt like I could do better.

I should say that in terms of output, Oath's combat system was doing exactly what it needed to do. But, I felt it was sometimes a little unhinged from the game's narrative logic, was a little tricky to teach, and sometimes didn't have the right emotional punch.

In terms of what it asks of it's systems, Oath is a really demanding game. For instance, the combat system needs to deal with all sorts of force configurations (big vs big, big vs small, etc). It also needs to support about 40 modifying powers.

On top of all of that, the combat has to compress time. That is, it needs to be able to resolve a gigantic campaign where the possible spoils include several sites, a midnight raid to steal an artifact, or a simple pitched battle.

I could write a lot about this last point, but for now I'll just say that this is a critical element of Oath's design. Players can perform tremendous pivots in the game and make up for lost time. It goes a long way in giving the game it's generational scope.

Oath's original combat was built on three elements: force size, scope, and technology. All of these were measured in terms of warbands. That is, if you fell short in any one area you could make up the difference by being able to pay in blood.

Force size used the old trick of wargames: ratio tables. Basically, if the attacker had 3 times as many units as the defender (3:1) they wouldn't have to pay any extra blood. For every column shift (2:1, 1:1, 1:2, etc) you'd have to kill a warband to make up the difference

The scope of the campaign was handled using the goal dice. For each objective the attacker had to roll a die and the total would provide an additional cost to be successful. Each die had pair of blanks, -1s, a single -2, and a doubler that would double the roll.

The doubler was very important because made these losses operate as exponential function as the scope of the campaign increased. In addition, the blank sides allowed for a huge amount of variance in the result. This was the price of time compression.

Finally, there were a number of cards in the deck that provided +/- bonuses depending on the cards you had control over, which allowed for a lose kind of rock-paper-scissors countering system.

So, some problems then: 1st. combat required players to perform addition, subtraction, multiplication, and division. 2nd. It was hard to intuit what your chances of victory were. 3rd. The defender felt as if they had no agency. 4th. The battle techs felt generic.

None of these were serious game-breaking problems, but they were things I wanted to address if I had time. As I said earlier, the actual system outputs were pretty good! I just didn't like how I got there.

From the start the priority was to build a system that could cleanly replace what was already there. So the first step was measuring the old system, getting average losses and win percentages for about 10 different force configurations.

After that I built a little model in python that allowed me to quickly make system alterations and run thousands of games to see how an adjusted rules stacked up. In the end, I went through about 6 different major versions with dozens of other small adjustments.

I spent a long time looking at charts that showed these configurations fighting at different scopes and checked both win percentage and also average losses.

At one point I had a nearly perfect match! I went so far as to prototype it and see how it felt in play and it was awful! What could have gone wrong? Well, turns out I hadn't been measuring standard deviations and while the new system had great means, the variance was horrendous.

Eventually though we found a system that worked. I should underline that this part of the process was deeply collaborated, with both @joshuayearsley and @BickNachmann making excellent, critical suggestions that made the final system what it is. Here's how it worked:

First, the attacker declares their spoils, giving the defender a banner die (blue) for each spoil they declare. Then the attacker gathers up warband dice (red) up to the number of warbands in their attacking force.

Attacker and then defender activate their battle plans which may modify the size of the dice pools or place other rules into effect.

Then the defender rolls their blue dice (which has the same faces as the old misfortune die but with cute shields) and adds that roll to the number of warbands in the defender force. This is their strength. They will then call it out e.g. "I defender with 6!"

To win, the attacker needs a strength that is higher than the defender. They roll their attacker die. It looks like this:

Each sword is a hit. The hollow swords are half hits that round down. And the double sword and skull is 2 hits + a self-kill. Like the old system, after rolling the attacker could sacrifice any of their warbands for an extra hit (and were compelled to do so if it led to a win.)

In general this new system creates almost the same numbers as the old one with a few improvements. In addition, it opened up space for rebuilding how battle plans worked in ways that were much more thematic. More about that shortly.

So the old system used a kind of countering system with suit liabilities based on what you owned. Here's an example:
This card says that you get a modifier = to the number of nomads you rule if you're fighting a beast card. Neat.

But in practice players generate liabilities pretty haphazardly and translating everything to a single number started feeling a little flat. This lead me to a big realization: countering tables (think Pokemon) can be understood as system failures.

Basically the system of the game isn't expressive enough to tell you water type is good against fire type, except for the fact that moves/pokemon coded in that way get bonuses.

I promise I'm not trying to be pedantic (and I love pokemon), but the countering system just doesn't interface with other game elements. It's an additional layer of abstraction used to justify itself. Maybe an example from Oath will show you what I mean.

Consider these two cards:
The first gives a bonus of 3 vs. a beast liability. The second gives a bonus of 3 if you (the caster) hold the Darkest Secret.

Both cards have a liability. But the second liability leans into the mechanical and thematic framework of the game. If you control the Darkest Secret, you get access to magic. The same cards that protect and threaten it also protect and threaten your ability to use this card.

This didn't mean that we had to drop the idea of suit liability either. Consider: Both have similar effects, but now the liability is narrower. Order cards, espeically those on sites, are defensive in nature. The Disgraced Captain allows you to break entrenched positions.

This is a lot more specific in the narrative sense and goes a long way in folding the battle plans into the game's emergent storytelling.

As a general design, Oath is naturalistic, leaning hard into its thematic underpinnings to generate its challenges and stories. The revised combat system goes a long way in bringing that design ethos to an element of the game that was always more utilitarian than dramatic.

And, I'm happy to report that the new system cut the combat rules down by about 40% and is much easier to think about and teach in practice. My hope is that we'll be folding this system into the public TTS mod along with buckets of new cards and art in the coming weeks or sooner.

to tell you WHY water type is good against fire type*