One of my top 3 games of all time is Arkham Horror, 2nd Edition.   My friends and I played the heck out of it when it first came out, and we still play at least once a year for Halloween (I have at two copies for two groups)!  It seems to be a real crowd pleaser in my game group(s), but it’s not for everyone: it has a lot of rules to absorb and a lot of components to manipulate.  My game group(s) have absorbed it and know the game quite well.

Something happened as we played Arkham Horror more and more:  we started to “streamline” the play.   The rules (above) dictate that play proceeds from the first Player (clockwise), and each player must finish their phase COMPLETELY before moving on to the next player.

To quote the rules (see complete rules here, page 5):

During each phase, every player, starting with the first player and continuing clockwise, performs the actions that take place during that phase

When we are playing strictly by the rules, our game play is sequential: every player action has to finish before the next player action completed.

We noticed this was taking waaaaaay too long!!! So what did we do??? We all started taking our turns at the same time!  Basically, everyone gets tired of waiting for “their turn to come”, but since this is a cooperative game (and we are all working together), we can all go at the same time!  We all perform UPKEEP at the same time.  After that’s done, we perform MOVEMENT at the same time, and so on.

In this mode, we are play each phase concurrently: players all act at the same time!

Visualization of Sequential and Concurrent Play

One way to think of the sequential play is to visualize it as a line of actions: Player 1 performs UPKEEP, player 2 performs UPKEEP, (UPKEEP complete), player 1 performs MOVEMENT, player 2 performs MOVEMENT, (MOVEMENT complete) and so on.

In concurrent play, you can think of each phase as a giant bubble of activity: all players perform UPKEEP concurrently (waiting for each other to finish).  Then all players perform MOVEMENT concurrently (waiting for all other players to finish), and so on. See below.

This particular concurrent method SIGNIFICANTLY speeds up gameplay, as there is much less waiting!  In fact, this very idea is used in Computer Science to make computer programs go faster!!! You take a computer program and parallelize it, causing a bunch of work be done!  In Computer Science circles, this idea is expressed in many ways: the Scatter-Gather, Work Crew, or Map-Reduce. (See here for reference)

If you can do this, this is an easy way to parallelize, or make gameplay faster!

Sequential Consistency

The problem with all of us acting at the same time was that were times  when two (or more) players collided in their actions!!  For example; What if we both drew from the same deck?    Since this is a friendly, cooperative game, the order we might draw from the deck doesn’t matter: we just both draw and one of us just happens to go first.  If we were feeling pedantic, we would draw in player-turn order, but most of the time we didn’t care: it was better to be moving quicker through the game than care about “who-got-which-cards”.

If we were pedantic in our play, we were ensuring that the game was playing EXACTLY the same way as if we had played WITHOUT the concurrency.  In other words, if everything happens in the exact same order as the game had played WITH THE SEQUENTIAL RULES.  If we can do this with our concurrent play, we are ensuring sequential consistency.

In other words, as long as we are pedantic in our concurrency, we are ensuring that the game plays out in exactly the same way: it is sequentially consistent.

Relaxed Sequential Consistency

In Arkham Horror, the decks (see above) we draw from are meant to be a source of randomness: the card we draw is meant to be “a random card”.

If that’s the case, does it matter if we are pedantic in the order we draw cards?  We just want a random card!  If that’s the goal, the order shouldn’t matter as long as we are (nominally) getting a random card!

If there are things that really don’t really matter the order that they occur (i.e., , two players drawing from a deck at the same time like above), then we have relaxed consistency.

In the end, this was how we played Arkham Horror 2nd Edition: Concurrent turns with relaxed consistency.   This model helped the game move much faster!

(In fact, the game even says that’s okay …)

Seven Wonders and Simultaneous Action Selection

It’s funny: 7 Wonders has weird place in my game groups: people love it or hate it! (It turns out, it’s just my game groups, see here).  But one thing everybody seems to like is the Simultaneous Action Selection!! This is very similar to what we ended up with in Arkham Horror (concurrent play with relaxed consistency), but the concurrent play  in 7 Wonders is much smoother.  Frankly, there’s only two main phases (passing cards concurrently and then playing cards/effects concurrently, see below)! 7 Wonders has been designed to avoid the consistency traps we saw in Arkham Horror!  Arguably, that’s Simultaneous Action Selection’s greatest feature: simple concurrency with no need to ensure a consistency model: that’s just the way it works.

If you squint, you can visualize the two concurrency phases in the main play:

1. All players select 1 card and then pass the rest (ALL HAPPENING CONCURRENTLY)
2. All players reveal and “act” on their card (buying it, putting it under wonder, etc) (ALL HAPPENING CONCURRENTLY)

That’s why 7 Wonders works so well with a large group: large amounts of concurrency!

Sidekick Saga and Concurrency

The goal of Sidekick Saga was to achieve the amount of concurrency in 7 Wonders, but in a world that must be explored (like Arkham Horror).  Sidekick Saga was designed to be a Simultaneous Action Selection game …  but, it turns out, concurrency is hard.

Originally, the Sidekick Phase (see above) was meant to be purely Simultaneous Action Selection: players strategize together at the start of the phase, then each perform their entire Sidekick Phase completely concurrently!  But several things got in the way:

1. There was the matter of the Lead cards: they are obtained at the end of the turn and can’t be shared that turn (thematically, you spend your whole turn running down a Lead so you can’t share it just yet).  Can I pass newly minted Leads when I get them?  (Answer: no)
2. When you can pass cards?  Can I pass a card I got this turn? (Answer: yes, but only if it wasn’t passed to you this turn! Only if you picked it up!)
3. What happens when two players draw from the same deck?  (Similar to Arkham Horror, but now order can matter if you have the X-Ray Specs)

Addressing each of these is simply a matter of making sure you ensure sequential consistency, but there’s just enough edge cases/rules that it can be confusing, especially as players are learning the game.

So I backed off Simultaneous Action Selection to a Concurrent with sequential consistency model  … like Arkham Horror.  At least players would getting SOME parallelism.  Recall, however, that model was achieved ONLY BY EXPERTS AT Arkham Horror!!  Playtesters, even with experienced players, got confused by the model.  So, I had to introduce a purely sequential mode: Novice!

In an ideal world, there would be three modes of Sidekick Saga:

1. Novice (as players become familiar with the actions): sequential play
2. Normal (once players are comfortable with the actions): concurrent play with sequential consistency
3. Advanced (players know the interactions very well): concurrent play with relaxed consistency, approaching Simultaneous Action Selection.  (For this to work, we have to be sure to have rules to deal with of the few edge cases we identified above).

The problem is that Novice was a bad word to use (and what Rahdo picked up on his “Final Thoughts” video).  Novice implies someone who is perhaps not used to modern board games: that’s not at all what I meant!  I meant someone who is new to THIS GAME!!  So, that’s my fault.  What I should have used:

1. Normal (sequential)
2. Advanced (concurrent play with sequential consistency)
3. Expert (concurrent play with relaxed consistency)

The Second Edition of the game will fix this (and there will probably be an updated rulebook on BoardGameGeek).

Conclusion

Concurrency is hard to think about.   In Computer Science curriculum, concurrency is so hard, it’s typically an upper-level college or graduate level course (When I took it, it was a graduate level class). SOme of the lessons I have learned here:

1. Don’t introduce concurrency unless it’s very simple concurrency (like 7 Wonders and Simultaneous Action Selection)
2. Realize that concurrency can be hard (and name modes that use it appropriately)
3. If you are going to introduce concurrency, make sure your rules explain it well and have lots of pretty pictures