@mnbroatch/boardgame.io 0.0.1

package/src/core/turn-order.test.ts

@@ -0,0 +1,1123 @@
+/*
+ * Copyright 2017 The boardgame.io Authors
+ *
+ * Use of this source code is governed by a MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ */
+
+import { Flow } from './flow';
+import { Client } from '../client/client';
+import {
+  UpdateTurnOrderState,
+  Stage,
+  TurnOrder,
+  ActivePlayers,
+} from './turn-order';
+import { makeMove, gameEvent } from './action-creators';
+import { CreateGameReducer } from './reducer';
+import { InitializeGame } from './initialize';
+import { error } from '../core/logger';
+import type { Game, State } from '../types';
+
+jest.mock('../core/logger', () => ({
+  info: jest.fn(),
+  error: jest.fn(),
+}));
+
+// Let the Typescript compiler know about our custom matcher.
+declare global {
+  namespace jest {
+    interface Matchers<R> {
+      toHaveUndefinedProperties(): R;
+    }
+  }
+}
+
+describe('turn orders', () => {
+  // Defines a matcher for testing that ctx has no undefined properties.
+  // Identifies which property is undefined.
+  expect.extend({
+    toHaveUndefinedProperties(ctx) {
+      const undefinedEntry = Object.entries(ctx).find((entry) => {
+        const [, value] = entry;
+        return value === undefined;
+      });
+      if (undefinedEntry === undefined) {
+        return {
+          message: () => `expected some properties of ctx to be undefined`,
+          pass: false,
+        };
+      } else {
+        const [k] = undefinedEntry;
+        return {
+          message: () => `expected ctx.${k} to be defined`,
+          pass: true,
+        };
+      }
+    },
+  });
+
+  test('DEFAULT', () => {
+    const flow = Flow({
+      phases: { A: { start: true, next: 'B' }, B: {} },
+    });
+
+    let state = { ctx: flow.ctx(2) } as State;
+    state = flow.init(state);
+    expect(state.ctx.currentPlayer).toBe('0');
+    expect(state.ctx).not.toHaveUndefinedProperties();
+
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('1');
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('0');
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('1');
+    expect(state.ctx.phase).toBe('A');
+    state = flow.processEvent(state, gameEvent('endPhase'));
+    expect(state.ctx.currentPlayer).toBe('0');
+    expect(state.ctx.phase).toBe('B');
+  });
+
+  test('CONTINUE', () => {
+    const flow = Flow({
+      turn: { order: TurnOrder.CONTINUE },
+      phases: { A: { start: true, next: 'B' }, B: {} },
+    });
+
+    let state = { ctx: flow.ctx(2) } as State;
+    state = flow.init(state);
+    expect(state.ctx.currentPlayer).toBe('0');
+    expect(state.ctx).not.toHaveUndefinedProperties();
+
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('1');
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('0');
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('1');
+    expect(state.ctx.phase).toBe('A');
+    state = flow.processEvent(state, gameEvent('endPhase'));
+    expect(state.ctx.currentPlayer).toBe('1');
+    expect(state.ctx.phase).toBe('B');
+  });
+
+  test('RESET', () => {
+    const flow = Flow({
+      turn: { order: TurnOrder.RESET },
+      phases: { A: { start: true, next: 'B' }, B: {} },
+    });
+
+    let state = { ctx: flow.ctx(2) } as State;
+    state = flow.init(state);
+    expect(state.ctx.currentPlayer).toBe('0');
+    expect(state.ctx).not.toHaveUndefinedProperties();
+
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('1');
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('0');
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('1');
+    expect(state.ctx.phase).toBe('A');
+    state = flow.processEvent(state, gameEvent('endPhase'));
+    expect(state.ctx.currentPlayer).toBe('0');
+    expect(state.ctx.phase).toBe('B');
+  });
+
+  test('ONCE', () => {
+    const flow = Flow({
+      turn: { order: TurnOrder.ONCE },
+      phases: { A: { start: true, next: 'B' }, B: {} },
+    });
+
+    let state = { ctx: flow.ctx(2) } as State;
+    state = flow.init(state);
+    expect(state.ctx.currentPlayer).toBe('0');
+    expect(state.ctx).not.toHaveUndefinedProperties();
+
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('1');
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('0');
+    expect(state.ctx.phase).toBe('B');
+  });
+
+  test('ALL', () => {
+    const flow = Flow({
+      turn: { activePlayers: ActivePlayers.ALL },
+    });
+
+    let state = { ctx: flow.ctx(2) } as State;
+    state = flow.init(state);
+    expect(state.ctx.currentPlayer).toBe('0');
+    expect(state.ctx.activePlayers).toEqual({
+      '0': Stage.NULL,
+      '1': Stage.NULL,
+    });
+    expect(state.ctx).not.toHaveUndefinedProperties();
+
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('1');
+    expect(state.ctx.activePlayers).toEqual({
+      '0': Stage.NULL,
+      '1': Stage.NULL,
+    });
+  });
+
+  test('ALL_ONCE', () => {
+    const flow = Flow({
+      phases: {
+        A: { start: true, turn: { activePlayers: ActivePlayers.ALL_ONCE } },
+      },
+    });
+
+    let state = { ctx: flow.ctx(2) } as State;
+    state = flow.init(state);
+
+    expect(state.ctx.phase).toBe('A');
+    expect(state.ctx.currentPlayer).toBe('0');
+    expect(Object.keys(state.ctx.activePlayers)).toEqual(['0', '1']);
+    expect(state.ctx).not.toHaveUndefinedProperties();
+
+    state = flow.processEvent(state, gameEvent('endTurn'));
+
+    expect(state.ctx.phase).toBe('A');
+    expect(state.ctx.currentPlayer).toBe('1');
+    expect(Object.keys(state.ctx.activePlayers)).toEqual(['0', '1']);
+
+    state = flow.processMove(state, makeMove('', null, '0').payload);
+
+    expect(state.ctx.phase).toBe('A');
+    expect(state.ctx.currentPlayer).toBe('1');
+    expect(Object.keys(state.ctx.activePlayers)).toEqual(['1']);
+
+    state = flow.processMove(state, makeMove('', null, '1').payload);
+
+    expect(state.ctx.currentPlayer).toBe('1');
+    expect(state.ctx.activePlayers).toBeNull();
+
+    state = flow.processMove(state, makeMove('', null, '1').payload);
+  });
+
+  test('OTHERS', () => {
+    const flow = Flow({
+      turn: { activePlayers: ActivePlayers.OTHERS },
+    });
+
+    let state = { ctx: flow.ctx(3) } as State;
+    state = flow.init(state);
+    expect(state.ctx.currentPlayer).toBe('0');
+    expect(Object.keys(state.ctx.activePlayers)).toEqual(['1', '2']);
+    expect(state.ctx).not.toHaveUndefinedProperties();
+
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('1');
+    expect(Object.keys(state.ctx.activePlayers)).toEqual(['0', '2']);
+  });
+
+  test('OTHERS_ONCE', () => {
+    const flow = Flow({
+      turn: { activePlayers: ActivePlayers.OTHERS_ONCE },
+      phases: { A: { start: true } },
+    });
+
+    let state = { ctx: flow.ctx(3) } as State;
+    state = flow.init(state);
+
+    expect(state.ctx.phase).toBe('A');
+    expect(state.ctx.currentPlayer).toBe('0');
+    expect(Object.keys(state.ctx.activePlayers)).toEqual(['1', '2']);
+    expect(state.ctx).not.toHaveUndefinedProperties();
+
+    state = flow.processEvent(state, gameEvent('endTurn'));
+
+    expect(state.ctx.phase).toBe('A');
+    expect(state.ctx.currentPlayer).toBe('1');
+    expect(Object.keys(state.ctx.activePlayers)).toEqual(['0', '2']);
+
+    state = flow.processMove(state, makeMove('', null, '0').payload);
+
+    expect(state.ctx.phase).toBe('A');
+    expect(state.ctx.currentPlayer).toBe('1');
+    expect(Object.keys(state.ctx.activePlayers)).toEqual(['2']);
+
+    state = flow.processMove(state, makeMove('', null, '2').payload);
+
+    expect(state.ctx.currentPlayer).toBe('1');
+    expect(state.ctx.activePlayers).toBeNull();
+
+    state = flow.processMove(state, makeMove('', null, '1').payload);
+  });
+
+  test('CUSTOM', () => {
+    const flow = Flow({
+      turn: { order: TurnOrder.CUSTOM(['1', '0']) },
+    });
+
+    let state = { ctx: flow.ctx(2) } as State;
+    state = flow.init(state);
+
+    expect(state.ctx.currentPlayer).toBe('1');
+    expect(state.ctx).not.toHaveUndefinedProperties();
+
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('0');
+  });
+
+  test('CUSTOM_FROM', () => {
+    const flow = Flow({
+      turn: { order: TurnOrder.CUSTOM_FROM('order') },
+    });
+
+    let state = { G: { order: ['2', '1', '0'] }, ctx: flow.ctx(3) } as State;
+    state = flow.init(state);
+
+    expect(state.ctx.currentPlayer).toBe('2');
+    expect(state.ctx).not.toHaveUndefinedProperties();
+
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('1');
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('0');
+  });
+
+  test('manual', () => {
+    const flow = Flow({
+      phases: {
+        A: {
+          start: true,
+          turn: {
+            order: {
+              first: () => 9,
+              next: () => 3,
+            },
+          },
+        },
+      },
+    });
+
+    let state = { ctx: flow.ctx(10) } as State;
+    state = flow.init(state);
+    expect(state.ctx.currentPlayer).toBe('9');
+    expect(state.ctx).not.toHaveUndefinedProperties();
+
+    state = flow.processEvent(state, gameEvent('endTurn'));
+    expect(state.ctx.currentPlayer).toBe('3');
+  });
+});
+
+test('override', () => {
+  const even = {
+    first: () => 0,
+    next: ({ ctx }) => (+ctx.currentPlayer + 2) % ctx.numPlayers,
+  };
+
+  const odd = {
+    first: () => 1,
+    next: ({ ctx }) => (+ctx.currentPlayer + 2) % ctx.numPlayers,
+  };
+
+  const flow = Flow({
+    turn: { order: even },
+    phases: { A: { start: true, next: 'B' }, B: { turn: { order: odd } } },
+  });
+
+  let state = { ctx: flow.ctx(10) } as State;
+  state = flow.init(state);
+
+  expect(state.ctx.currentPlayer).toBe('0');
+  state = flow.processEvent(state, gameEvent('endTurn'));
+  expect(state.ctx.currentPlayer).toBe('2');
+  state = flow.processEvent(state, gameEvent('endTurn'));
+  expect(state.ctx.currentPlayer).toBe('4');
+
+  state = flow.processEvent(state, gameEvent('endPhase'));
+
+  expect(state.ctx.currentPlayer).toBe('1');
+  state = flow.processEvent(state, gameEvent('endTurn'));
+  expect(state.ctx.currentPlayer).toBe('3');
+  state = flow.processEvent(state, gameEvent('endTurn'));
+  expect(state.ctx.currentPlayer).toBe('5');
+});
+
+test('playOrder', () => {
+  const game: Game = {};
+  const reducer = CreateGameReducer({ game });
+
+  let state = InitializeGame({ game, numPlayers: 3 });
+
+  state.ctx = {
+    ...state.ctx,
+    currentPlayer: '2',
+    playOrder: ['2', '0', '1'],
+  };
+
+  state = reducer(state, gameEvent('endTurn'));
+  expect(state.ctx.currentPlayer).toBe('0');
+  state = reducer(state, gameEvent('endTurn'));
+  expect(state.ctx.currentPlayer).toBe('1');
+  state = reducer(state, gameEvent('endTurn'));
+  expect(state.ctx.currentPlayer).toBe('2');
+});
+
+describe('setActivePlayers', () => {
+  const flow = Flow({});
+  const state = { ctx: flow.ctx(2) } as State;
+
+  test('basic', () => {
+    const newState = flow.processEvent(
+      state,
+      gameEvent('setActivePlayers', [{ value: { '1': Stage.NULL } }])
+    );
+    expect(newState.ctx.activePlayers).toMatchObject({ '1': Stage.NULL });
+  });
+
+  test('short form', () => {
+    const newState = flow.processEvent(
+      state,
+      gameEvent('setActivePlayers', [['1', '2']])
+    );
+    expect(newState.ctx.activePlayers).toMatchObject({
+      '1': Stage.NULL,
+      '2': Stage.NULL,
+    });
+  });
+
+  test('undefined stage leaves player inactive', () => {
+    const newState = flow.processEvent(
+      state,
+      gameEvent('setActivePlayers', [
+        {
+          value: {
+            '1': {
+              minMoves: 2,
+              maxMoves: 2,
+            },
+          },
+        },
+      ])
+    );
+    expect(newState.ctx.activePlayers).toBeNull();
+  });
+
+  test('all', () => {
+    const newState = flow.processEvent(
+      state,
+      gameEvent('setActivePlayers', [{ all: Stage.NULL }])
+    );
+    expect(newState.ctx.activePlayers).toMatchObject({
+      '0': Stage.NULL,
+      '1': Stage.NULL,
+    });
+  });
+
+  test('once', () => {
+    const game: Game = {
+      moves: {
+        B: ({ G, events }) => {
+          events.setActivePlayers({
+            value: { '0': Stage.NULL, '1': Stage.NULL },
+            minMoves: 1,
+            maxMoves: 1,
+          });
+          return G;
+        },
+        A: ({ G }) => G,
+      },
+    };
+
+    const reducer = CreateGameReducer({ game });
+
+    let state = InitializeGame({ game });
+    state = reducer(state, makeMove('B', null, '0'));
+    expect(Object.keys(state.ctx.activePlayers)).toEqual(['0', '1']);
+    state = reducer(state, makeMove('A', null, '0'));
+    expect(Object.keys(state.ctx.activePlayers)).toEqual(['1']);
+    state = reducer(state, makeMove('A', null, '1'));
+    expect(state.ctx.activePlayers).toBeNull();
+  });
+
+  test('others', () => {
+    const game: Game = {
+      moves: {
+        B: ({ G, events }) => {
+          events.setActivePlayers({
+            minMoves: 1,
+            maxMoves: 1,
+            others: Stage.NULL,
+          });
+          return G;
+        },
+        A: ({ G }) => G,
+      },
+    };
+
+    const reducer = CreateGameReducer({ game });
+
+    let state = InitializeGame({ game, numPlayers: 3 });
+
+    // on move B, control switches from player 0 to players 1 and 2
+    state = reducer(state, makeMove('B', null, '0'));
+    expect(Object.keys(state.ctx.activePlayers)).toEqual(['1', '2']);
+
+    // player 1 makes move
+    state = reducer(state, makeMove('A', null, '1'));
+    expect(Object.keys(state.ctx.activePlayers)).toEqual(['2']);
+
+    // player 2 makes move
+    state = reducer(state, makeMove('A', null, '2'));
+    expect(state.ctx.activePlayers).toBeNull();
+  });
+
+  test('set stages to Stage.NULL', () => {
+    const game: Game = {
+      moves: {
+        A: ({ G }) => G,
+        B: ({ G, events }) => {
+          events.setActivePlayers({
+            minMoves: 1,
+            maxMoves: 1,
+            currentPlayer: 'start',
+          });
+          return G;
+        },
+      },
+      turn: {
+        activePlayers: {
+          currentPlayer: {
+            stage: 'start',
+          },
+          others: Stage.NULL,
+        },
+        stages: {
+          start: {
+            moves: {
+              S: ({ G, events }) => {
+                events.setStage(Stage.NULL);
+                return G;
+              },
+            },
+          },
+        },
+      },
+    };
+    const reducer = CreateGameReducer({ game });
+    let state = InitializeGame({ game, numPlayers: 3 });
+
+    expect(state.ctx.currentPlayer).toBe('0');
+    expect(Object.keys(state.ctx.activePlayers)).toEqual(['0', '1', '2']);
+    expect(state.ctx.activePlayers['0']).toEqual('start');
+    expect(state.ctx.activePlayers['1']).toEqual(Stage.NULL);
+    expect(state.ctx.activePlayers['2']).toEqual(Stage.NULL);
+
+    state = reducer(state, makeMove('S', null, '0'));
+    expect(Object.keys(state.ctx.activePlayers)).toEqual(['0', '1', '2']);
+    expect(state.ctx.activePlayers['0']).toEqual(Stage.NULL);
+
+    state = reducer(state, makeMove('B', null, '0'));
+    expect(Object.keys(state.ctx.activePlayers)).toEqual(['0']);
+    expect(state.ctx.activePlayers['0']).toEqual('start');
+  });
+
+  describe('reset behavior', () => {
+    test('start of turn', () => {
+      const game: Game = {
+        moves: {
+          A: () => {},
+        },
+
+        turn: {
+          activePlayers: { currentPlayer: 'stage', minMoves: 1, maxMoves: 1 },
+        },
+      };
+
+      const reducer = CreateGameReducer({ game });
+      let state = InitializeGame({ game });
+
+      expect(state.ctx).toMatchObject({
+        activePlayers: { '0': 'stage' },
+        _prevActivePlayers: [],
+      });
+
+      state = reducer(state, makeMove('A', null, '0'));
+
+      expect(state.ctx).toMatchObject({
+        activePlayers: null,
+        _prevActivePlayers: [],
+      });
+    });
+
+    describe('revert', () => {
+      test('resets to previous', () => {
+        const game: Game = {
+          moves: {
+            A: ({ events }) => {
+              events.setActivePlayers({
+                currentPlayer: 'stage2',
+                minMoves: 1,
+                maxMoves: 1,
+                revert: true,
+              });
+            },
+            B: () => {},
+          },
+
+          turn: {
+            activePlayers: { currentPlayer: 'stage1' },
+          },
+        };
+
+        const reducer = CreateGameReducer({ game });
+        let state = InitializeGame({ game });
+
+        expect(state.ctx).toMatchObject({
+          activePlayers: { '0': 'stage1' },
+          _prevActivePlayers: [],
+        });
+
+        state = reducer(state, makeMove('A', null, '0'));
+
+        expect(state.ctx).toMatchObject({
+          activePlayers: { '0': 'stage2' },
+          _prevActivePlayers: [
+            {
+              activePlayers: { '0': 'stage1' },
+              _activePlayersMinMoves: null,
+              _activePlayersMaxMoves: null,
+              _activePlayersNumMoves: { '0': 1 },
+            },
+          ],
+        });
+
+        state = reducer(state, makeMove('B', null, '0'));
+
+        expect(state.ctx).toMatchObject({
+          activePlayers: { '0': 'stage1' },
+          _prevActivePlayers: [],
+        });
+      });
+
+      test('restores move limits and counts', () => {
+        const game: Game = {
+          moves: {
+            A: ({ events }) => {
+              events.setActivePlayers({
+                currentPlayer: 'stage2',
+                minMoves: 1,
+                maxMoves: 1,
+                revert: true,
+              });
+            },
+            B: () => {},
+          },
+
+          turn: {
+            activePlayers: {
+              currentPlayer: 'stage1',
+              minMoves: 2,
+              maxMoves: 3,
+            },
+          },
+        };
+
+        const reducer = CreateGameReducer({ game });
+        let state = InitializeGame({ game });
+
+        expect(state.ctx).toMatchObject({
+          activePlayers: { '0': 'stage1' },
+          _prevActivePlayers: [],
+          _activePlayersMinMoves: { '0': 2 },
+          _activePlayersMaxMoves: { '0': 3 },
+          _activePlayersNumMoves: {
+            '0': 0,
+          },
+        });
+
+        state = reducer(state, makeMove('B', null, '0'));
+
+        expect(state.ctx).toMatchObject({
+          activePlayers: { '0': 'stage1' },
+          _prevActivePlayers: [],
+          _activePlayersMinMoves: { '0': 2 },
+          _activePlayersMaxMoves: { '0': 3 },
+          _activePlayersNumMoves: {
+            '0': 1,
+          },
+        });
+
+        state = reducer(state, makeMove('A', null, '0'));
+
+        expect(state.ctx).toMatchObject({
+          activePlayers: { '0': 'stage2' },
+          _prevActivePlayers: [
+            {
+              activePlayers: { '0': 'stage1' },
+              _activePlayersNumMoves: { '0': 2 },
+              _activePlayersMinMoves: { '0': 2 },
+              _activePlayersMaxMoves: { '0': 3 },
+            },
+          ],
+          _activePlayersMinMoves: { '0': 1 },
+          _activePlayersMaxMoves: { '0': 1 },
+          _activePlayersNumMoves: {
+            '0': 0,
+          },
+        });
+
+        state = reducer(state, makeMove('B', null, '0'));
+
+        expect(state.ctx).toMatchObject({
+          activePlayers: { '0': 'stage1' },
+          _prevActivePlayers: [],
+          _activePlayersMinMoves: { '0': 2 },
+          _activePlayersMaxMoves: { '0': 3 },
+          _activePlayersNumMoves: {
+            '0': 2,
+          },
+        });
+      });
+    });
+
+    test('set to next', () => {
+      const game: Game = {
+        moves: {
+          A: () => {},
+        },
+
+        turn: {
+          activePlayers: {
+            currentPlayer: 'stage1',
+            minMoves: 1,
+            maxMoves: 1,
+            next: {
+              currentPlayer: 'stage2',
+              minMoves: 1,
+              maxMoves: 1,
+              next: {
+                currentPlayer: 'stage3',
+              },
+            },
+          },
+        },
+      };
+
+      const reducer = CreateGameReducer({ game });
+      let state = InitializeGame({ game });
+
+      expect(state.ctx).toMatchObject({
+        activePlayers: { '0': 'stage1' },
+        _prevActivePlayers: [],
+        _nextActivePlayers: {
+          currentPlayer: 'stage2',
+          minMoves: 1,
+          maxMoves: 1,
+          next: {
+            currentPlayer: 'stage3',
+          },
+        },
+      });
+
+      state = reducer(state, makeMove('A', null, '0'));
+
+      expect(state.ctx).toMatchObject({
+        activePlayers: { '0': 'stage2' },
+        _prevActivePlayers: [],
+        _nextActivePlayers: {
+          currentPlayer: 'stage3',
+        },
+      });
+
+      state = reducer(state, makeMove('A', null, '0'));
+
+      expect(state.ctx).toMatchObject({
+        activePlayers: { '0': 'stage3' },
+        _prevActivePlayers: [],
+        _nextActivePlayers: null,
+      });
+    });
+  });
+
+  describe('move limits', () => {
+    test('shorthand syntax', () => {
+      const game: Game = {
+        turn: {
+          activePlayers: {
+            all: 'play',
+            minMoves: 1,
+            maxMoves: 3,
+          },
+          stages: {
+            play: { moves: { A: () => {} } },
+          },
+        },
+      };
+
+      const reducer = CreateGameReducer({ game });
+      let state = InitializeGame({ game, numPlayers: 3 });
+
+      expect(state.ctx._activePlayersMinMoves).toEqual({
+        '0': 1,
+        '1': 1,
+        '2': 1,
+      });
+
+      expect(state.ctx._activePlayersMaxMoves).toEqual({
+        '0': 3,
+        '1': 3,
+        '2': 3,
+      });
+
+      expect(state.ctx._activePlayersNumMoves).toEqual({
+        '0': 0,
+        '1': 0,
+        '2': 0,
+      });
+
+      state = reducer(state, makeMove('A', null, '0'));
+      state = reducer(state, makeMove('A', null, '1'));
+      state = reducer(state, makeMove('A', null, '1'));
+      state = reducer(state, makeMove('A', null, '2'));
+
+      expect(state.ctx._activePlayersNumMoves).toEqual({
+        '0': 1,
+        '1': 2,
+        '2': 1,
+      });
+
+      state = reducer(state, makeMove('A', null, '1'));
+
+      expect(state.ctx.activePlayers).toEqual({
+        '0': 'play',
+        '2': 'play',
+      });
+    });
+
+    test('long-form syntax', () => {
+      const game: Game = {
+        turn: {
+          activePlayers: {
+            currentPlayer: { stage: 'play', minMoves: 1, maxMoves: 2 },
+            others: { stage: 'play', maxMoves: 1 },
+          },
+          stages: {
+            play: { moves: { A: () => {} } },
+          },
+        },
+      };
+
+      const reducer = CreateGameReducer({ game });
+      let state = InitializeGame({ game, numPlayers: 3 });
+
+      expect(state.ctx._activePlayersMinMoves).toStrictEqual({ '0': 1 });
+
+      expect(state.ctx._activePlayersMaxMoves).toEqual({
+        '0': 2,
+        '1': 1,
+        '2': 1,
+      });
+
+      expect(state.ctx._activePlayersNumMoves).toEqual({
+        '0': 0,
+        '1': 0,
+        '2': 0,
+      });
+
+      state = reducer(state, makeMove('A', null, '0'));
+      state = reducer(state, makeMove('A', null, '1'));
+      state = reducer(state, makeMove('A', null, '2'));
+
+      expect(state.ctx._activePlayersNumMoves).toEqual({
+        '0': 1,
+        '1': 1,
+        '2': 1,
+      });
+
+      expect(state.ctx.activePlayers).toEqual({ '0': 'play' });
+
+      state = reducer(state, makeMove('A', null, '0'));
+
+      expect(state.ctx.activePlayers).toBeNull();
+    });
+
+    test('player-specific limit overrides move limit args', () => {
+      const game: Game = {
+        turn: {
+          activePlayers: {
+            all: { stage: 'play', minMoves: 2, maxMoves: 2 },
+            minMoves: 1,
+            maxMoves: 1,
+          },
+        },
+      };
+
+      const state = InitializeGame({ game, numPlayers: 2 });
+
+      expect(state.ctx._activePlayersMinMoves).toEqual({
+        '0': 2,
+        '1': 2,
+      });
+
+      expect(state.ctx._activePlayersMaxMoves).toEqual({
+        '0': 2,
+        '1': 2,
+      });
+    });
+
+    test('value syntax', () => {
+      const game: Game = {
+        turn: {
+          activePlayers: {
+            value: {
+              '0': { stage: 'play', maxMoves: 1 },
+              '1': { stage: 'play', minMoves: 1, maxMoves: 2 },
+              '2': { stage: 'play', minMoves: 2, maxMoves: 3 },
+            },
+          },
+          stages: {
+            play: { moves: { A: () => {} } },
+          },
+        },
+      };
+
+      const reducer = CreateGameReducer({ game });
+      let state = InitializeGame({ game, numPlayers: 3 });
+
+      expect(state.ctx._activePlayersMinMoves).toStrictEqual({
+        '1': 1,
+        '2': 2,
+      });
+
+      expect(state.ctx._activePlayersMaxMoves).toEqual({
+        '0': 1,
+        '1': 2,
+        '2': 3,
+      });
+
+      state = reducer(state, makeMove('A', null, '0'));
+      state = reducer(state, makeMove('A', null, '1'));
+      state = reducer(state, makeMove('A', null, '2'));
+
+      expect(state.ctx.activePlayers).toEqual({ '1': 'play', '2': 'play' });
+
+      state = reducer(state, makeMove('A', null, '1'));
+      state = reducer(state, makeMove('A', null, '2'));
+
+      expect(state.ctx.activePlayers).toEqual({ '2': 'play' });
+
+      state = reducer(state, makeMove('A', null, '2'));
+      expect(state.ctx.activePlayers).toBeNull();
+    });
+
+    test('move counts reset on turn end', () => {
+      const game: Game = {
+        turn: {
+          activePlayers: {
+            all: 'play',
+          },
+          stages: {
+            play: { moves: { A: () => {} } },
+          },
+        },
+      };
+
+      const reducer = CreateGameReducer({ game });
+      let state = InitializeGame({ game, numPlayers: 3 });
+
+      state = reducer(state, makeMove('A', null, '0'));
+      state = reducer(state, makeMove('A', null, '1'));
+
+      expect(state.ctx._activePlayersNumMoves).toEqual({
+        '0': 1,
+        '1': 1,
+        '2': 0,
+      });
+
+      state = reducer(state, gameEvent('endTurn'));
+
+      expect(state.ctx._activePlayersNumMoves).toEqual({
+        '0': 0,
+        '1': 0,
+        '2': 0,
+      });
+    });
+  });
+
+  describe('militia', () => {
+    let state;
+    let reducer;
+    beforeAll(() => {
+      const game: Game = {
+        moves: {
+          militia: ({ events }) => {
+            events.setActivePlayers({
+              others: 'discard',
+              minMoves: 1,
+              maxMoves: 1,
+              revert: true,
+            });
+          },
+        },
+
+        turn: {
+          stages: {
+            discard: {
+              moves: {
+                discard: ({ G }) => G,
+              },
+            },
+          },
+        },
+      };
+
+      reducer = CreateGameReducer({ game });
+      state = InitializeGame({ game, numPlayers: 3 });
+    });
+
+    beforeEach(() => {
+      (error as jest.Mock).mockClear();
+    });
+
+    test('sanity', () => {
+      expect(state.ctx.activePlayers).toEqual(null);
+    });
+
+    test('player 1 cannot play the militia card', () => {
+      state = reducer(state, makeMove('militia', undefined, '1'));
+      expect(error).toHaveBeenCalledWith('disallowed move: militia');
+    });
+
+    test('player 2 cannot play the militia card', () => {
+      state = reducer(state, makeMove('militia', undefined, '2'));
+      expect(error).toHaveBeenCalledWith('disallowed move: militia');
+    });
+
+    test('player 0 cannot discard', () => {
+      state = reducer(state, makeMove('discard', undefined, '0'));
+      expect(error).toHaveBeenCalledWith('disallowed move: discard');
+    });
+
+    test('player 1 cannot discard', () => {
+      state = reducer(state, makeMove('discard', undefined, '1'));
+      expect(error).toHaveBeenCalledWith('disallowed move: discard');
+    });
+
+    test('player 2 cannot discard', () => {
+      state = reducer(state, makeMove('discard', undefined, '2'));
+      expect(error).toHaveBeenCalledWith('disallowed move: discard');
+    });
+
+    test('player 0 plays militia', () => {
+      state = reducer(state, makeMove('militia', undefined, '0'));
+      expect(state.ctx.activePlayers).toEqual({
+        '1': 'discard',
+        '2': 'discard',
+      });
+    });
+
+    test('player 0 cannot play militia again', () => {
+      state = reducer(state, makeMove('militia', undefined, '0'));
+      expect(error).toHaveBeenCalledWith('disallowed move: militia');
+    });
+
+    test('player 0 still cannot discard', () => {
+      state = reducer(state, makeMove('discard', undefined, '0'));
+      expect(error).toHaveBeenCalledWith('disallowed move: discard');
+    });
+
+    test('everyone else discards', () => {
+      state = reducer(state, makeMove('discard', undefined, '1'));
+      expect(state.ctx.activePlayers).toEqual({ '2': 'discard' });
+      state = reducer(state, makeMove('discard', undefined, '2'));
+    });
+
+    test('activePlayers is restored to previous state', () => {
+      expect(state.ctx.activePlayers).toEqual(null);
+    });
+  });
+});
+
+describe('UpdateTurnOrderState', () => {
+  const G = {};
+  const ctx = {
+    currentPlayer: '0',
+    playOrder: ['0', '1', '2'],
+    playOrderPos: 0,
+  };
+  const turn = { order: TurnOrder.DEFAULT };
+
+  test('without next player', () => {
+    const { ctx: t } = UpdateTurnOrderState(
+      { G, ctx } as State,
+      ctx.currentPlayer,
+      turn
+    );
+    expect(t).toMatchObject({ currentPlayer: '1' });
+  });
+
+  test('with next player', () => {
+    const { ctx: t } = UpdateTurnOrderState(
+      { G, ctx } as State,
+      ctx.currentPlayer,
+      turn,
+      {
+        next: '2',
+      }
+    );
+    expect(t).toMatchObject({ currentPlayer: '2' });
+  });
+
+  test('errors if turn.order.next doesn’t return a number', () => {
+    UpdateTurnOrderState({ G, ctx } as State, ctx.currentPlayer, {
+      order: {
+        first: () => 0,
+        next: () => '2' as unknown as number,
+      },
+    });
+    expect(error).toHaveBeenCalledWith(
+      `invalid value returned by turn.order.next — expected number or undefined got string “2”.`
+    );
+  });
+});
+
+describe('Random API is available', () => {
+  let first;
+  let next;
+
+  const turn = {
+    order: {
+      first: ({ random }) => {
+        if (random !== undefined) {
+          first = true;
+        }
+        return 0;
+      },
+
+      next: ({ random }) => {
+        if (random !== undefined) {
+          next = true;
+        }
+        return 0;
+      },
+    },
+  };
+
+  const game: Game = { turn };
+
+  beforeEach(() => {
+    first = next = false;
+  });
+
+  test('init', () => {
+    Client({ game });
+    expect(first).toBe(true);
+  });
+
+  test('end turn', () => {
+    const client = Client({ game });
+    expect(next).toBe(false);
+    client.events.endTurn();
+    expect(next).toBe(true);
+  });
+});