@mnbroatch/boardgame.io 0.0.1

package/dist/cjs/ai-e0e8a768.js

@@ -0,0 +1,377 @@
+'use strict';
+
+require('setimmediate');
+var reducer = require('./reducer-16eec232.js');
+var turnOrder = require('./turn-order-b2ff8740.js');
+var pluginRandom = require('./plugin-random-7425844d.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.
+ */
+/**
+ * Base class that bots can extend.
+ */
+class Bot {
+    constructor({ enumerate, seed, }) {
+        this.enumerateFn = enumerate;
+        this.seed = seed;
+        this.iterationCounter = 0;
+        this._opts = {};
+    }
+    addOpt({ key, range, initial, }) {
+        this._opts[key] = {
+            range,
+            value: initial,
+        };
+    }
+    getOpt(key) {
+        return this._opts[key].value;
+    }
+    setOpt(key, value) {
+        if (key in this._opts) {
+            this._opts[key].value = value;
+        }
+    }
+    opts() {
+        return this._opts;
+    }
+    enumerate(G, ctx, playerID) {
+        const actions = this.enumerateFn(G, ctx, playerID);
+        return actions.map((a) => {
+            if ('payload' in a) {
+                return a;
+            }
+            if ('move' in a) {
+                return turnOrder.makeMove(a.move, a.args, playerID);
+            }
+            if ('event' in a) {
+                return turnOrder.gameEvent(a.event, a.args, playerID);
+            }
+        });
+    }
+    random(arg) {
+        let number;
+        if (this.seed !== undefined) {
+            const seed = this.prngstate ? '' : this.seed;
+            const rand = pluginRandom.alea(seed, this.prngstate);
+            number = rand();
+            this.prngstate = rand.state();
+        }
+        else {
+            number = Math.random();
+        }
+        if (arg) {
+            if (Array.isArray(arg)) {
+                const id = Math.floor(number * arg.length);
+                return arg[id];
+            }
+            else {
+                return Math.floor(number * arg);
+            }
+        }
+        return number;
+    }
+}
+
+/*
+ * 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.
+ */
+/**
+ * The number of iterations to run before yielding to
+ * the JS event loop (in async mode).
+ */
+const CHUNK_SIZE = 25;
+/**
+ * Bot that uses Monte-Carlo Tree Search to find promising moves.
+ */
+class MCTSBot extends Bot {
+    constructor({ enumerate, seed, objectives, game, iterations, playoutDepth, iterationCallback, }) {
+        super({ enumerate, seed });
+        if (objectives === undefined) {
+            objectives = () => ({});
+        }
+        this.objectives = objectives;
+        this.iterationCallback = iterationCallback || (() => { });
+        this.reducer = reducer.CreateGameReducer({ game });
+        this.iterations = iterations;
+        this.playoutDepth = playoutDepth;
+        this.addOpt({
+            key: 'async',
+            initial: false,
+        });
+        this.addOpt({
+            key: 'iterations',
+            initial: typeof iterations === 'number' ? iterations : 1000,
+            range: { min: 1, max: 2000 },
+        });
+        this.addOpt({
+            key: 'playoutDepth',
+            initial: typeof playoutDepth === 'number' ? playoutDepth : 50,
+            range: { min: 1, max: 100 },
+        });
+    }
+    createNode({ state, parentAction, parent, playerID, }) {
+        const { G, ctx } = state;
+        let actions = [];
+        let objectives = [];
+        if (playerID !== undefined) {
+            actions = this.enumerate(G, ctx, playerID);
+            objectives = this.objectives(G, ctx, playerID);
+        }
+        else if (ctx.activePlayers) {
+            for (const playerID in ctx.activePlayers) {
+                actions.push(...this.enumerate(G, ctx, playerID));
+                objectives.push(this.objectives(G, ctx, playerID));
+            }
+        }
+        else {
+            actions = this.enumerate(G, ctx, ctx.currentPlayer);
+            objectives = this.objectives(G, ctx, ctx.currentPlayer);
+        }
+        return {
+            state,
+            parent,
+            parentAction,
+            actions,
+            objectives,
+            children: [],
+            visits: 0,
+            value: 0,
+        };
+    }
+    select(node) {
+        // This node has unvisited children.
+        if (node.actions.length > 0) {
+            return node;
+        }
+        // This is a terminal node.
+        if (node.children.length === 0) {
+            return node;
+        }
+        let selectedChild = null;
+        let best = 0;
+        for (const child of node.children) {
+            const childVisits = child.visits + Number.EPSILON;
+            const uct = child.value / childVisits +
+                Math.sqrt((2 * Math.log(node.visits)) / childVisits);
+            if (selectedChild == null || uct > best) {
+                best = uct;
+                selectedChild = child;
+            }
+        }
+        return this.select(selectedChild);
+    }
+    expand(node) {
+        const actions = node.actions;
+        if (actions.length === 0 || node.state.ctx.gameover !== undefined) {
+            return node;
+        }
+        const id = this.random(actions.length);
+        const action = actions[id];
+        node.actions.splice(id, 1);
+        const childState = this.reducer(node.state, action);
+        const childNode = this.createNode({
+            state: childState,
+            parentAction: action,
+            parent: node,
+        });
+        node.children.push(childNode);
+        return childNode;
+    }
+    playout({ state }) {
+        let playoutDepth = this.getOpt('playoutDepth');
+        if (typeof this.playoutDepth === 'function') {
+            playoutDepth = this.playoutDepth(state.G, state.ctx);
+        }
+        for (let i = 0; i < playoutDepth && state.ctx.gameover === undefined; i++) {
+            const { G, ctx } = state;
+            let playerID = ctx.currentPlayer;
+            if (ctx.activePlayers) {
+                playerID = Object.keys(ctx.activePlayers)[0];
+            }
+            const moves = this.enumerate(G, ctx, playerID);
+            // Check if any objectives are met.
+            const objectives = this.objectives(G, ctx, playerID);
+            const score = Object.keys(objectives).reduce((score, key) => {
+                const objective = objectives[key];
+                if (objective.checker(G, ctx)) {
+                    return score + objective.weight;
+                }
+                return score;
+            }, 0);
+            // If so, stop and return the score.
+            if (score > 0) {
+                return { score };
+            }
+            if (!moves || moves.length === 0) {
+                return undefined;
+            }
+            const id = this.random(moves.length);
+            const childState = this.reducer(state, moves[id]);
+            state = childState;
+        }
+        return state.ctx.gameover;
+    }
+    backpropagate(node, result = {}) {
+        node.visits++;
+        if (result.score !== undefined) {
+            node.value += result.score;
+        }
+        if (result.draw === true) {
+            node.value += 0.5;
+        }
+        if (node.parentAction &&
+            result.winner === node.parentAction.payload.playerID) {
+            node.value++;
+        }
+        if (node.parent) {
+            this.backpropagate(node.parent, result);
+        }
+    }
+    play(state, playerID) {
+        const root = this.createNode({ state, playerID });
+        let numIterations = this.getOpt('iterations');
+        if (typeof this.iterations === 'function') {
+            numIterations = this.iterations(state.G, state.ctx);
+        }
+        const getResult = () => {
+            let selectedChild = null;
+            for (const child of root.children) {
+                if (selectedChild == null || child.visits > selectedChild.visits) {
+                    selectedChild = child;
+                }
+            }
+            const action = selectedChild && selectedChild.parentAction;
+            const metadata = root;
+            return { action, metadata };
+        };
+        return new Promise((resolve) => {
+            const iteration = () => {
+                for (let i = 0; i < CHUNK_SIZE && this.iterationCounter < numIterations; i++) {
+                    const leaf = this.select(root);
+                    const child = this.expand(leaf);
+                    const result = this.playout(child);
+                    this.backpropagate(child, result);
+                    this.iterationCounter++;
+                }
+                this.iterationCallback({
+                    iterationCounter: this.iterationCounter,
+                    numIterations,
+                    metadata: root,
+                });
+            };
+            this.iterationCounter = 0;
+            if (this.getOpt('async')) {
+                const asyncIteration = () => {
+                    if (this.iterationCounter < numIterations) {
+                        iteration();
+                        setImmediate(asyncIteration);
+                    }
+                    else {
+                        resolve(getResult());
+                    }
+                };
+                asyncIteration();
+            }
+            else {
+                while (this.iterationCounter < numIterations) {
+                    iteration();
+                }
+                resolve(getResult());
+            }
+        });
+    }
+}
+
+/*
+ * 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.
+ */
+/**
+ * Bot that picks a move at random.
+ */
+class RandomBot extends Bot {
+    play({ G, ctx }, playerID) {
+        const moves = this.enumerate(G, ctx, playerID);
+        return Promise.resolve({ action: this.random(moves) });
+    }
+}
+
+/*
+ * 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.
+ */
+/**
+ * Make a single move on the client with a bot.
+ *
+ * @param {...object} client - The game client.
+ * @param {...object} bot - The bot.
+ */
+async function Step(client, bot) {
+    const state = client.store.getState();
+    let playerID = state.ctx.currentPlayer;
+    if (state.ctx.activePlayers) {
+        playerID = Object.keys(state.ctx.activePlayers)[0];
+    }
+    const { action, metadata } = await bot.play(state, playerID);
+    if (action) {
+        const a = {
+            ...action,
+            payload: {
+                ...action.payload,
+                metadata,
+            },
+        };
+        client.store.dispatch(a);
+        return a;
+    }
+}
+/**
+ * Simulates the game till the end or a max depth.
+ *
+ * @param {...object} game - The game object.
+ * @param {...object} bots - An array of bots.
+ * @param {...object} state - The game state to start from.
+ */
+async function Simulate({ game, bots, state, depth, }) {
+    if (depth === undefined)
+        depth = 10000;
+    const reducer$1 = reducer.CreateGameReducer({ game });
+    let metadata = null;
+    let iter = 0;
+    while (state.ctx.gameover === undefined && iter < depth) {
+        let playerID = state.ctx.currentPlayer;
+        if (state.ctx.activePlayers) {
+            playerID = Object.keys(state.ctx.activePlayers)[0];
+        }
+        const bot = bots instanceof Bot ? bots : bots[playerID];
+        const t = await bot.play(state, playerID);
+        if (!t.action) {
+            break;
+        }
+        metadata = t.metadata;
+        state = reducer$1(state, t.action);
+        iter++;
+    }
+    return { state, metadata };
+}
+
+exports.Bot = Bot;
+exports.MCTSBot = MCTSBot;
+exports.RandomBot = RandomBot;
+exports.Simulate = Simulate;
+exports.Step = Step;

package/dist/cjs/ai.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ai = require('./ai-e0e8a768.js');
+require('setimmediate');
+require('./reducer-16eec232.js');
+require('./turn-order-b2ff8740.js');
+require('immer');
+require('./plugin-random-7425844d.js');
+require('lodash.isplainobject');
+require('rfc6902');
+
+
+
+exports.Bot = ai.Bot;
+exports.MCTSBot = ai.MCTSBot;
+exports.RandomBot = ai.RandomBot;
+exports.Simulate = ai.Simulate;
+exports.Step = ai.Step;

package/dist/cjs/client-76dec77b.js

@@ -0,0 +1,258 @@
+'use strict';
+
+const assertString = (str, label) => {
+    if (!str || typeof str !== 'string') {
+        throw new Error(`Expected ${label} string, got "${str}".`);
+    }
+};
+const assertGameName = (name) => assertString(name, 'game name');
+const assertMatchID = (id) => assertString(id, 'match ID');
+const validateBody = (body, schema) => {
+    if (!body)
+        throw new Error(`Expected body, got “${body}”.`);
+    for (const key in schema) {
+        const propSchema = schema[key];
+        const types = Array.isArray(propSchema) ? propSchema : [propSchema];
+        const received = body[key];
+        if (!types.includes(typeof received)) {
+            const union = types.join('|');
+            throw new TypeError(`Expected body.${key} to be of type ${union}, got “${received}”.`);
+        }
+    }
+};
+class LobbyClientError extends Error {
+    constructor(message, details) {
+        super(message);
+        this.details = details;
+    }
+}
+/**
+ * Create a boardgame.io Lobby API client.
+ * @param server The API’s base URL, e.g. `http://localhost:8000`.
+ */
+class LobbyClient {
+    constructor({ server = '' } = {}) {
+        // strip trailing slash if passed
+        this.server = server.replace(/\/$/, '');
+    }
+    async request(route, init) {
+        const response = await fetch(this.server + route, init);
+        if (!response.ok) {
+            let details;
+            try {
+                details = await response.clone().json();
+            }
+            catch {
+                try {
+                    details = await response.text();
+                }
+                catch (error) {
+                    details = error.message;
+                }
+            }
+            throw new LobbyClientError(`HTTP status ${response.status}`, details);
+        }
+        return response.json();
+    }
+    async post(route, opts) {
+        let init = {
+            method: 'post',
+            body: JSON.stringify(opts.body),
+            headers: { 'Content-Type': 'application/json' },
+        };
+        if (opts.init)
+            init = {
+                ...init,
+                ...opts.init,
+                headers: { ...init.headers, ...opts.init.headers },
+            };
+        return this.request(route, init);
+    }
+    /**
+     * Get a list of the game names available on this server.
+     * @param  init Optional RequestInit interface to override defaults.
+     * @return Array of game names.
+     *
+     * @example
+     * lobbyClient.listGames()
+     *   .then(console.log); // => ['chess', 'tic-tac-toe']
+     */
+    async listGames(init) {
+        return this.request('/games', init);
+    }
+    /**
+     * Get a list of the matches for a specific game type on the server.
+     * @param  gameName The game to list for, e.g. 'tic-tac-toe'.
+     * @param  where    Options to filter matches by update time or gameover state
+     * @param  init     Optional RequestInit interface to override defaults.
+     * @return Array of match metadata objects.
+     *
+     * @example
+     * lobbyClient.listMatches('tic-tac-toe', where: { isGameover: false })
+     *   .then(data => console.log(data.matches));
+     * // => [
+     * //   {
+     * //     matchID: 'xyz',
+     * //     gameName: 'tic-tac-toe',
+     * //     players: [{ id: 0, name: 'Alice' }, { id: 1 }]
+     * //   },
+     * //   ...
+     * // ]
+     */
+    async listMatches(gameName, where, init) {
+        assertGameName(gameName);
+        let query = '';
+        if (where) {
+            const queries = [];
+            const { isGameover, updatedBefore, updatedAfter } = where;
+            if (isGameover !== undefined)
+                queries.push(`isGameover=${isGameover}`);
+            if (updatedBefore)
+                queries.push(`updatedBefore=${updatedBefore}`);
+            if (updatedAfter)
+                queries.push(`updatedAfter=${updatedAfter}`);
+            if (queries.length > 0)
+                query = '?' + queries.join('&');
+        }
+        return this.request(`/games/${gameName}${query}`, init);
+    }
+    /**
+     * Get metadata for a specific match.
+     * @param  gameName The match’s game type, e.g. 'tic-tac-toe'.
+     * @param  matchID  Match ID for the match to fetch.
+     * @param  init     Optional RequestInit interface to override defaults.
+     * @return A match metadata object.
+     *
+     * @example
+     * lobbyClient.getMatch('tic-tac-toe', 'xyz').then(console.log);
+     * // => {
+     * //   matchID: 'xyz',
+     * //   gameName: 'tic-tac-toe',
+     * //   players: [{ id: 0, name: 'Alice' }, { id: 1 }]
+     * // }
+     */
+    async getMatch(gameName, matchID, init) {
+        assertGameName(gameName);
+        assertMatchID(matchID);
+        return this.request(`/games/${gameName}/${matchID}`, init);
+    }
+    /**
+     * Create a new match for a specific game type.
+     * @param  gameName The game to create a match for, e.g. 'tic-tac-toe'.
+     * @param  body     Options required to configure match creation.
+     * @param  init     Optional RequestInit interface to override defaults.
+     * @return An object containing the created `matchID`.
+     *
+     * @example
+     * lobbyClient.createMatch('tic-tac-toe', { numPlayers: 2 })
+     *   .then(console.log);
+     * // => { matchID: 'xyz' }
+     */
+    async createMatch(gameName, body, init) {
+        assertGameName(gameName);
+        validateBody(body, { numPlayers: 'number' });
+        return this.post(`/games/${gameName}/create`, { body, init });
+    }
+    /**
+     * Join a match using its matchID.
+     * @param  gameName The match’s game type, e.g. 'tic-tac-toe'.
+     * @param  matchID  Match ID for the match to join.
+     * @param  body     Options required to join match.
+     * @param  init     Optional RequestInit interface to override defaults.
+     * @return Object containing `playerCredentials` for the player who joined.
+     *
+     * @example
+     * lobbyClient.joinMatch('tic-tac-toe', 'xyz', {
+     *   playerID: '1',
+     *   playerName: 'Bob',
+     * }).then(console.log);
+     * // => { playerID: '1', playerCredentials: 'random-string' }
+     */
+    async joinMatch(gameName, matchID, body, init) {
+        assertGameName(gameName);
+        assertMatchID(matchID);
+        validateBody(body, {
+            playerID: ['string', 'undefined'],
+            playerName: 'string',
+        });
+        return this.post(`/games/${gameName}/${matchID}/join`, { body, init });
+    }
+    /**
+     * Leave a previously joined match.
+     * @param  gameName The match’s game type, e.g. 'tic-tac-toe'.
+     * @param  matchID  Match ID for the match to leave.
+     * @param  body     Options required to leave match.
+     * @param  init     Optional RequestInit interface to override defaults.
+     * @return Promise resolves if successful.
+     *
+     * @example
+     * lobbyClient.leaveMatch('tic-tac-toe', 'xyz', {
+     *   playerID: '1',
+     *   credentials: 'credentials-returned-when-joining',
+     * })
+     *   .then(() => console.log('Left match.'))
+     *   .catch(error => console.error('Error leaving match', error));
+     */
+    async leaveMatch(gameName, matchID, body, init) {
+        assertGameName(gameName);
+        assertMatchID(matchID);
+        validateBody(body, { playerID: 'string', credentials: 'string' });
+        await this.post(`/games/${gameName}/${matchID}/leave`, { body, init });
+    }
+    /**
+     * Update a player’s name or custom metadata.
+     * @param  gameName The match’s game type, e.g. 'tic-tac-toe'.
+     * @param  matchID  Match ID for the match to update.
+     * @param  body     Options required to update player.
+     * @param  init     Optional RequestInit interface to override defaults.
+     * @return Promise resolves if successful.
+     *
+     * @example
+     * lobbyClient.updatePlayer('tic-tac-toe', 'xyz', {
+     *   playerID: '0',
+     *   credentials: 'credentials-returned-when-joining',
+     *   newName: 'Al',
+     * })
+     *   .then(() => console.log('Updated player data.'))
+     *   .catch(error => console.error('Error updating data', error));
+     */
+    async updatePlayer(gameName, matchID, body, init) {
+        assertGameName(gameName);
+        assertMatchID(matchID);
+        validateBody(body, { playerID: 'string', credentials: 'string' });
+        await this.post(`/games/${gameName}/${matchID}/update`, { body, init });
+    }
+    /**
+     * Create a new match based on the configuration of the current match.
+     * @param  gameName The match’s game type, e.g. 'tic-tac-toe'.
+     * @param  matchID  Match ID for the match to play again.
+     * @param  body     Options required to configure match.
+     * @param  init     Optional RequestInit interface to override defaults.
+     * @return Object containing `nextMatchID`.
+     *
+     * @example
+     * lobbyClient.playAgain('tic-tac-toe', 'xyz', {
+     *   playerID: '0',
+     *   credentials: 'credentials-returned-when-joining',
+     * })
+     *   .then(({ nextMatchID }) => {
+     *     return lobbyClient.joinMatch('tic-tac-toe', nextMatchID, {
+     *       playerID: '0',
+     *       playerName: 'Al',
+     *     })
+     *   })
+     *   .then({ playerCredentials } => {
+     *     console.log(playerCredentials);
+     *   })
+     *   .catch(console.error);
+     */
+    async playAgain(gameName, matchID, body, init) {
+        assertGameName(gameName);
+        assertMatchID(matchID);
+        validateBody(body, { playerID: 'string', credentials: 'string' });
+        return this.post(`/games/${gameName}/${matchID}/playAgain`, { body, init });
+    }
+}
+
+exports.LobbyClient = LobbyClient;
+exports.LobbyClientError = LobbyClientError;