@mnbroatch/boardgame.io 0.0.1

package/dist/esm/master-fa8f2e43.js

@@ -0,0 +1,318 @@
+import { P as ProcessGameConfig, C as CreateGameReducer, T as TransientHandlingMiddleware, I as IsLongFormMove } from './reducer-c46da7e5.js';
+import { g as error, d as UNDO, c as REDO, M as MAKE_MOVE } from './turn-order-376d315e.js';
+import { applyMiddleware, createStore } from 'redux';
+import { i as isSynchronous, c as createMatch } from './util-b6147cef.js';
+
+/*
+ * 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.
+ */
+/**
+ * Filter match data to get a player metadata object with credentials stripped.
+ */
+const filterMatchData = (matchData) => Object.values(matchData.players).map((player) => {
+    const { credentials, ...filteredData } = player;
+    return filteredData;
+});
+/**
+ * Remove player credentials from action payload
+ */
+const stripCredentialsFromAction = (action) => {
+    const { credentials, ...payload } = action.payload;
+    return { ...action, payload };
+};
+/**
+ * Master
+ *
+ * Class that runs the game and maintains the authoritative state.
+ * It uses the transportAPI to communicate with clients and the
+ * storageAPI to communicate with the database.
+ */
+class Master {
+    constructor(game, storageAPI, transportAPI, auth) {
+        this.game = ProcessGameConfig(game);
+        this.storageAPI = storageAPI;
+        this.transportAPI = transportAPI;
+        this.subscribeCallback = () => { };
+        this.auth = auth;
+    }
+    subscribe(fn) {
+        this.subscribeCallback = fn;
+    }
+    /**
+     * Called on each move / event made by the client.
+     * Computes the new value of the game state and returns it
+     * along with a deltalog.
+     */
+    async onUpdate(credAction, stateID, matchID, playerID) {
+        if (!credAction || !credAction.payload) {
+            return { error: 'missing action or action payload' };
+        }
+        let metadata;
+        if (isSynchronous(this.storageAPI)) {
+            ({ metadata } = this.storageAPI.fetch(matchID, { metadata: true }));
+        }
+        else {
+            ({ metadata } = await this.storageAPI.fetch(matchID, { metadata: true }));
+        }
+        if (this.auth) {
+            const isAuthentic = await this.auth.authenticateCredentials({
+                playerID,
+                credentials: credAction.payload.credentials,
+                metadata,
+            });
+            if (!isAuthentic) {
+                return { error: 'unauthorized action' };
+            }
+        }
+        const action = stripCredentialsFromAction(credAction);
+        const key = matchID;
+        let state;
+        if (isSynchronous(this.storageAPI)) {
+            ({ state } = this.storageAPI.fetch(key, { state: true }));
+        }
+        else {
+            ({ state } = await this.storageAPI.fetch(key, { state: true }));
+        }
+        if (state === undefined) {
+            error(`game not found, matchID=[${key}]`);
+            return { error: 'game not found' };
+        }
+        if (state.ctx.gameover !== undefined) {
+            error(`game over - matchID=[${key}] - playerID=[${playerID}]` +
+                ` - action[${action.payload.type}]`);
+            return;
+        }
+        const reducer = CreateGameReducer({
+            game: this.game,
+        });
+        const middleware = applyMiddleware(TransientHandlingMiddleware);
+        const store = createStore(reducer, state, middleware);
+        // Only allow UNDO / REDO if there is exactly one player
+        // that can make moves right now and the person doing the
+        // action is that player.
+        if (action.type == UNDO || action.type == REDO) {
+            const hasActivePlayers = state.ctx.activePlayers !== null;
+            const isCurrentPlayer = state.ctx.currentPlayer === playerID;
+            if (
+            // If activePlayers is empty, non-current players can’t undo.
+            (!hasActivePlayers && !isCurrentPlayer) ||
+                // If player is not active or multiple players are active, can’t undo.
+                (hasActivePlayers &&
+                    (state.ctx.activePlayers[playerID] === undefined ||
+                        Object.keys(state.ctx.activePlayers).length > 1))) {
+                error(`playerID=[${playerID}] cannot undo / redo right now`);
+                return;
+            }
+        }
+        // Check whether the player is active.
+        if (!this.game.flow.isPlayerActive(state.G, state.ctx, playerID)) {
+            error(`player not active - playerID=[${playerID}]` +
+                ` - action[${action.payload.type}]`);
+            return;
+        }
+        // Get move for further checks
+        const move = action.type == MAKE_MOVE
+            ? this.game.flow.getMove(state.ctx, action.payload.type, playerID)
+            : null;
+        // Check whether the player is allowed to make the move.
+        if (action.type == MAKE_MOVE && !move) {
+            error(`move not processed - canPlayerMakeMove=false - playerID=[${playerID}]` +
+                ` - action[${action.payload.type}]`);
+            return;
+        }
+        // Check if action's stateID is different than store's stateID
+        // and if move does not have ignoreStaleStateID truthy.
+        if (state._stateID !== stateID &&
+            !(move && IsLongFormMove(move) && move.ignoreStaleStateID)) {
+            error(`invalid stateID, was=[${stateID}], expected=[${state._stateID}]` +
+                ` - playerID=[${playerID}] - action[${action.payload.type}]`);
+            return;
+        }
+        const prevState = store.getState();
+        // Update server's version of the store.
+        store.dispatch(action);
+        state = store.getState();
+        this.subscribeCallback({
+            state,
+            action,
+            matchID,
+        });
+        if (this.game.deltaState) {
+            this.transportAPI.sendAll({
+                type: 'patch',
+                args: [matchID, stateID, prevState, state],
+            });
+        }
+        else {
+            this.transportAPI.sendAll({
+                type: 'update',
+                args: [matchID, state],
+            });
+        }
+        const { deltalog, ...stateWithoutDeltalog } = state;
+        let newMetadata;
+        if (metadata &&
+            (metadata.gameover === undefined || metadata.gameover === null)) {
+            newMetadata = {
+                ...metadata,
+                updatedAt: Date.now(),
+            };
+            if (state.ctx.gameover !== undefined) {
+                newMetadata.gameover = state.ctx.gameover;
+            }
+        }
+        if (isSynchronous(this.storageAPI)) {
+            this.storageAPI.setState(key, stateWithoutDeltalog, deltalog);
+            if (newMetadata)
+                this.storageAPI.setMetadata(key, newMetadata);
+        }
+        else {
+            const writes = [
+                this.storageAPI.setState(key, stateWithoutDeltalog, deltalog),
+            ];
+            if (newMetadata) {
+                writes.push(this.storageAPI.setMetadata(key, newMetadata));
+            }
+            await Promise.all(writes);
+        }
+    }
+    /**
+     * Called when the client connects / reconnects.
+     * Returns the latest game state and the entire log.
+     */
+    async onSync(matchID, playerID, credentials, numPlayers = 2) {
+        const key = matchID;
+        const fetchOpts = {
+            state: true,
+            metadata: true,
+            log: true,
+            initialState: true,
+        };
+        const fetchResult = isSynchronous(this.storageAPI)
+            ? this.storageAPI.fetch(key, fetchOpts)
+            : await this.storageAPI.fetch(key, fetchOpts);
+        let { state, initialState, log, metadata } = fetchResult;
+        if (this.auth && playerID !== undefined && playerID !== null) {
+            const isAuthentic = await this.auth.authenticateCredentials({
+                playerID,
+                credentials,
+                metadata,
+            });
+            if (!isAuthentic) {
+                return { error: 'unauthorized' };
+            }
+        }
+        // If the game doesn't exist, then create one on demand.
+        // TODO: Move this out of the sync call.
+        if (state === undefined) {
+            const match = createMatch({
+                game: this.game,
+                unlisted: true,
+                numPlayers,
+                setupData: undefined,
+            });
+            if ('setupDataError' in match) {
+                return { error: 'game requires setupData' };
+            }
+            initialState = state = match.initialState;
+            metadata = match.metadata;
+            this.subscribeCallback({ state, matchID });
+            if (isSynchronous(this.storageAPI)) {
+                this.storageAPI.createMatch(key, { initialState, metadata });
+            }
+            else {
+                await this.storageAPI.createMatch(key, { initialState, metadata });
+            }
+        }
+        const filteredMetadata = metadata ? filterMatchData(metadata) : undefined;
+        const syncInfo = {
+            state,
+            log,
+            filteredMetadata,
+            initialState,
+        };
+        this.transportAPI.send({
+            playerID,
+            type: 'sync',
+            args: [matchID, syncInfo],
+        });
+        return;
+    }
+    /**
+     * Called when a client connects or disconnects.
+     * Updates and sends out metadata to reflect the player’s connection status.
+     */
+    async onConnectionChange(matchID, playerID, credentials, connected) {
+        const key = matchID;
+        // Ignore changes for clients without a playerID, e.g. spectators.
+        if (playerID === undefined || playerID === null) {
+            return;
+        }
+        let metadata;
+        if (isSynchronous(this.storageAPI)) {
+            ({ metadata } = this.storageAPI.fetch(key, { metadata: true }));
+        }
+        else {
+            ({ metadata } = await this.storageAPI.fetch(key, { metadata: true }));
+        }
+        if (metadata === undefined) {
+            error(`metadata not found for matchID=[${key}]`);
+            return { error: 'metadata not found' };
+        }
+        if (metadata.players[playerID] === undefined) {
+            error(`Player not in the match, matchID=[${key}] playerID=[${playerID}]`);
+            return { error: 'player not in the match' };
+        }
+        if (this.auth) {
+            const isAuthentic = await this.auth.authenticateCredentials({
+                playerID,
+                credentials,
+                metadata,
+            });
+            if (!isAuthentic) {
+                return { error: 'unauthorized' };
+            }
+        }
+        metadata.players[playerID].isConnected = connected;
+        const filteredMetadata = filterMatchData(metadata);
+        this.transportAPI.sendAll({
+            type: 'matchData',
+            args: [matchID, filteredMetadata],
+        });
+        if (isSynchronous(this.storageAPI)) {
+            this.storageAPI.setMetadata(key, metadata);
+        }
+        else {
+            await this.storageAPI.setMetadata(key, metadata);
+        }
+    }
+    async onChatMessage(matchID, chatMessage, credentials) {
+        const key = matchID;
+        if (this.auth) {
+            const { metadata } = await this.storageAPI.fetch(key, {
+                metadata: true,
+            });
+            if (!(chatMessage && typeof chatMessage.sender === 'string')) {
+                return { error: 'unauthorized' };
+            }
+            const isAuthentic = await this.auth.authenticateCredentials({
+                playerID: chatMessage.sender,
+                credentials,
+                metadata,
+            });
+            if (!isAuthentic) {
+                return { error: 'unauthorized' };
+            }
+        }
+        this.transportAPI.sendAll({
+            type: 'chat',
+            args: [matchID, chatMessage],
+        });
+    }
+}
+
+export { Master as M };

package/dist/esm/master.js

@@ -0,0 +1,10 @@
+export { M as Master } from './master-fa8f2e43.js';
+import './reducer-c46da7e5.js';
+import './turn-order-376d315e.js';
+import 'immer';
+import './plugin-random-087f861e.js';
+import 'lodash.isplainobject';
+import 'rfc6902';
+import 'redux';
+import './util-b6147cef.js';
+import './initialize-11d626ca.js';

package/dist/esm/multiplayer.js

@@ -0,0 +1,14 @@
+export { L as Local, S as SocketIO } from './socketio-c22ffa65.js';
+import './util-b6147cef.js';
+import './initialize-11d626ca.js';
+import './reducer-c46da7e5.js';
+import './turn-order-376d315e.js';
+import 'immer';
+import './plugin-random-087f861e.js';
+import 'lodash.isplainobject';
+import 'rfc6902';
+import './master-fa8f2e43.js';
+import 'redux';
+import './transport-ce07b771.js';
+import './filter-player-view-2c6cc96f.js';
+import 'socket.io-client';

package/dist/esm/plugin-random-087f861e.js

@@ -0,0 +1,226 @@
+// Inlined version of Alea from https://github.com/davidbau/seedrandom.
+// Converted to Typescript October 2020.
+class Alea {
+    constructor(seed) {
+        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) {
+        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, t) {
+    t.c = f.c;
+    t.s0 = f.s0;
+    t.s1 = f.s1;
+    t.s2 = f.s2;
+    return t;
+}
+function alea(seed, state) {
+    const xg = new Alea(seed);
+    const prng = xg.next.bind(xg);
+    if (state)
+        copy(state, xg);
+    prng.state = () => copy(xg, {});
+    return prng;
+}
+
+/*
+ * 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.
+ */
+/**
+ * Random
+ *
+ * Calls that require a pseudorandom number generator.
+ * Uses a seed from ctx, and also persists the PRNG
+ * state in ctx so that moves can stay pure.
+ */
+class Random {
+    /**
+     * constructor
+     * @param {object} ctx - The ctx object to initialize from.
+     */
+    constructor(state) {
+        // If we are on the client, the seed is not present.
+        // Just use a temporary seed to execute the move without
+        // crashing it. The move state itself is discarded,
+        // so the actual value doesn't matter.
+        this.state = state || { seed: '0' };
+        this.used = false;
+    }
+    /**
+     * Generates a new seed from the current date / time.
+     */
+    static seed() {
+        return Date.now().toString(36).slice(-10);
+    }
+    isUsed() {
+        return this.used;
+    }
+    getState() {
+        return this.state;
+    }
+    /**
+     * Generate a random number.
+     */
+    _random() {
+        this.used = true;
+        const R = this.state;
+        const seed = R.prngstate ? '' : R.seed;
+        const rand = alea(seed, R.prngstate);
+        const number = rand();
+        this.state = {
+            ...R,
+            prngstate: rand.state(),
+        };
+        return number;
+    }
+    api() {
+        const random = this._random.bind(this);
+        const SpotValue = {
+            D4: 4,
+            D6: 6,
+            D8: 8,
+            D10: 10,
+            D12: 12,
+            D20: 20,
+        };
+        // Generate functions for predefined dice values D4 - D20.
+        const predefined = {};
+        for (const key in SpotValue) {
+            const spotvalue = SpotValue[key];
+            predefined[key] = (diceCount) => {
+                return diceCount === undefined
+                    ? Math.floor(random() * spotvalue) + 1
+                    : Array.from({ length: diceCount }).map(() => Math.floor(random() * spotvalue) + 1);
+            };
+        }
+        function Die(spotvalue = 6, diceCount) {
+            return diceCount === undefined
+                ? Math.floor(random() * spotvalue) + 1
+                : Array.from({ length: diceCount }).map(() => Math.floor(random() * spotvalue) + 1);
+        }
+        return {
+            /**
+             * Similar to Die below, but with fixed spot values.
+             * Supports passing a diceCount
+             *    if not defined, defaults to 1 and returns the value directly.
+             *    if defined, returns an array containing the random dice values.
+             *
+             * D4: (diceCount) => value
+             * D6: (diceCount) => value
+             * D8: (diceCount) => value
+             * D10: (diceCount) => value
+             * D12: (diceCount) => value
+             * D20: (diceCount) => value
+             */
+            ...predefined,
+            /**
+             * Roll a die of specified spot value.
+             *
+             * @param {number} spotvalue - The die dimension (default: 6).
+             * @param {number} diceCount - number of dice to throw.
+             *                             if not defined, defaults to 1 and returns the value directly.
+             *                             if defined, returns an array containing the random dice values.
+             */
+            Die,
+            /**
+             * Generate a random number between 0 and 1.
+             */
+            Number: () => {
+                return random();
+            },
+            /**
+             * Shuffle an array.
+             *
+             * @param {Array} deck - The array to shuffle. Does not mutate
+             *                       the input, but returns the shuffled array.
+             */
+            Shuffle: (deck) => {
+                const clone = [...deck];
+                let sourceIndex = deck.length;
+                let destinationIndex = 0;
+                const shuffled = Array.from({ length: sourceIndex });
+                while (sourceIndex) {
+                    const randomIndex = Math.trunc(sourceIndex * random());
+                    shuffled[destinationIndex++] = clone[randomIndex];
+                    clone[randomIndex] = clone[--sourceIndex];
+                }
+                return shuffled;
+            },
+            _private: this,
+        };
+    }
+}
+
+/*
+ * 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 RandomPlugin = {
+    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 { RandomPlugin as R, alea as a };

package/dist/esm/plugins.js

@@ -0,0 +1,55 @@
+/*
+ * 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.
+ */
+/**
+ * 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 = ({ setup, playerView, } = {}) => ({
+    name: 'player',
+    flush: ({ api }) => {
+        return { players: api.state };
+    },
+    api: ({ ctx, data }) => {
+        const state = data.players;
+        const get = () => {
+            return data.players[ctx.currentPlayer];
+        };
+        const set = (value) => {
+            return (state[ctx.currentPlayer] = value);
+        };
+        const result = { 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 = {};
+        for (let i = 0; i < ctx.numPlayers; i++) {
+            let playerState = {};
+            if (setup !== undefined) {
+                playerState = setup(i + '');
+            }
+            players[i + ''] = playerState;
+        }
+        return { players };
+    },
+    playerView: ({ data, playerID }) => playerView ? { players: playerView(data.players, playerID) } : data,
+});
+
+export { PlayerPlugin as PluginPlayer };