@mnbroatch/boardgame.io 0.0.1

package/src/plugins/plugin-player.test.ts

@@ -0,0 +1,172 @@
+/*
+ * 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 PluginPlayer from './plugin-player';
+import type { PlayerAPI } from './plugin-player';
+import { Client } from '../client/client';
+import type { Game } from '../types';
+
+describe('default values', () => {
+  test('playerState is not passed', () => {
+    const plugin = PluginPlayer();
+    const game: Game<any, { player: PlayerAPI }> = {
+      plugins: [plugin],
+    };
+    const client = Client({ game });
+    expect(client.getState().plugins[plugin.name].data).toEqual({
+      players: { '0': {}, '1': {} },
+    });
+  });
+
+  test('playerState is passed', () => {
+    const plugin = PluginPlayer({ setup: () => ({ A: 1 }) });
+    const game: Game<any, { player: PlayerAPI }> = {
+      plugins: [plugin],
+    };
+    const client = Client({ game });
+    expect(client.getState().plugins[plugin.name].data).toEqual({
+      players: { '0': { A: 1 }, '1': { A: 1 } },
+    });
+  });
+});
+
+describe('2 player game', () => {
+  let client;
+
+  beforeAll(() => {
+    const game: Game<any, { player: PlayerAPI }> = {
+      moves: {
+        A: ({ player }) => {
+          player.set({ field: 'A1' });
+          player.opponent.set({ field: 'A2' });
+        },
+
+        B: ({ G, player }) => {
+          G.playerValue = player.get().field;
+          G.opponentValue = player.opponent.get().field;
+        },
+      },
+
+      plugins: [PluginPlayer()],
+    };
+
+    client = Client({ game });
+  });
+
+  test('player 0 turn', () => {
+    client.moves.A();
+    expect(client.getState().plugins[PluginPlayer().name].data).toEqual({
+      players: {
+        '0': { field: 'A1' },
+        '1': { field: 'A2' },
+      },
+    });
+  });
+
+  test('player 1 turn', () => {
+    client.events.endTurn();
+    client.moves.A();
+    expect(client.getState().plugins[PluginPlayer().name].data).toEqual({
+      players: {
+        '0': { field: 'A2' },
+        '1': { field: 'A1' },
+      },
+    });
+  });
+
+  test('player 1 makes move B', () => {
+    client.moves.B();
+    expect(client.getState().G).toEqual({
+      playerValue: 'A1',
+      opponentValue: 'A2',
+    });
+  });
+});
+
+describe('3 player game', () => {
+  let client;
+
+  beforeAll(() => {
+    const game: Game<any, { player: PlayerAPI }> = {
+      moves: {
+        A: ({ player }) => {
+          player.set({ field: 'A' });
+        },
+      },
+
+      plugins: [PluginPlayer()],
+    };
+
+    client = Client({ game, numPlayers: 3 });
+  });
+
+  test('G.opponent is not created', () => {
+    client.moves.A();
+    expect(client.getState().plugins[PluginPlayer().name].data).toEqual({
+      players: {
+        '0': { field: 'A' },
+        '1': {},
+        '2': {},
+      },
+    });
+  });
+});
+
+describe('game with phases', () => {
+  let client;
+
+  beforeAll(() => {
+    const game: Game<any, { player: PlayerAPI }> = {
+      plugins: [PluginPlayer({ setup: (id) => ({ id }) })],
+      phases: {
+        phase: {},
+      },
+    };
+
+    client = Client({ game });
+  });
+
+  test('includes playerSetup state', () => {
+    expect(client.getState().plugins[PluginPlayer().name].data).toEqual({
+      players: {
+        0: {
+          id: '0',
+        },
+        1: {
+          id: '1',
+        },
+      },
+    });
+  });
+});
+
+describe('with playerView', () => {
+  const plugin = PluginPlayer({
+    setup: (id) => ({ id }),
+    playerView: (players, playerID) => ({
+      [playerID]: players[playerID],
+    }),
+  });
+  const game = {
+    plugins: [plugin],
+  };
+
+  test('spectator doesn’t see player state', () => {
+    const spectator = Client({ game });
+    expect(spectator.getState().plugins[plugin.name].data).toEqual({
+      players: {},
+    });
+  });
+
+  test('player only sees own state', () => {
+    const client = Client({ game, playerID: '0' });
+    expect(client.getState().plugins[plugin.name].data).toEqual({
+      players: { '0': { id: '0' } },
+    });
+  });
+});

package/src/plugins/plugin-player.ts

@@ -0,0 +1,100 @@
+/*
+ * 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 { Plugin, PlayerID } from '../types';
+
+interface PlayerData<PlayerState extends any = any> {
+  players: Record<PlayerID, PlayerState>;
+}
+
+export interface PlayerAPI<PlayerState extends any = any> {
+  state: Record<PlayerID, PlayerState>;
+  get(): PlayerState;
+  set(value: PlayerState): PlayerState;
+  opponent?: {
+    get(): PlayerState;
+    set(value: PlayerState): PlayerState;
+  };
+}
+
+interface PluginPlayerOpts<PlayerState extends any = any> {
+  setup?: (playerID: string) => PlayerState;
+  playerView?: (
+    players: Record<PlayerID, PlayerState>,
+    playerID?: string | null
+  ) => any;
+}
+
+export interface PlayerPlugin<PlayerState extends any = any> {
+  player: PlayerAPI<PlayerState>;
+}
+
+/**
+ * Plugin that maintains state for each player in G.players.
+ * During a turn, G.player will contain the object for the current player.
+ * In two player games, G.opponent will contain the object for the other player.
+ *
+ * @param {function} initPlayerState - Function of type (playerID) => playerState.
+ */
+const PlayerPlugin = <PlayerState extends any = any>({
+  setup,
+  playerView,
+}: PluginPlayerOpts<PlayerState> = {}): Plugin<
+  PlayerAPI<PlayerState>,
+  PlayerData<PlayerState>
+> => ({
+  name: 'player',
+
+  flush: ({ api }) => {
+    return { players: api.state };
+  },
+
+  api: ({ ctx, data }): PlayerAPI => {
+    const state = data.players;
+
+    const get = () => {
+      return data.players[ctx.currentPlayer];
+    };
+
+    const set = (value) => {
+      return (state[ctx.currentPlayer] = value);
+    };
+
+    const result: PlayerAPI = { state, get, set };
+
+    if (ctx.numPlayers === 2) {
+      const other = ctx.currentPlayer === '0' ? '1' : '0';
+      const get = () => {
+        return data.players[other];
+      };
+      const set = (value) => {
+        return (state[other] = value);
+      };
+      result.opponent = { get, set };
+    }
+
+    return result;
+  },
+
+  setup: ({ ctx }) => {
+    const players: Record<PlayerID, any> = {};
+    for (let i = 0; i < ctx.numPlayers; i++) {
+      let playerState: any = {};
+      if (setup !== undefined) {
+        playerState = setup(i + '');
+      }
+      players[i + ''] = playerState;
+    }
+    return { players };
+  },
+
+  playerView: ({ data, playerID }) =>
+    playerView ? { players: playerView(data.players, playerID) } : data,
+});
+
+export default PlayerPlugin;

package/src/plugins/plugin-random.ts

@@ -0,0 +1,40 @@
+/*
+ * 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 { Plugin } from '../types';
+import type { RandomAPI, PrivateRandomAPI, RandomState } from './random/random';
+import { Random } from './random/random';
+
+const RandomPlugin: Plugin<RandomAPI & PrivateRandomAPI, RandomState> = {
+  name: 'random',
+
+  noClient: ({ api }) => {
+    return api._private.isUsed();
+  },
+
+  flush: ({ api }) => {
+    return api._private.getState();
+  },
+
+  api: ({ data }) => {
+    const random = new Random(data);
+    return random.api();
+  },
+
+  setup: ({ game }) => {
+    let { seed } = game;
+    if (seed === undefined) {
+      seed = Random.seed();
+    }
+    return { seed };
+  },
+
+  playerView: () => undefined,
+};
+
+export default RandomPlugin;

package/src/plugins/plugin-serializable.test.ts

@@ -0,0 +1,40 @@
+import { Client } from '../client/client';
+import type { Game } from '../types';
+
+describe('plugin-serializable', () => {
+  let client: ReturnType<typeof Client>;
+
+  beforeAll(() => {
+    const game: Game = {
+      moves: {
+        serializable: () => {
+          return { hello: 'world' };
+        },
+
+        nonSerializable: () => {
+          class Foo {
+            a: number;
+            constructor(a: number) {
+              this.a = a;
+            }
+          }
+          return { hello: new Foo(1) };
+        },
+      },
+    };
+
+    client = Client({ game });
+  });
+
+  test('does not throw for serializable move', () => {
+    expect(() => {
+      client.moves.serializable();
+    }).not.toThrow();
+  });
+
+  test('throws for non-serializable move', () => {
+    expect(() => {
+      client.moves.nonSerializable();
+    }).toThrow();
+  });
+});

package/src/plugins/plugin-serializable.ts

@@ -0,0 +1,55 @@
+import type { Plugin } from '../types';
+import isPlainObject from 'lodash.isplainobject';
+
+/**
+ * Check if a value can be serialized (e.g. using `JSON.stringify`).
+ * Adapted from: https://stackoverflow.com/a/30712764/3829557
+ */
+function isSerializable(value: any) {
+  // Primitives are OK.
+  if (
+    value === undefined ||
+    value === null ||
+    typeof value === 'boolean' ||
+    typeof value === 'number' ||
+    typeof value === 'string'
+  ) {
+    return true;
+  }
+
+  // A non-primitive value that is neither a POJO or an array cannot be serialized.
+  if (!isPlainObject(value) && !Array.isArray(value)) {
+    return false;
+  }
+
+  // Recurse entries if the value is an object or array.
+  for (const key in value) {
+    if (!isSerializable(value[key])) return false;
+  }
+
+  return true;
+}
+
+/**
+ * Plugin that checks whether state is serializable, in order to avoid
+ * network serialization bugs.
+ */
+const SerializablePlugin: Plugin = {
+  name: 'plugin-serializable',
+
+  fnWrap:
+    (move) =>
+    (context, ...args) => {
+      const result = move(context, ...args);
+      // Check state in non-production environments.
+      if (process.env.NODE_ENV !== 'production' && !isSerializable(result)) {
+        throw new Error(
+          'Move state is not JSON-serialiazable.\n' +
+            'See https://boardgame.io/documentation/#/?id=state for more information.'
+        );
+      }
+      return result;
+    },
+};
+
+export default SerializablePlugin;

package/src/plugins/random/random.alea.ts

@@ -0,0 +1,109 @@
+// Inlined version of Alea from https://github.com/davidbau/seedrandom.
+// Converted to Typescript October 2020.
+
+/*
+ * Copyright 2015 David Bau.
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software
+ * and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the
+ * Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall
+ * be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+export interface AleaState {
+  c: number;
+  s0: number;
+  s1: number;
+  s2: number;
+}
+
+class Alea {
+  c: number;
+  s0: number;
+  s1: number;
+  s2: number;
+
+  constructor(seed: string | number) {
+    const mash = Mash();
+
+    // Apply the seeding algorithm from Baagoe.
+    this.c = 1;
+    this.s0 = mash(' ');
+    this.s1 = mash(' ');
+    this.s2 = mash(' ');
+    this.s0 -= mash(seed);
+    if (this.s0 < 0) {
+      this.s0 += 1;
+    }
+    this.s1 -= mash(seed);
+    if (this.s1 < 0) {
+      this.s1 += 1;
+    }
+    this.s2 -= mash(seed);
+    if (this.s2 < 0) {
+      this.s2 += 1;
+    }
+  }
+
+  next() {
+    const t = 2091639 * this.s0 + this.c * 2.3283064365386963e-10; // 2^-32
+    this.s0 = this.s1;
+    this.s1 = this.s2;
+    return (this.s2 = t - (this.c = Math.trunc(t)));
+  }
+}
+
+function Mash() {
+  let n = 0xefc8249d;
+
+  const mash = function (data: string | number) {
+    const str = data.toString();
+    for (let i = 0; i < str.length; i++) {
+      n += str.charCodeAt(i);
+      let h = 0.02519603282416938 * n;
+      n = h >>> 0;
+      h -= n;
+      h *= n;
+      n = h >>> 0;
+      h -= n;
+      n += h * 0x100000000; // 2^32
+    }
+    return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
+  };
+
+  return mash;
+}
+
+function copy(f: AleaState, t: Partial<AleaState>) {
+  t.c = f.c;
+  t.s0 = f.s0;
+  t.s1 = f.s1;
+  t.s2 = f.s2;
+  return t as AleaState;
+}
+
+type PRNG = Alea['next'] & { state?: () => AleaState };
+
+export function alea(seed: string | number, state?: AleaState): PRNG {
+  const xg = new Alea(seed);
+  const prng = xg.next.bind(xg) as PRNG;
+  if (state) copy(state, xg);
+  prng.state = () => copy(xg, {});
+  return prng;
+}

package/src/plugins/random/random.test.ts

@@ -0,0 +1,167 @@
+/*
+ * 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 { Random } from './random';
+import { makeMove } from '../../core/action-creators';
+import { CreateGameReducer } from '../../core/reducer';
+import { InitializeGame } from '../../core/initialize';
+import { Client } from '../../client/client';
+import type { Game } from '../../types';
+import { PlayerView } from '../main';
+
+function Init(seed) {
+  return new Random({ seed });
+}
+
+test('random', () => {
+  const r = Init('hi there');
+  // make sure that subsequent calls are different.
+  expect(r._random()).toBe(0.573445922927931);
+  expect(r._random()).toBe(0.4695413049776107);
+  expect(r._random()).toBe(0.5943194630090147);
+});
+
+test('predefined dice values', () => {
+  const r = Init(0);
+
+  const rfns = [4, 6, 8, 10, 12, 20].map((v) => {
+    return { fn: r.api()[`D${v}`], highest: v };
+  });
+
+  rfns.forEach((pair) => {
+    const result = pair.fn();
+    expect(result).toBeDefined();
+    expect(result).toBeGreaterThanOrEqual(1);
+    expect(result).toBeLessThanOrEqual(pair.highest);
+    expect(r.state.prngstate).toBeDefined();
+
+    const multiple = pair.fn(5);
+    expect(multiple).toBeDefined();
+    expect(multiple).toHaveLength(5);
+    multiple.forEach((m) => {
+      expect(m).toBeGreaterThanOrEqual(1);
+      expect(m).toBeLessThanOrEqual(pair.highest);
+    });
+  });
+});
+
+test('Random.Die', () => {
+  const r = Init(0);
+  const api = r.api();
+
+  {
+    const result = api.Die(123);
+    expect(result).toBeDefined();
+    expect(result).toBe(74);
+    expect(r.state.prngstate).toBeDefined();
+  }
+
+  {
+    const result = api.Die();
+    expect(result).toBeDefined();
+    expect(result).toBeLessThanOrEqual(6);
+    expect(r.state.prngstate).toBeDefined();
+  }
+
+  {
+    const multiple = api.Die(6, 3);
+    expect(multiple).toBeDefined();
+    expect(multiple).toHaveLength(3);
+    multiple.forEach((m) => {
+      expect(m).toBeGreaterThanOrEqual(1);
+      expect(m).toBeLessThanOrEqual(6);
+    });
+    expect(r.state.prngstate).toBeDefined();
+  }
+});
+
+test('Random.Number', () => {
+  const r = Init(0);
+  const result = r.api().Number();
+  expect(result).toBeDefined();
+  expect(result).toBeGreaterThanOrEqual(0);
+  expect(result).toBeLessThanOrEqual(1);
+  expect(r.state.prngstate).toBeDefined();
+});
+
+test('Random.Shuffle', () => {
+  const r = Init(0);
+  const initialTiles = ['A', 'B', 'C', 'D', 'E'];
+  const tiles = [...initialTiles];
+  const result = r.api().Shuffle(tiles);
+  expect(result).toHaveLength(initialTiles.length);
+  expect(result).toEqual(expect.arrayContaining(initialTiles));
+  expect(result.sort()).toEqual(initialTiles);
+  expect(r.state.prngstate).toBeDefined();
+});
+
+test('Random API is not executed optimisitically', () => {
+  const game: Game = {
+    seed: 0,
+    moves: {
+      rollDie: ({ G, random }) => ({ ...G, die: random.D6() }),
+    },
+  };
+
+  {
+    const reducer = CreateGameReducer({ game });
+    let state = InitializeGame({ game });
+    expect(state.G.die).not.toBeDefined();
+    state = reducer(state, makeMove('rollDie'));
+    expect(state.G).toMatchObject({ die: 4 });
+  }
+
+  {
+    const reducer = CreateGameReducer({ game, isClient: true });
+    let state = InitializeGame({ game });
+    expect(state.G.die).not.toBeDefined();
+    state = reducer(state, makeMove('rollDie'));
+    expect(state.G.die).not.toBeDefined();
+  }
+});
+
+test('Random API works when its state is redacted by playerView', () => {
+  const game = {
+    seed: 0,
+    moves: {
+      rollDie: ({ G, random }) => ({ ...G, die: random.D6() }),
+    },
+  };
+
+  const opts = { game, isClient: true };
+  const reducer = CreateGameReducer(opts);
+  let state = InitializeGame({ game });
+  state.plugins = PlayerView(state, { ...opts, playerID: '0' });
+  expect(state.plugins.random.data).not.toBeDefined();
+  expect(state.G.die).not.toBeDefined();
+  state = reducer(state, makeMove('rollDie'));
+  expect(state.G.die).not.toBeDefined();
+});
+
+test('turn.onBegin has ctx APIs at the beginning of the game', () => {
+  let random = null;
+  let events = null;
+
+  const game: Game = {
+    turn: {
+      onBegin: (context) => {
+        random = context.random;
+        events = context.events;
+      },
+    },
+  };
+
+  InitializeGame({ game });
+  expect(random).not.toBe(null);
+  expect(events).not.toBe(null);
+});
+
+test('PRNG state is not sent to the client', () => {
+  const client = Client({ game: {} });
+  expect(client.getState().plugins.random.data).toBeUndefined();
+});