retire the string constant 'any'

This was an old hack that enabled any player to play during a turn. This has since been subsumed by the actionPlayers mechanism, which can now be used to allow any player to play (by setting it to an array with all players in it).

Author: darthfiddler

src/client/client.js

@@ -182,7 +182,7 @@ class _ClientImpl {
     // but we also strip them here so that game developers
     // can see their effects while prototyping.
     let playerID = this.playerID;
-    if (!this.multiplayer && !playerID && state.ctx.currentPlayer != 'any') {
+    if (!this.multiplayer && !playerID) {
       playerID = state.ctx.currentPlayer;
     }
     const G = this.game.playerView(state.G, state.ctx, playerID);

src/client/react-native.test.js

@@ -68,8 +68,6 @@ test('board props', () => {
     board: TestBoard,
     multiplayer: true,
   });
-  board = Enzyme.mount(<Board />).find(TestBoard);
-  expect(board.props().isActive).toBe(true);
   board = Enzyme.mount(<Board playerID={'0'} />).find(TestBoard);
   expect(board.props().isActive).toBe(true);
   board = Enzyme.mount(<Board playerID={'1'} />).find(TestBoard);

src/client/react.test.js

@@ -69,8 +69,6 @@ test('board props', () => {
     board: TestBoard,
     multiplayer: true,
   });
-  board = Enzyme.mount(<Board />).find(TestBoard);
-  expect(board.props().isActive).toBe(true);
   board = Enzyme.mount(<Board playerID={'0'} />).find(TestBoard);
   expect(board.props().isActive).toBe(true);
   board = Enzyme.mount(<Board playerID={'1'} />).find(TestBoard);

src/core/flow.js

@@ -106,7 +106,7 @@ export function Flow({
 
     canPlayerMakeMove: (G, ctx, playerID) => {
       const actionPlayers = ctx.actionPlayers || [];
-      return actionPlayers.includes(playerID) || actionPlayers.includes('any');
+      return actionPlayers.includes(playerID);
     },
 
     canMakeMove: (G, ctx, moveName) => {

src/core/flow.test.js

@@ -478,26 +478,20 @@ test('canMakeMove', () => {
 
 test('canPlayerMakeMove', () => {
   // default behaviour
-  const pid = 0;
+  const pid = '0';
 
   let flow = Flow({});
   expect(flow.canPlayerMakeMove({}, {}, pid)).toBe(false);
   // NOTE: currentPlayer is not allowed to make a move by default.
-  // his playerID must be included in the actionPlayers array.
-  expect(flow.canPlayerMakeMove({}, { currentPlayer: 0 }, pid)).toBe(false);
-  expect(flow.canPlayerMakeMove({}, { actionPlayers: ['any'] }, pid)).toBe(
-    true
-  );
-  expect(flow.canPlayerMakeMove({}, { actionPlayers: [0] }, pid)).toBe(true);
-  expect(flow.canPlayerMakeMove({}, { actionPlayers: [1, 2, 3] }, pid)).toBe(
-    false
-  );
+  // Their playerID must be included in the actionPlayers array.
+  expect(flow.canPlayerMakeMove({}, { actionPlayers: ['1'] }, pid)).toBe(false);
+  expect(flow.canPlayerMakeMove({}, { actionPlayers: ['0'] }, pid)).toBe(true);
 
   // no one can make a move
   flow = Flow({ canPlayerMakeMove: () => false });
   expect(flow.canPlayerMakeMove({}, {}, pid)).toBe(false);
-  expect(flow.canPlayerMakeMove({}, { currentPlayer: 0 }, pid)).toBe(false);
-  expect(flow.canPlayerMakeMove({}, {}, 'any')).toBe(false);
+  expect(flow.canPlayerMakeMove({}, { actionPlayers: [] }, pid)).toBe(false);
+  expect(flow.canPlayerMakeMove({}, {}, '5')).toBe(false);
 });
 
 test('endGame', () => {
@@ -540,13 +534,6 @@ test('endTurn / endPhase args', () => {
     expect(t.ctx.phase).toBe('C');
   }
 
-  {
-    let t = state;
-    t = flow.processGameEvent(t, gameEvent('endTurn', 'any'));
-    expect(t.ctx.playOrderPos).toBe(undefined);
-    expect(t.ctx.currentPlayer).toBe('any');
-  }
-
   {
     let t = state;
     t = flow.processGameEvent(t, gameEvent('endTurn', '0'));

src/core/turn-order.js

@@ -18,8 +18,7 @@ export const Pass = (G, ctx) => {
   if (G.passOrder !== undefined) {
     passOrder = G.passOrder;
   }
-  const playerID =
-    ctx.currentPlayer === 'any' ? ctx.playerID : ctx.currentPlayer;
+  const playerID = ctx.playerID;
   passOrder.push(playerID);
   G = { ...G, passOrder };
   if (passOrder.length >= ctx.numPlayers) {
@@ -53,9 +52,6 @@ export function ChangeActionPlayers(state, actionPlayers) {
  * @param {number} playOrderPos - An index into the above.
  */
 function getCurrentPlayer(playOrder, playOrderPos) {
-  if (playOrderPos === undefined) {
-    return 'any';
-  }
   return playOrder[playOrderPos] + '';
 }
 
@@ -66,9 +62,25 @@ function getCurrentPlayer(playOrder, playOrderPos) {
  * @param {object} turnOrder - A turn order object for this phase.
  */
 export function InitTurnOrderState(G, ctx, turnOrder) {
-  const playOrderPos = turnOrder.first(G, ctx);
+  let playOrderPos;
+  let actionPlayers;
+
+  const t = turnOrder.first(G, ctx);
+
+  if (t.playOrderPos !== undefined) {
+    playOrderPos = t.playOrderPos;
+  } else {
+    playOrderPos = t;
+  }
+
   const currentPlayer = getCurrentPlayer(ctx.playOrder, playOrderPos);
-  const actionPlayers = [currentPlayer];
+
+  if (t.actionPlayers !== undefined) {
+    actionPlayers = t.actionPlayers;
+  } else {
+    actionPlayers = [currentPlayer];
+  }
+
   return { ...ctx, currentPlayer, playOrderPos, actionPlayers };
 }
 
@@ -83,19 +95,29 @@ export function InitTurnOrderState(G, ctx, turnOrder) {
 export function UpdateTurnOrderState(G, ctx, turnOrder, nextPlayer) {
   let playOrderPos = ctx.playOrderPos;
   let currentPlayer = ctx.currentPlayer;
+  let actionPlayers;
 
-  if (nextPlayer === 'any') {
-    playOrderPos = undefined;
-    currentPlayer = nextPlayer;
-  } else if (ctx.playOrder.includes(nextPlayer)) {
+  if (ctx.playOrder.includes(nextPlayer)) {
     playOrderPos = ctx.playOrder.indexOf(nextPlayer);
     currentPlayer = nextPlayer;
+    actionPlayers = [currentPlayer];
   } else {
-    playOrderPos = turnOrder.next(G, ctx);
+    const t = turnOrder.next(G, ctx);
+
+    if (t && t.playOrderPos !== undefined) {
+      playOrderPos = t.playOrderPos;
+    } else {
+      playOrderPos = t;
+    }
+
     currentPlayer = getCurrentPlayer(ctx.playOrder, playOrderPos);
-  }
 
-  const actionPlayers = [currentPlayer];
+    if (t && t.actionPlayers !== undefined) {
+      actionPlayers = t.actionPlayers;
+    } else {
+      actionPlayers = [currentPlayer];
+    }
+  }
 
   return {
     ...ctx,
@@ -121,6 +143,10 @@ export const TurnOrder = {
    * Each object defines the first player when the phase / game
    * begins, and also a function `next` to determine who the
    * next player is when the turn ends.
+   *
+   * first / next can also return an object of type
+   * { playOrderPos, actionPlayers }
+   * in which case they can also set actionPlayers simultaneously.
    */
 
   /**
@@ -136,11 +162,19 @@ export const TurnOrder = {
   /**
    * ANY
    *
-   * Any player can play and there isn't a currentPlayer really.
+   * currentPlayer switches around in round-robin fashion, but any player can play on each turn.
    */
   ANY: {
-    first: () => undefined,
-    next: () => undefined,
+    first: (G, ctx) => {
+      return {
+        actionPlayers: [...ctx.playOrder],
+        playOrderPos: ctx.playOrderPos,
+      };
+    },
+    next: (G, ctx) => {
+      const playOrderPos = (ctx.playOrderPos + 1) % ctx.playOrder.length;
+      return { actionPlayers: [...ctx.playOrder], playOrderPos };
+    },
   },
 
   /**

src/core/turn-order.test.js

@@ -7,7 +7,7 @@
  */
 
 import { FlowWithPhases } from './flow';
-import { TurnOrder, Pass } from './turn-order';
+import { UpdateTurnOrderState, TurnOrder, Pass } from './turn-order';
 import Game from './game';
 import { makeMove, gameEvent } from './action-creators';
 import { CreateGameReducer } from './reducer';
@@ -27,20 +27,6 @@ describe('turnOrder', () => {
     expect(state.ctx.actionPlayers).toEqual(['1']);
   });
 
-  test('any', () => {
-    const flow = FlowWithPhases({
-      phases: [{ name: 'A', turnOrder: TurnOrder.ANY }],
-    });
-
-    let state = { ctx: flow.ctx(10) };
-    state = flow.init(state);
-    expect(state.ctx.currentPlayer).toBe('any');
-    expect(state.ctx.actionPlayers).toEqual(['any']);
-    state = flow.processGameEvent(state, gameEvent('endTurn'));
-    expect(state.ctx.currentPlayer).toBe('any');
-    expect(state.ctx.actionPlayers).toEqual(['any']);
-  });
-
   test('custom', () => {
     const flow = FlowWithPhases({
       phases: [{ name: 'A', turnOrder: { first: () => 9, next: () => 3 } }],
@@ -68,7 +54,7 @@ test('passing', () => {
   let state = reducer(undefined, { type: 'init' });
 
   expect(state.ctx.currentPlayer).toBe('0');
-  state = reducer(state, makeMove('pass'));
+  state = reducer(state, makeMove('pass', null, '0'));
   state = reducer(state, gameEvent('endTurn'));
   expect(state.G.allPassed).toBe(undefined);
   expect(state.G.passOrder).toEqual(['0']);
@@ -83,7 +69,7 @@ test('passing', () => {
   expect(state.G.allPassed).toBe(undefined);
 
   expect(state.ctx.currentPlayer).toBe('1');
-  state = reducer(state, makeMove('pass'));
+  state = reducer(state, makeMove('pass', null, '1'));
   state = reducer(state, gameEvent('endTurn'));
   expect(state.G.allPassed).toBe(undefined);
   expect(state.G.passOrder).toEqual(['0', '1']);
@@ -93,7 +79,7 @@ test('passing', () => {
   expect(state.G.allPassed).toBe(undefined);
 
   expect(state.ctx.currentPlayer).toBe('2');
-  state = reducer(state, makeMove('pass'));
+  state = reducer(state, makeMove('pass', null, '2'));
   expect(state.G.allPassed).toBe(true);
   expect(state.ctx.currentPlayer).toBe('2');
   state = reducer(state, gameEvent('endTurn'));
@@ -114,7 +100,7 @@ test('end game after everyone passes', () => {
   const reducer = CreateGameReducer({ game, numPlayers: 3 });
 
   let state = reducer(undefined, { type: 'init' });
-  expect(state.ctx.currentPlayer).toBe('any');
+  expect(state.ctx.actionPlayers).toEqual(['0', '1', '2']);
 
   // Passes can be make in any order with TurnOrder.ANY.
 
@@ -250,3 +236,31 @@ describe('change action players', () => {
     expect(state.G).toMatchObject({});
   });
 });
+
+describe('UpdateTurnOrderState', () => {
+  const G = {};
+  const ctx = {
+    currentPlayer: '0',
+    playOrder: ['0', '1', '2'],
+    playOrderPos: 0,
+    actionPlayers: ['0'],
+  };
+
+  test('without nextPlayer', () => {
+    const t = UpdateTurnOrderState(G, ctx, TurnOrder.DEFAULT);
+    expect(t).toMatchObject({ currentPlayer: '1' });
+  });
+
+  test('with nextPlayer', () => {
+    const t = UpdateTurnOrderState(G, ctx, TurnOrder.DEFAULT, '2');
+    expect(t).toMatchObject({ currentPlayer: '2' });
+  });
+
+  test('with actionPlayers', () => {
+    const t = UpdateTurnOrderState(G, ctx, TurnOrder.ANY);
+    expect(t).toMatchObject({
+      currentPlayer: '1',
+      actionPlayers: ['0', '1', '2'],
+    });
+  });
+});