I’m tinkering with a framework to implement board games in c# (similar to boardgame.io in JS) part of that is getting a handle on turn structures. (What is a round? what is a turn? who gets to go when? etc)
So I’ve gone through all my games and looked for recurring patterns and exceptions to them and here’s what I’ve collected so far:
- There’s always at least one structure that handles how player act or “take turns”
- the vast majority of games do traditional turns - one player does things, then then another,
- usually in a fixed order maybe going forward some times and backward other times.
- sometimes the order can change
- also possible are:
- turn order decks (you don’t know who goes next but know that everyone gets a turn)
- action tracks (where whoever is furthest back gets to go next, possibly resulting in an uneven number of turns)
- the next player is dependent on an action of the previous player
- it’s also possible that players can play simultaneously
- a complete free for all is pretty common
- it’s also possible that players can act freely to some point, then have to wait for everyone else to catch up
- another consideration, both for concurrent and sequential play is that sometimes some players are excluded (Codenames for example lets all guessers on a given team act concurrently but not the leaders or the other team)
- there can be different rules at different times (like first picking a tile in sequence then everyone can place it simultaneously)
- and there can be nested rules (like every player gets to run an auction but in every auction each player get’s to bid as well)
- one relatively common special case is where certain actions on a player’s turn result in decisions being needed from other players (trades, attacks, “each player …” effects)
- the vast majority of games do traditional turns - one player does things, then then another,
- there are often structures that simply subdivide another structure
- they can occur at any level. A game may be divided into “setup” and “play”, a round could be divided into different phases but a single player’s turn might also be divided into smaller steps.
- these subdivision usually restrict / specify which actions are allowed in them
- these subdivision often come with limits like: you can only do N actions
- sometimes a player can “pass” sometimes they cannot
I’m wondering if anyone can think of an instance that is not covered by these “rules”.
Interesting challenge! Its curious how programming leads to this systematic analysis and the revelation of complexity even for “simple” things
There are some games where the turn order can be influenced that I am not sure are covered by your rules:
5 tribes has a auction-style system by players committing a certain amount of currency to occupy a specific slot in the turn. For 2 player game each player goes twice and auctions twice for the upcoming turn
Bot factory is using a rotating worker placing mechanic with 4 sections with each 2-3 worker position, with the limitation that you cannot remain in the same section
Castles of Burgundy player order divided in 5 turns divided into 5 phases which changes depending on playing certain tiles (ships and specific monasteries)
oh nice! The 5 tribes is probably gonna be a variant of the “action track” system.
Not quite sure I understand the “Bot Factory” example. Is that more than just a simple sequential structure and the restriction is only about what you can do this or next turn?
Burgundy: That’ll also be interesting. Could do that by transitioning straight to the next applicable phase, or could keep the structure simpler and just auto-terminate any phases where the player has nothing to do.
Thanks!
Bot factory has a turn order track that is read from right to left. It has roughly 10 positions that are separated into 4 regions. You can not choose a similar spot in the same region as your previous turn. Additionally, there is a worker that will always move from one section to the next, occupying the next available slot. This is the AI-worker and essentially a fifth player with special rules.
Burgundy player turn is determined also by a track, players can occupy the same slot. The position is marked by stackable player tokens with the top player of the stack going first. The last player to advance to the next section of the track will play first but the next player to advance there will be stacked on top and thus become the first. However, there is an ability that can be acquired by one player during the game which makes their stackable player token always be on the top, irrespective of when others join their stack
Bot factory has a turn order track that is read from right to left. It has roughly 10 positions that are separated into 4 regions. You can not choose a similar spot in the same region as your previous turn. Additionally, there is a worker that will always move from one section to the next, occupying the next available slot. This is the AI-worker and essentially a fifth player with special rules.
That still doesn’t necessarily have anything to do with turn structure. When do the players actually move from one spot to another? If it’s just a normal WP game where you get your turn and move your worker and the only restriction is that you can’t put it back to a similar spot then that’s a simple sequential set of turns. The other possible explanation I see is the WP spaces also functioning as an action track.
Rather than trying to define abstractions for turns and rounds, maybe you could implement the game state (and possibly individual players) as a finite state machine.
In this model, the way you set up the states and transitions for a particular game will capture its idiosyncracies in turn and round order.
That’s what I’m currently doing. But I’m not yet sure if a straight FSM is such a great fit. There’s not good mapping for the concept of turns in a single level FSM. You can do it of course but if you have multiple such models or nested instances where each player gets to react to specific actions on each player’s regular turn, each of them is gonna push the the properties needed to manage that into the shared state.
So I’m currently at nested state machines. This way the implementation details for alternating between players can be hidden from the higher level states.
BGA’s state machine might be worth checking out. There are also a bunch of game implementations using it on Github.
Looks quite comprehensive! Some cases that may or may not fit in already:
- Turn order for the rest of the round determined by an early simultaneous step of the round: Gloomhaven, Undaunted, Khôra: Rise of an Empire
- Player gets an immediate extra turn due to an action: Mottainai “Frog” card
- Game ends immediately (mid-round) due to player action: Mottainai again.
- Round ends immediately due to a player’s action skipping the other players’ turns: Cubirds
- Parts of the round are timed: Bullet♥︎, Flatline
Thanks a lot for those examples! Totally forgot about those “extra turn” effects. That’ll be fun.
I had already considered a bunch of concepts about how a phase can end but not that it might be completely independent from any player action.
The Gloomhaven scenario probably is the easiest of these since it is merely a variant of the general “player actions result in change of player order” case