@mnbroatch/boardgame.io 0.0.1

package/dist/cjs/plugin-random-7425844d.js

@@ -0,0 +1,229 @@
+'use strict';
+
+// 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,
+};
+
+exports.RandomPlugin = RandomPlugin;
+exports.alea = alea;

package/dist/cjs/plugins.js

@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/*
+ * 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,
+});
+
+exports.PluginPlayer = PlayerPlugin;

package/dist/cjs/react-native.js

@@ -0,0 +1,182 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Debug = require('./Debug-9d141c06.js');
+var React = require('react');
+var PropTypes = require('prop-types');
+var client = require('./client-a22d7500.js');
+require('./turn-order-b2ff8740.js');
+require('immer');
+require('./plugin-random-7425844d.js');
+require('lodash.isplainobject');
+require('flatted');
+require('./reducer-16eec232.js');
+require('rfc6902');
+require('./ai-e0e8a768.js');
+require('setimmediate');
+require('nanoid/non-secure');
+require('redux');
+require('./initialize-267fcd69.js');
+require('./transport-b1874dfa.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var PropTypes__default = /*#__PURE__*/_interopDefaultLegacy(PropTypes);
+
+var _excluded = ["matchID", "playerID"];
+/**
+ * Client
+ *
+ * boardgame.io React Native client.
+ *
+ * @param {...object} game - The return value of `Game`.
+ * @param {...object} numPlayers - The number of players.
+ * @param {...object} board - The React component for the game.
+ * @param {...object} loading - (optional) The React component for the loading state.
+ * @param {...object} multiplayer - Set to a falsy value or a transportFactory, e.g., SocketIO()
+ * @param {...object} enhancer - Optional enhancer to send to the Redux store
+ *
+ * Returns:
+ *   A React Native component that wraps board and provides an
+ *   API through props for it to interact with the framework
+ *   and dispatch actions such as MAKE_MOVE.
+ */
+
+function Client(opts) {
+  var _class, _temp;
+
+  var game = opts.game,
+      numPlayers = opts.numPlayers,
+      board = opts.board,
+      multiplayer = opts.multiplayer,
+      enhancer = opts.enhancer;
+  var loading = opts.loading; // Component that is displayed before the client has synced
+  // with the game master.
+
+  if (loading === undefined) {
+    var Loading = function Loading() {
+      return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null);
+    };
+
+    loading = Loading;
+  }
+  /*
+   * WrappedBoard
+   *
+   * The main React component that wraps the passed in
+   * board component and adds the API to its props.
+   */
+
+
+  return _temp = _class = /*#__PURE__*/function (_React$Component) {
+    Debug._inherits(WrappedBoard, _React$Component);
+
+    var _super = Debug._createSuper(WrappedBoard);
+
+    function WrappedBoard(props) {
+      var _this;
+
+      Debug._classCallCheck(this, WrappedBoard);
+
+      _this = _super.call(this, props);
+      _this.client = client.Client({
+        game: game,
+        numPlayers: numPlayers,
+        multiplayer: multiplayer,
+        matchID: props.matchID,
+        playerID: props.playerID,
+        credentials: props.credentials,
+        debug: false,
+        enhancer: enhancer
+      });
+      return _this;
+    }
+
+    Debug._createClass(WrappedBoard, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        var _this2 = this;
+
+        this.unsubscribe = this.client.subscribe(function () {
+          return _this2.forceUpdate();
+        });
+        this.client.start();
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        this.client.stop();
+        this.unsubscribe();
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        if (prevProps.matchID != this.props.matchID) {
+          this.client.updateMatchID(this.props.matchID);
+        }
+
+        if (prevProps.playerID != this.props.playerID) {
+          this.client.updatePlayerID(this.props.playerID);
+        }
+
+        if (prevProps.credentials != this.props.credentials) {
+          this.client.updateCredentials(this.props.credentials);
+        }
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _board = null;
+        var state = this.client.getState();
+
+        if (state === null) {
+          return /*#__PURE__*/React__default["default"].createElement(loading);
+        }
+
+        var _this$props = this.props,
+            matchID = _this$props.matchID,
+            playerID = _this$props.playerID,
+            rest = Debug._objectWithoutProperties(_this$props, _excluded);
+
+        if (board) {
+          _board = /*#__PURE__*/React__default["default"].createElement(board, Debug._objectSpread2(Debug._objectSpread2(Debug._objectSpread2({}, state), rest), {}, {
+            matchID: matchID,
+            playerID: playerID,
+            isMultiplayer: !!multiplayer,
+            moves: this.client.moves,
+            events: this.client.events,
+            step: this.client.step,
+            reset: this.client.reset,
+            undo: this.client.undo,
+            redo: this.client.redo,
+            matchData: this.client.matchData,
+            sendChatMessage: this.client.sendChatMessage,
+            chatMessages: this.client.chatMessages
+          }));
+        }
+
+        return _board;
+      }
+    }]);
+
+    return WrappedBoard;
+  }(React__default["default"].Component), Debug._defineProperty(_class, "propTypes", {
+    // The ID of a game to connect to.
+    // Only relevant in multiplayer.
+    matchID: PropTypes__default["default"].string,
+    // The ID of the player associated with this client.
+    // Only relevant in multiplayer.
+    playerID: PropTypes__default["default"].string,
+    // This client's authentication credentials.
+    // Only relevant in multiplayer.
+    credentials: PropTypes__default["default"].string
+  }), Debug._defineProperty(_class, "defaultProps", {
+    matchID: 'default',
+    playerID: null,
+    credentials: null
+  }), _temp;
+}
+
+exports.Client = Client;