@mnbroatch/boardgame.io 0.0.1

package/src/core/game-methods.ts

@@ -0,0 +1,9 @@
+export enum GameMethod {
+  MOVE = 'MOVE',
+  GAME_ON_END = 'GAME_ON_END',
+  PHASE_ON_BEGIN = 'PHASE_ON_BEGIN',
+  PHASE_ON_END = 'PHASE_ON_END',
+  TURN_ON_BEGIN = 'TURN_ON_BEGIN',
+  TURN_ON_MOVE = 'TURN_ON_MOVE',
+  TURN_ON_END = 'TURN_ON_END',
+}

package/src/core/game.test.ts

@@ -0,0 +1,286 @@
+/*
+ * Copyright 2018 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 { ProcessGameConfig } from './game';
+import { Client } from '../client/client';
+import { error } from '../core/logger';
+import { InitializeGame } from './initialize';
+import type { Game } from '../types';
+
+jest.mock('../core/logger', () => ({
+  info: jest.fn(),
+  error: jest.fn(),
+}));
+
+describe('basic', () => {
+  let game;
+  beforeAll(() => {
+    game = ProcessGameConfig({
+      moves: {
+        A: ({ G }) => G,
+        B: () => null,
+        C: {
+          move: () => 'C',
+        },
+      },
+
+      phases: {
+        PA: {
+          moves: {
+            A: () => 'PA.A',
+          },
+        },
+      },
+    });
+  });
+
+  test('sanity', () => {
+    expect(game.moveNames).toEqual(['A', 'B', 'C']);
+    expect(typeof game.processMove).toEqual('function');
+  });
+
+  test('processMove', () => {
+    const G = { test: true };
+    const ctx = { phase: '' };
+    const state = { G, ctx, plugins: {} };
+
+    expect(game.processMove(state, { type: 'A' })).toEqual(G);
+    expect(game.processMove(state, { type: 'D' })).toEqual(G);
+    expect(game.processMove(state, { type: 'B' })).toEqual(null);
+
+    state.ctx.phase = 'PA';
+    expect(game.processMove(state, { type: 'A' })).toEqual('PA.A');
+  });
+
+  test('long-form move syntax', () => {
+    expect(
+      game.processMove({ ctx: { phase: '' }, plugins: {} }, { type: 'C' })
+    ).toEqual('C');
+  });
+});
+
+// Following turn order is often used in worker placement games like Agricola and Viticulture.
+test('rounds with starting player token', () => {
+  const game: Game = {
+    setup: () => ({ startingPlayerToken: 0 }),
+
+    moves: {
+      takeStartingPlayerToken: ({ G, ctx }) => {
+        G.startingPlayerToken = ctx.currentPlayer;
+      },
+    },
+
+    phases: {
+      main: {
+        start: true,
+        turn: {
+          order: {
+            first: ({ G }) => G.startingPlayerToken,
+            next: ({ ctx }) => (+ctx.playOrderPos + 1) % ctx.playOrder.length,
+          },
+        },
+      },
+    },
+  };
+
+  const client = Client({ game, numPlayers: 4 });
+
+  expect(client.getState().ctx.currentPlayer).toBe('0');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('1');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('2');
+
+  client.moves.takeStartingPlayerToken();
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('3');
+
+  client.events.endTurn();
+  client.events.setPhase('main');
+  expect(client.getState().ctx.currentPlayer).toBe('2');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('3');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('0');
+});
+
+// The following pattern is used in Catan, Twilight Imperium, and (sort of) Powergrid.
+test('serpentine setup phases', () => {
+  const game: Game = {
+    phases: {
+      'first setup round': {
+        start: true,
+        turn: {
+          order: {
+            first: () => 0,
+            next: ({ ctx }) => (+ctx.playOrderPos + 1) % ctx.playOrder.length,
+          },
+        },
+        next: 'second setup round',
+      },
+      'second setup round': {
+        turn: {
+          order: {
+            first: ({ ctx }) => ctx.playOrder.length - 1,
+            next: ({ ctx }) => (+ctx.playOrderPos - 1) % ctx.playOrder.length,
+          },
+        },
+        next: 'main phase',
+      },
+      'main phase': {
+        turn: {
+          order: {
+            first: () => 0,
+            next: ({ ctx }) => (+ctx.playOrderPos + 1) % ctx.playOrder.length,
+          },
+        },
+      },
+    },
+  };
+
+  const numPlayers = 4;
+  const client = Client({ game, numPlayers });
+
+  expect(client.getState().ctx.currentPlayer).toBe('0');
+  expect(client.getState().ctx.phase).toBe('first setup round');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('1');
+  expect(client.getState().ctx.phase).toBe('first setup round');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('2');
+  expect(client.getState().ctx.phase).toBe('first setup round');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('3');
+  expect(client.getState().ctx.phase).toBe('first setup round');
+
+  client.events.endTurn();
+  client.events.endPhase();
+  expect(client.getState().ctx.currentPlayer).toBe('3');
+  expect(client.getState().ctx.phase).toBe('second setup round');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('2');
+  expect(client.getState().ctx.phase).toBe('second setup round');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('1');
+  expect(client.getState().ctx.phase).toBe('second setup round');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('0');
+  expect(client.getState().ctx.phase).toBe('second setup round');
+
+  client.events.endTurn();
+  client.events.endPhase();
+  expect(client.getState().ctx.currentPlayer).toBe('0');
+  expect(client.getState().ctx.phase).toBe('main phase');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('1');
+  expect(client.getState().ctx.phase).toBe('main phase');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('2');
+  expect(client.getState().ctx.phase).toBe('main phase');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('3');
+  expect(client.getState().ctx.phase).toBe('main phase');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('0');
+  expect(client.getState().ctx.phase).toBe('main phase');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('1');
+  expect(client.getState().ctx.phase).toBe('main phase');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('2');
+  expect(client.getState().ctx.phase).toBe('main phase');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('3');
+  expect(client.getState().ctx.phase).toBe('main phase');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('0');
+  expect(client.getState().ctx.phase).toBe('main phase');
+
+  client.events.endTurn();
+  expect(client.getState().ctx.currentPlayer).toBe('1');
+  expect(client.getState().ctx.phase).toBe('main phase');
+});
+
+describe('config errors', () => {
+  test('game name with spaces', () => {
+    const game = () => {
+      ProcessGameConfig({ name: 'tic tac toe' });
+    };
+    expect(game).toThrow();
+  });
+
+  test('plugin name with spaces', () => {
+    const plugins = [
+      {
+        name: 'my cool plugin',
+        api: () => {},
+      },
+    ];
+    const game = () => {
+      ProcessGameConfig({ plugins });
+    };
+    expect(game).toThrow();
+  });
+
+  test('plugin name missing', () => {
+    const plugins = [
+      {
+        api: () => {},
+      },
+    ];
+    const game = () => {
+      ProcessGameConfig({ plugins } as unknown as Game);
+    };
+    expect(game).toThrow();
+  });
+
+  test('invalid move object', () => {
+    const game = ProcessGameConfig({ moves: { A: 1 } } as unknown as Game);
+    const state = InitializeGame({ game });
+    game.processMove(state, { type: 'A', args: null, playerID: '0' });
+    expect(error).toBeCalledWith(
+      expect.stringContaining('invalid move object')
+    );
+  });
+});
+
+describe('disableUndo', () => {
+  test('set disableUndo to false by default', () => {
+    const game = ProcessGameConfig({
+      moves: {},
+    });
+    expect(game.disableUndo).toBeFalsy();
+  });
+
+  test('set disableUndo to true', () => {
+    const game = ProcessGameConfig({
+      moves: {},
+      disableUndo: true,
+    });
+
+    expect(game.disableUndo).toBeTruthy();
+  });
+});

package/src/core/game.ts

@@ -0,0 +1,114 @@
+/*
+ * 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 * as plugins from '../plugins/main';
+import { Flow } from './flow';
+import type { INVALID_MOVE } from './constants';
+import type { ActionPayload, Game, Move, LongFormMove, State } from '../types';
+import * as logging from './logger';
+import { GameMethod } from './game-methods';
+
+type ProcessedGame = Game & {
+  flow: ReturnType<typeof Flow>;
+  moveNames: string[];
+  pluginNames: string[];
+  processMove: (
+    state: State,
+    action: ActionPayload.MakeMove
+  ) => State | typeof INVALID_MOVE;
+};
+
+function IsProcessed(game: Game | ProcessedGame): game is ProcessedGame {
+  return game.processMove !== undefined;
+}
+
+/**
+ * Helper to generate the game move reducer. The returned
+ * reducer has the following signature:
+ *
+ * (G, action, ctx) => {}
+ *
+ * You can roll your own if you like, or use any Redux
+ * addon to generate such a reducer.
+ *
+ * The convention used in this framework is to
+ * have action.type contain the name of the move, and
+ * action.args contain any additional arguments as an
+ * Array.
+ */
+export function ProcessGameConfig(game: Game | ProcessedGame): ProcessedGame {
+  // The Game() function has already been called on this
+  // config object, so just pass it through.
+  if (IsProcessed(game)) {
+    return game;
+  }
+
+  if (game.name === undefined) game.name = 'default';
+  if (game.deltaState === undefined) game.deltaState = false;
+  if (game.disableUndo === undefined) game.disableUndo = false;
+  if (game.setup === undefined) game.setup = () => ({});
+  if (game.moves === undefined) game.moves = {};
+  if (game.playerView === undefined) game.playerView = ({ G }) => G;
+  if (game.plugins === undefined) game.plugins = [];
+
+  game.plugins.forEach((plugin) => {
+    if (plugin.name === undefined) {
+      throw new Error('Plugin missing name attribute');
+    }
+    if (plugin.name.includes(' ')) {
+      throw new Error(plugin.name + ': Plugin name must not include spaces');
+    }
+  });
+
+  if (game.name.includes(' ')) {
+    throw new Error(game.name + ': Game name must not include spaces');
+  }
+
+  const flow = Flow(game);
+
+  return {
+    ...game,
+
+    flow,
+
+    moveNames: flow.moveNames as string[],
+
+    pluginNames: game.plugins.map((p) => p.name) as string[],
+
+    processMove: (state: State, action: ActionPayload.MakeMove) => {
+      let moveFn = flow.getMove(state.ctx, action.type, action.playerID);
+
+      if (IsLongFormMove(moveFn)) {
+        moveFn = moveFn.move;
+      }
+
+      if (moveFn instanceof Function) {
+        const fn = plugins.FnWrap(moveFn, GameMethod.MOVE, game.plugins);
+        let args = [];
+        if (action.args !== undefined) {
+          args = Array.isArray(action.args) ? action.args : [action.args];
+        }
+        const context = {
+          ...plugins.GetAPIs(state),
+          G: state.G,
+          ctx: state.ctx,
+          playerID: action.playerID,
+        };
+        return fn(context, ...args);
+      }
+
+      logging.error(`invalid move object: ${action.type}`);
+
+      return state.G;
+    },
+  };
+}
+
+export function IsLongFormMove(move: Move): move is LongFormMove {
+  return move instanceof Object && (move as LongFormMove).move !== undefined;
+}

package/src/core/initialize.ts

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2020 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 { ProcessGameConfig } from './game';
+import * as plugins from '../plugins/main';
+import type { Ctx, Game, PartialGameState, State } from '../types';
+
+/**
+ * Creates the initial game state.
+ */
+export function InitializeGame({
+  game,
+  numPlayers,
+  setupData,
+}: {
+  game: Game;
+  numPlayers?: number;
+  setupData?: any;
+}) {
+  game = ProcessGameConfig(game);
+
+  if (!numPlayers) {
+    numPlayers = 2;
+  }
+
+  const ctx: Ctx = game.flow.ctx(numPlayers);
+
+  let state: PartialGameState = {
+    // User managed state.
+    G: {},
+    // Framework managed state.
+    ctx,
+    // Plugin related state.
+    plugins: {},
+  };
+
+  // Run plugins over initial state.
+  state = plugins.Setup(state, { game });
+  state = plugins.Enhance(state, { game, playerID: undefined });
+
+  const pluginAPIs = plugins.GetAPIs(state);
+  state.G = game.setup({ ...pluginAPIs, ctx: state.ctx }, setupData);
+
+  let initial: State = {
+    ...state,
+
+    // List of {G, ctx} pairs that can be undone.
+    _undo: [],
+    // List of {G, ctx} pairs that can be redone.
+    _redo: [],
+    // A monotonically non-decreasing ID to ensure that
+    // state updates are only allowed from clients that
+    // are at the same version that the server.
+    _stateID: 0,
+  };
+
+  initial = game.flow.init(initial);
+  [initial] = plugins.FlushAndValidate(initial, { game });
+
+  // Initialize undo stack.
+  if (!game.disableUndo) {
+    initial._undo = [
+      {
+        G: initial.G,
+        ctx: initial.ctx,
+        plugins: initial.plugins,
+      },
+    ];
+  }
+
+  return initial;
+}

package/src/core/logger.test.js

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2018 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.
+ */
+
+describe('logging', () => {
+  const oldConsoleLog = console.log;
+  const oldConsoleError = console.error;
+  const oldNodeEnv = process.env.NODE_ENV;
+
+  beforeEach(() => {
+    console.log.mockReset();
+    console.error.mockReset();
+  });
+
+  afterAll(() => {
+    console.log = oldConsoleLog;
+    console.error = oldConsoleError;
+    process.env.NODE_ENV = oldNodeEnv;
+  });
+
+  console.log = jest.fn();
+  console.error = jest.fn();
+
+  describe('dev', () => {
+    let logging;
+
+    beforeAll(() => {
+      logging = require('./logger');
+    });
+
+    test('error', () => {
+      logging.error('msg1');
+      expect(console.error).toHaveBeenCalledWith('ERROR:', 'msg1');
+    });
+
+    test('info', () => {
+      logging.info('msg2');
+      expect(console.log).toHaveBeenCalledWith('INFO: msg2');
+    });
+  });
+
+  describe('production', () => {
+    let logging;
+
+    beforeAll(() => {
+      process.env.NODE_ENV = 'production';
+      jest.resetModules();
+      logging = require('./logger');
+    });
+    afterAll(() => {
+      process.env.NODE_ENV = oldNodeEnv;
+    });
+
+    test('info stripped', () => {
+      logging.info('msg2');
+      expect(console.log).not.toHaveBeenCalled();
+    });
+
+    test('error not stripped', () => {
+      logging.error('msg1');
+      expect(console.error).toHaveBeenCalled();
+    });
+  });
+
+  describe('spying after load', () => {
+    let logging;
+
+    beforeAll(() => {
+      jest.resetModules();
+      console.log = oldConsoleLog;
+      console.error = oldConsoleError;
+      logging = require('./logger');
+      console.log = jest.fn();
+      console.error = jest.fn();
+    });
+
+    test('should allow console log to be spied', () => {
+      logging.info('test');
+      expect(console.log).toHaveBeenCalledWith('INFO: test');
+    });
+    test('should allow console error to be spied', () => {
+      logging.error('test');
+      expect(console.error).toHaveBeenCalledWith('ERROR:', 'test');
+    });
+  });
+});

package/src/core/logger.ts

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2018 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.
+ */
+
+const production = process.env.NODE_ENV === 'production';
+const logfn = production ? () => {} : (...msg) => console.log(...msg);
+const errorfn = (...msg) => console.error(...msg);
+
+export function info(msg: string) {
+  logfn(`INFO: ${msg}`);
+}
+export function error(error: string) {
+  errorfn('ERROR:', error);
+}

package/src/core/player-view.test.ts

@@ -0,0 +1,50 @@
+/*
+ * 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 { PlayerView } from './player-view';
+import type { Ctx } from '../types';
+
+test('no change', () => {
+  const G = { test: true };
+  const newG = PlayerView.STRIP_SECRETS({ G, ctx: {} as Ctx, playerID: '0' });
+  expect(newG).toEqual(G);
+});
+
+test('secret', () => {
+  const G = { secret: true };
+  const newG = PlayerView.STRIP_SECRETS({ G, ctx: {} as Ctx, playerID: '0' });
+  expect(newG).toEqual({});
+});
+
+describe('players', () => {
+  const G = {
+    players: {
+      '0': {},
+      '1': {},
+    },
+  };
+
+  test('playerID: "0"', () => {
+    const newG = PlayerView.STRIP_SECRETS({ G, ctx: {} as Ctx, playerID: '0' });
+    expect(newG.players).toEqual({ '0': {} });
+  });
+
+  test('playerID: "1"', () => {
+    const newG = PlayerView.STRIP_SECRETS({ G, ctx: {} as Ctx, playerID: '1' });
+    expect(newG.players).toEqual({ '1': {} });
+  });
+
+  test('playerID: null', () => {
+    const newG = PlayerView.STRIP_SECRETS({
+      G,
+      ctx: {} as Ctx,
+      playerID: null,
+    });
+    expect(newG.players).toEqual({});
+  });
+});

package/src/core/player-view.ts

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2018 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 type { Game, PlayerID } from '../types';
+
+/**
+ * PlayerView reducers.
+ */
+export const PlayerView: { STRIP_SECRETS: Game['playerView'] } = {
+  /**
+   * STRIP_SECRETS
+   *
+   * Reducer which removes a key named `secret` and
+   * removes all the keys in `players`, except for the one
+   * corresponding to the current playerID.
+   */
+  STRIP_SECRETS: ({ G, playerID }: { G: any; playerID: PlayerID | null }) => {
+    const r = { ...G };
+
+    if (r.secret !== undefined) {
+      delete r.secret;
+    }
+
+    if (r.players) {
+      r.players = playerID
+        ? {
+            [playerID]: r.players[playerID],
+          }
+        : {};
+    }
+
+    return r;
+  },
+};