@gamepark/react-client 6.38.5 → 7.0.0-beta.0

package/dist/Store/gameReducer.js

@@ -1,526 +1,539 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.replayAction = exports.replayActions = exports.getGameAfterAnimations = exports.gameReducer = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var assert_1 = __importDefault(require("assert"));
-var immer_1 = __importStar(require("immer"));
-var isEqual_1 = __importDefault(require("lodash/isEqual"));
-var uniqueId_1 = __importDefault(require("lodash/uniqueId"));
-var Actions_1 = require("../Actions");
-var PlayerQuit_1 = require("../Actions/PlayerQuit");
-var animations_1 = require("../animations");
-var Failure_1 = require("../Failure");
-var GiveUp_1 = require("../GiveUp");
-var Log_1 = require("../Log");
-var Sound_1 = require("../Sound");
-var Types_1 = require("../Types");
-var ArrayUtil_1 = require("../util/ArrayUtil");
-var DisplayedAction_1 = require("./DisplayedAction");
-function gameReducer(context) {
-    var _a;
-    var GameRules = context.Rules;
-    var animations = (_a = context.animations) !== null && _a !== void 0 ? _a : new animations_1.Animations();
-    var initialState = {
-        players: [], pendingNotifications: [], nextNotificationIndex: 0, legalMoves: [], failures: [],
-        animationIncrement: 0, animationsSpeed: 1, animationPaused: false,
-        soundsMuted: (0, Sound_1.soundsMuted)(), clientTimeDelta: 0, liveLogStopped: false
-    };
-    return function (state, event) {
-        if (state === void 0) { state = initialState; }
-        switch (event.type) {
-            case Actions_1.GAME_STATE_LOADED:
-                return (0, immer_1.default)(state, function (draft) {
-                    if (event.serverTime) {
-                        draft.clientTimeDelta = approximateTimeDelta(event.serverTime, draft.clientTimeDelta);
-                    }
-                    draft.players = event.players;
-                    draft.options = event.options;
-                    draft.playerId = event.playerId;
-                    draft.state = event.state;
-                    if (event.playerId !== undefined) {
-                        draft.legalMoves = (0, immer_1.castDraft)(new GameRules(event.state).getLegalMoves(event.playerId));
-                    }
-                    draft.setup = event.setup;
-                    draft.gameOver = !!event.endDate;
-                    draft.gameMode = event.mode;
-                    draft.tournament = event.tournament;
-                    draft.nextNotificationIndex = event.notifications.length;
-                    if (!event.endDate) {
-                        draft.client = { player: event.playerId };
-                    }
-                    setActionsFromPastNotifications(draft, event.notifications);
-                });
-            case Actions_1.GAME_NOTIFICATIONS_RECEIVED:
-                return (0, immer_1.default)(state, function (draft) {
-                    if (event.serverTime) {
-                        draft.clientTimeDelta = approximateTimeDelta(event.serverTime, draft.clientTimeDelta);
-                    }
-                    draft.players.forEach(function (player) {
-                        var _a;
-                        var newPlayerTime = (_a = event.players.find(function (p) { return p.id === player.id; })) === null || _a === void 0 ? void 0 : _a.time;
-                        player.time = newPlayerTime || player.time;
-                    });
-                    if (event.notificationsIndex == 0 && !draft.actions) {
-                        setActionsFromPastNotifications(draft, event.notifications);
-                    }
-                    for (var i = Math.max(draft.nextNotificationIndex - event.notificationsIndex, 0); i < event.notifications.length; i++) {
-                        draft.pendingNotifications.push(__assign(__assign({}, event.notifications[i]), { index: i + event.notificationsIndex }));
-                    }
-                    draft.pendingNotifications.sort(function (n1, n2) { return n1.index - n2.index; });
-                    if (draft.state) {
-                        applyPendingNotifications(draft);
-                    }
-                });
-            case Actions_1.ActionType.MOVE_PLAYED:
-                return (0, immer_1.default)(state, function (draft) {
-                    var _a;
-                    if (!draft.state)
-                        throw new Error('Cannot play move before game state is loaded');
-                    if (!draft.actions)
-                        throw new Error('Cannot play move before game history is loaded');
-                    var transient = event.transient;
-                    var local = (_a = event.local) !== null && _a !== void 0 ? _a : transient;
-                    if (state.playerId === undefined && !local)
-                        throw new Error('Spectators cannot play');
-                    var action = {
-                        id: 'local-' + (0, uniqueId_1.default)(),
-                        playerId: state.playerId,
-                        move: event.move,
-                        consequences: [],
-                        played: 0,
-                        pending: !local,
-                        local: local,
-                        transient: transient
-                    };
-                    var rules = getGameAfterAnimations(draft, GameRules);
-                    var isUnpredictable = function (move) { return (0, rules_api_1.hasUnpredictableMoves)(rules) && rules.isUnpredictableMove(move, action.playerId); };
-                    if (!local && (event.delayed || isUnpredictable(event.move))) {
-                        action.delayed = true;
-                    }
-                    else {
-                        action.consequences = [];
-                        var pendingMoves_1 = rules.play(JSON.parse(JSON.stringify(event.move)), { local: local, transient: transient });
-                        (0, rules_api_1.loopWithFuse)(function () {
-                            var move = pendingMoves_1.shift();
-                            if (!move || isUnpredictable(move))
-                                return false;
-                            action.consequences.push(move);
-                            pendingMoves_1.unshift.apply(pendingMoves_1, rules.play(JSON.parse(JSON.stringify(move)), { local: local, transient: transient }));
-                            return true;
-                        }, { errorFn: function () { return new Error("Infinite loop detected while applying move consequences: ".concat(JSON.stringify(action), ")")); } });
-                        if (event.skipAnimation) {
-                            playNextMove(action, draft);
-                        }
-                        else {
-                            animatePlayedAction(action, draft);
-                        }
-                    }
-                    if (!transient || action.animation) {
-                        draft.actions.push(action);
-                    }
-                });
-            case Actions_1.MOVE_UNDONE:
-                return (0, immer_1.default)(state, function (draft) {
-                    if (!state.actions || !draft.actions || !state.setup || !state.state) {
-                        return console.error('Cannot undo before actions history is loaded');
-                    }
-                    var action = (0, ArrayUtil_1.findLastItem)(draft.actions, function (action) { return action.id === event.actionId; });
-                    if (!action)
-                        return console.error("Could not find action to undo with this id: ".concat(event.actionId));
-                    if (!action.local && state.playerId === undefined) {
-                        return console.error('Spectators cannot undo moves');
-                    }
-                    action.cancelled = true;
-                    if (!action.local) {
-                        action.cancelPending = true;
-                    }
-                    if (!action.local && (event.delayed || !new GameRules(state.state, state.client).isTurnToPlay(state.playerId))) {
-                        action.delayed = true;
-                    }
-                    else {
-                        animateUndoneAction(action, draft);
-                    }
-                });
-            case Actions_1.ACTION_FAILED:
-                return (0, immer_1.default)(state, function (draft) {
-                    if (draft.actions) {
-                        switch (event.reason) {
-                            case Failure_1.Failure.UNDO_FORBIDDEN:
-                                for (var _i = 0, _a = draft.actions; _i < _a.length; _i++) {
-                                    var action = _a[_i];
-                                    if (action.cancelPending) {
-                                        action.cancelled = false;
-                                        action.cancelPending = false;
-                                    }
-                                }
-                                break;
-                            default:
-                                draft.actions = draft.actions.filter(function (action) { return !action.pending; });
-                                var rules = new GameRules(JSON.parse(JSON.stringify(draft.setup)), state.client);
-                                replayActions(rules, draft.actions, state.state);
-                                draft.state = rules.game;
-                        }
-                    }
-                    draft.failures.push(event.reason);
-                });
-            case Actions_1.CLEAR_FAILURES:
-                return (0, immer_1.default)(state, function (draft) {
-                    draft.failures = [];
-                });
-            case Actions_1.ANIMATION_START:
-                return (0, immer_1.default)(state, function (draft) {
-                    if (!draft.actions)
-                        return;
-                    var action = draft.actions.find(function (action) { return action.id === event.actionId; });
-                    if (action) {
-                        animateAction(action, draft);
-                    }
-                });
-            case Actions_1.ANIMATION_COMPLETE:
-                return (0, immer_1.default)(state, function (draft) {
-                    var _a;
-                    if (draft.actions) {
-                        var action = draft.actions.find(function (action) { var _a; return ((_a = action.animation) === null || _a === void 0 ? void 0 : _a.id) === event.animationId; });
-                        if (!action) {
-                            return console.error('ANIMATION_COMPLETE event received but not animation found with provided id');
-                        }
-                        var step = (_a = action.animation) === null || _a === void 0 ? void 0 : _a.step;
-                        if (action.transient) {
-                            draft.actions.splice(draft.actions.indexOf(action), 1);
-                        }
-                        else {
-                            delete action.animation;
-                        }
-                        if (step === animations_1.AnimationStep.BEFORE_MOVE) {
-                            playNextMove(action, draft);
-                        }
-                        else if (step === animations_1.AnimationStep.BEFORE_UNDO) {
-                            undoNextMove(action, draft);
-                        }
-                        else {
-                            refreshLegalMoves(draft);
-                        }
-                    }
-                });
-            case Actions_1.ANIMATION_PAUSED:
-                return (0, immer_1.default)(state, function (draft) {
-                    draft.animationPaused = event.pause;
-                });
-            case Actions_1.SET_ANIMATIONS_SPEED:
-                return __assign(__assign({}, state), { animationsSpeed: event.speed });
-            case GiveUp_1.GIVE_UP:
-                return __assign(__assign({}, state), { playerId: undefined });
-            case Sound_1.MUTE_SOUNDS:
-                return __assign(__assign({}, state), { soundsMuted: true });
-            case Sound_1.UNMUTE_SOUNDS:
-                return __assign(__assign({}, state), { soundsMuted: false });
-            case Log_1.START_LIVE_LOG:
-                return __assign(__assign({}, state), { liveLogStopped: false });
-            case Log_1.STOP_LIVE_LOG:
-                return __assign(__assign({}, state), { liveLogStopped: true });
-            case PlayerQuit_1.PLAYER_QUIT:
-                return (0, immer_1.default)(state, function (draft) {
-                    var player = draft.players.find(function (p) { return p.id === event.playerId; });
-                    if (player) {
-                        player.quit = true;
-                        player.quitReason = event.reason;
-                    }
-                    if (draft.playerId === event.playerId) {
-                        delete draft.playerId;
-                    }
-                });
-            case Actions_1.GAME_OVER:
-                return __assign(__assign({}, state), { gameOver: true, players: state.players.map(function (player) {
-                        var _a;
-                        var p = event.players.find(function (p) { return p.id === player.id; });
-                        if (!p)
-                            return player;
-                        else
-                            return (__assign(__assign({}, player), { time: (_a = p.time) !== null && _a !== void 0 ? _a : player.time, gamePointsDelta: p.gamePointsDelta, tournamentPoints: p.tournamentPoints }));
-                    }) });
-        }
-        return state;
-    };
-    function playNextMove(action, draft) {
-        var consequenceIndex = action.played === 0 ? undefined : action.played - 1;
-        var move = consequenceIndex === undefined ? action.move : action.consequences[consequenceIndex];
-        var rules = new GameRules(draft.state, draft.client);
-        rules.play(JSON.parse(JSON.stringify(move)), { local: action.local, transient: action.transient });
-        action.played++;
-        if (!action.local && !action.transient && !action.pending) {
-            draft.playedMoves.push({ actionId: action.id, move: move, consequenceIndex: consequenceIndex });
-        }
-        animatePlayedAction(action, draft, animations_1.AnimationStep.AFTER_MOVE);
-    }
-    function undoNextMove(action, draft) {
-        var rules = new GameRules(JSON.parse(JSON.stringify(draft.setup)), draft.client);
-        action.played--;
-        var actionsPlayed = draft.actions.filter(function (action) { return action.played > 0; })
-            .map(function (action) { return (__assign(__assign({}, action), { consequences: action.consequences.slice(0, action.played - 1) })); });
-        replayActions(rules, actionsPlayed, draft.state);
-        draft.state = rules.game;
-        animateUndoneAction(action, draft, animations_1.AnimationStep.AFTER_UNDO);
-    }
-    function setActionsFromPastNotifications(draft, notifications) {
-        var _a;
-        draft.actions = [];
-        draft.playedMoves = [];
-        var _loop_1 = function (i) {
-            var notification = notifications[i];
-            if ((0, Types_1.isMovePlayedNotification)(notification)) {
-                var action = {
-                    id: (_a = notification.actionId) !== null && _a !== void 0 ? _a : undefined,
-                    playerId: notification.playerId, move: notification.moveView,
-                    consequences: notification.consequences,
-                    played: 1 + notification.consequences.length
-                };
-                draft.actions.push(action);
-                draft.playedMoves.push({ actionId: action.id, move: action.move });
-                for (var consequenceIndex = 0; consequenceIndex < action.consequences.length; consequenceIndex++) {
-                    var consequence = action.consequences[consequenceIndex];
-                    draft.playedMoves.push({ actionId: action.id, move: consequence, consequenceIndex: consequenceIndex });
-                }
-            }
-            else if ((0, Types_1.isMoveUndoneNotification)(notification)) {
-                var index = notification.actionId ? (0, ArrayUtil_1.findLastIndex)(draft.actions, function (action) { return action.id === notification.actionId; }) : notification.moveUndone;
-                if (index !== -1) {
-                    draft.actions.splice(index, 1);
-                }
-                draft.playedMoves = draft.playedMoves.filter(function (playedMove) { return playedMove.actionId !== notification.actionId; });
-            }
-        };
-        for (var i = 0; i < draft.nextNotificationIndex; i++) {
-            _loop_1(i);
-        }
-    }
-    function applyPendingNotifications(draft) {
-        if (!draft.actions) {
-            return;
-        }
-        while (draft.pendingNotifications.length && draft.pendingNotifications[0].index <= draft.nextNotificationIndex) {
-            var notification = draft.pendingNotifications.shift();
-            if (notification.index < draft.nextNotificationIndex) {
-                console.info('A notification was received twice: ' + JSON.stringify(notification));
-            }
-            else {
-                draft.nextNotificationIndex++;
-                applyNotification(draft, notification);
-            }
-        }
-    }
-    function applyNotification(draft, notification) {
-        if ((0, Types_1.isMovePlayedNotification)(notification)) {
-            applyMovePlayedNotification(draft, notification);
-        }
-        else if ((0, Types_1.isMoveUndoneNotification)(notification)) {
-            applyMoveUndoneNotification(draft, notification);
-        }
-    }
-    function applyMovePlayedNotification(draft, notification) {
-        var _a;
-        var _b, _c;
-        (0, assert_1.default)(draft.actions !== undefined, 'Cannot apply a notification before action history is loaded');
-        var action;
-        if (notification.playerId == draft.playerId) {
-            action = draft.actions.find(function (action) { return action.pending && action.playerId == notification.playerId; });
-        }
-        if (action) {
-            action.id = (_b = notification.actionId) !== null && _b !== void 0 ? _b : undefined;
-            action.pending = false;
-            if (action.delayed) {
-                action.move = notification.moveView;
-                action.consequences = notification.consequences;
-                delete action.delayed;
-            }
-            else {
-                if (action.played !== 0) {
-                    draft.playedMoves.push({ actionId: action.id, move: action.move });
-                    for (var consequenceIndex = 0; consequenceIndex < action.played - 1; consequenceIndex++) {
-                        var consequence = action.consequences[consequenceIndex];
-                        draft.playedMoves.push({ actionId: action.id, move: consequence, consequenceIndex: consequenceIndex });
-                    }
-                }
-                if (!(0, isEqual_1.default)(JSON.parse(JSON.stringify(action.move)), JSON.parse(JSON.stringify(notification.moveView)))) {
-                    var rules = new GameRules(draft.state);
-                    if ((0, rules_api_1.hasUnpredictableMoves)(rules) && rules.canIgnoreServerDifference
-                        && rules.canIgnoreServerDifference(action.move, notification.moveView)) {
-                        action.move = notification.moveView;
-                    }
-                    else {
-                        console.error('An action was played and executed immediately:', JSON.parse(JSON.stringify(action.move)), ', but the notifications does not contain the same data:', JSON.parse(JSON.stringify(notification.moveView)), '(use the "delayed" parameter to postpone execution if the outcome cannot be anticipated).');
-                    }
-                }
-                if (action.consequences.length > notification.consequences.length) {
-                    console.error('The server returned less consequences that what was played locally:', action.consequences, notification.consequences);
-                }
-                else {
-                    for (var i = 0; i < action.consequences.length; i++) {
-                        if (!(0, isEqual_1.default)(JSON.parse(JSON.stringify(action.consequences[i])), JSON.parse(JSON.stringify(notification.consequences[i])))) {
-                            var rules = new GameRules(draft.state);
-                            if ((0, rules_api_1.hasUnpredictableMoves)(rules) && rules.canIgnoreServerDifference
-                                && rules.canIgnoreServerDifference(action.consequences[i], notification.consequences[i])) {
-                                action.consequences[i] = notification.consequences[i];
-                            }
-                            else {
-                                console.error("Consequence #".concat(i, " was played on the client, but the server returned a different consequence:"), JSON.parse(JSON.stringify(action.consequences[i])), notification.consequences[i]);
-                            }
-                        }
-                    }
-                    (_a = action.consequences).push.apply(_a, notification.consequences.slice(action.consequences.length));
-                }
-            }
-        }
-        else {
-            draft.actions.splice((0, ArrayUtil_1.findLastIndex)(draft.actions, function (action) { return !action.pending; }) + 1, 0, {
-                id: (_c = notification.actionId) !== null && _c !== void 0 ? _c : undefined,
-                playerId: notification.playerId,
-                move: notification.moveView,
-                consequences: notification.consequences,
-                played: 0
-            });
-        }
-    }
-    function applyMoveUndoneNotification(draft, notification) {
-        (0, assert_1.default)(draft.actions !== undefined, 'Cannot apply a notification before action history is loaded');
-        var index = (0, ArrayUtil_1.findLastIndex)(draft.actions, function (action) { return action.id === notification.actionId; });
-        if (index === -1)
-            return console.error("Received move undone notification, but action ".concat(notification.actionId, " is unknown"));
-        var cancelledAction = draft.actions[index];
-        if (!cancelledAction.played && !cancelledAction.animation) {
-            draft.actions.splice(index, 1);
-        }
-        else {
-            cancelledAction.cancelled = true;
-            delete cancelledAction.cancelPending;
-            delete cancelledAction.delayed;
-        }
-        draft.playedMoves = draft.playedMoves.filter(function (move) { return move.actionId !== notification.actionId; });
-    }
-    function animateAction(action, draft) {
-        if (!action.cancelled) {
-            animatePlayedAction(action, draft);
-        }
-        else {
-            animateUndoneAction(action, draft);
-        }
-    }
-    function animatePlayedAction(action, draft, step) {
-        if (step === void 0) { step = animations_1.AnimationStep.BEFORE_MOVE; }
-        if (action.activePlayers === undefined) {
-            var rules_1 = new GameRules(draft.state, draft.client);
-            action.activePlayers = draft.players.map(function (p) { return p.id; }).filter(function (p) { return rules_1.isTurnToPlay(p); });
-        }
-        var move = (0, DisplayedAction_1.getAnimatedMove)(action, step);
-        var duration = animations.getDuration(move, getAnimationContext(action, draft, step)) / draft.animationsSpeed;
-        if (duration > 0) {
-            action.animation = { id: draft.animationIncrement++, duration: duration, step: step };
-        }
-        else if (step === animations_1.AnimationStep.BEFORE_MOVE) {
-            playNextMove(action, draft);
-        }
-        else if (action.played <= action.consequences.length && !draft.animationPaused) {
-            animatePlayedAction(action, draft);
-        }
-        else {
-            refreshLegalMoves(draft);
-        }
-    }
-    function refreshLegalMoves(draft) {
-        if (draft.playerId !== undefined) {
-            var rules = new GameRules(draft.state, draft.client);
-            draft.legalMoves = (0, immer_1.castDraft)(rules.getLegalMoves(draft.playerId));
-        }
-    }
-    function animateUndoneAction(action, draft, step) {
-        if (step === void 0) { step = animations_1.AnimationStep.BEFORE_UNDO; }
-        var move = (0, DisplayedAction_1.getAnimatedMove)(action, step);
-        var duration = animations.getDuration(move, getAnimationContext(action, draft, step)) / draft.animationsSpeed;
-        if (duration > 0) {
-            action.animation = { id: draft.animationIncrement++, duration: duration, step: step };
-        }
-        else if (step === animations_1.AnimationStep.BEFORE_UNDO) {
-            undoNextMove(action, draft);
-        }
-        else if (action.played > 0) {
-            animateUndoneAction(action, draft);
-        }
-        else {
-            refreshLegalMoves(draft);
-            if (!action.cancelPending) {
-                draft.actions.splice(draft.actions.indexOf(action), 1);
-            }
-        }
-    }
-    function getAnimationContext(action, draft, step) {
-        return __assign(__assign({}, context), { action: action, game: draft.state, playerId: draft.playerId, step: step });
-    }
-}
-exports.gameReducer = gameReducer;
-function getGameAfterAnimations(state, Rules) {
-    if (!state.actions || !state.setup) {
-        throw new Error('Cannot play move before game history is loaded');
-    }
-    if (state.actions.some(function (action) { return action.animation || action.cancelled; })) {
-        var rules_2 = new Rules(JSON.parse(JSON.stringify(state.setup)), state.client);
-        var actionsToReplay = state.actions.filter(function (action) { return !action.delayed && !action.cancelled; });
-        actionsToReplay.forEach(function (action) { return replayAction(rules_2, action); });
-        return rules_2;
-    }
-    else {
-        return new Rules(JSON.parse(JSON.stringify(state.state)), { player: state.playerId });
-    }
-}
-exports.getGameAfterAnimations = getGameAfterAnimations;
-var estimatedLatency = 100;
-function approximateTimeDelta(serverTime, clientTimeDelta) {
-    return Math.min(serverTime + estimatedLatency - new Date().getTime(), clientTimeDelta || Infinity);
-}
-function replayActions(rules, actions, previousState) {
-    actions.forEach(function (action) { return replayAction(rules, action); });
-    if ((0, rules_api_1.hasUndo)(rules) && rules.restoreTransientState)
-        rules.restoreTransientState(previousState);
-}
-exports.replayActions = replayActions;
-function replayAction(rules, action) {
-    rules.play(JSON.parse(JSON.stringify(action.move)), { local: action.local, transient: action.transient });
-    action.consequences.forEach(function (move) { return rules.play(JSON.parse(JSON.stringify(move)), { local: action.local, transient: action.transient }); });
-}
-exports.replayAction = replayAction;
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gameReducer = gameReducer;
+exports.getGameAfterAnimations = getGameAfterAnimations;
+exports.replayActions = replayActions;
+exports.replayAction = replayAction;
+exports.isGameAction = isGameAction;
+var rules_api_1 = require("@gamepark/rules-api");
+var assert_1 = __importDefault(require("assert"));
+var es_toolkit_1 = require("es-toolkit");
+var compat_1 = require("es-toolkit/compat");
+var immer_1 = __importStar(require("immer"));
+var Actions_1 = require("../Actions");
+var PlayerQuit_1 = require("../Actions/PlayerQuit");
+var animations_1 = require("../animations");
+var Failure_1 = require("../Failure");
+var GiveUp_1 = require("../GiveUp");
+var Log_1 = require("../Log");
+var Sound_1 = require("../Sound");
+var Types_1 = require("../Types");
+var ArrayUtil_1 = require("../util/ArrayUtil");
+var DisplayedAction_1 = require("./DisplayedAction");
+function gameReducer(context) {
+    var _a;
+    var GameRules = context.Rules;
+    var animations = (_a = context.animations) !== null && _a !== void 0 ? _a : new animations_1.Animations();
+    var initialState = {
+        players: [], pendingNotifications: [], nextNotificationIndex: 0, legalMoves: [], failures: [],
+        animationIncrement: 0, animationsSpeed: 1, animationPaused: false,
+        soundsMuted: (0, Sound_1.soundsMuted)(), clientTimeDelta: 0, liveLogStopped: false
+    };
+    return function (state, event) {
+        if (state === void 0) { state = initialState; }
+        switch (event.type) {
+            case Actions_1.GAME_STATE_LOADED:
+                return (0, immer_1.default)(state, function (draft) {
+                    if (event.serverTime) {
+                        draft.clientTimeDelta = approximateTimeDelta(event.serverTime, draft.clientTimeDelta);
+                    }
+                    draft.players = event.players;
+                    draft.options = event.options;
+                    draft.playerId = event.playerId;
+                    draft.state = event.state;
+                    if (event.playerId !== undefined) {
+                        draft.legalMoves = (0, immer_1.castDraft)(new GameRules(event.state).getLegalMoves(event.playerId));
+                    }
+                    draft.setup = event.setup;
+                    draft.gameOver = !!event.endDate;
+                    draft.gameMode = event.mode;
+                    draft.tournament = event.tournament;
+                    draft.nextNotificationIndex = event.notifications.length;
+                    if (!event.endDate) {
+                        draft.client = { player: event.playerId };
+                    }
+                    setActionsFromPastNotifications(draft, event.notifications);
+                });
+            case Actions_1.GAME_NOTIFICATIONS_RECEIVED:
+                return (0, immer_1.default)(state, function (draft) {
+                    if (event.serverTime) {
+                        draft.clientTimeDelta = approximateTimeDelta(event.serverTime, draft.clientTimeDelta);
+                    }
+                    draft.players.forEach(function (player) {
+                        var _a;
+                        var newPlayerTime = (_a = event.players.find(function (p) { return p.id === player.id; })) === null || _a === void 0 ? void 0 : _a.time;
+                        player.time = newPlayerTime || player.time;
+                    });
+                    if (event.notificationsIndex == 0 && !draft.actions) {
+                        setActionsFromPastNotifications(draft, event.notifications);
+                    }
+                    for (var i = Math.max(draft.nextNotificationIndex - event.notificationsIndex, 0); i < event.notifications.length; i++) {
+                        draft.pendingNotifications.push(__assign(__assign({}, event.notifications[i]), { index: i + event.notificationsIndex }));
+                    }
+                    draft.pendingNotifications.sort(function (n1, n2) { return n1.index - n2.index; });
+                    if (draft.state) {
+                        applyPendingNotifications(draft);
+                    }
+                });
+            case Actions_1.MOVE_PLAYED:
+                return (0, immer_1.default)(state, function (draft) {
+                    var _a;
+                    if (!draft.state)
+                        throw new Error('Cannot play move before game state is loaded');
+                    if (!draft.actions)
+                        throw new Error('Cannot play move before game history is loaded');
+                    var transient = event.transient;
+                    var local = (_a = event.local) !== null && _a !== void 0 ? _a : transient;
+                    if (state.playerId === undefined && !local)
+                        throw new Error('Spectators cannot play');
+                    var action = {
+                        id: 'local-' + (0, compat_1.uniqueId)(),
+                        playerId: state.playerId,
+                        move: event.move,
+                        consequences: [],
+                        played: 0,
+                        pending: !local,
+                        local: local,
+                        transient: transient
+                    };
+                    var rules = getGameAfterAnimations(draft, GameRules);
+                    var isUnpredictable = function (move) { return (0, rules_api_1.hasUnpredictableMoves)(rules) && rules.isUnpredictableMove(move, action.playerId); };
+                    if (!local && (event.delayed || isUnpredictable(event.move))) {
+                        action.delayed = true;
+                    }
+                    else {
+                        action.consequences = [];
+                        var pendingMoves_1 = rules.play(JSON.parse(JSON.stringify(event.move)), { local: local, transient: transient });
+                        (0, rules_api_1.loopWithFuse)(function () {
+                            var move = pendingMoves_1.shift();
+                            if (!move || isUnpredictable(move))
+                                return false;
+                            action.consequences.push(move);
+                            pendingMoves_1.unshift.apply(pendingMoves_1, rules.play(JSON.parse(JSON.stringify(move)), { local: local, transient: transient }));
+                            return true;
+                        }, { errorFn: function () { return new Error("Infinite loop detected while applying move consequences: ".concat(JSON.stringify(action), ")")); } });
+                        if (event.skipAnimation) {
+                            playNextMove(action, draft);
+                        }
+                        else {
+                            animatePlayedAction(action, draft);
+                        }
+                    }
+                    if (!transient || action.animation) {
+                        draft.actions.push(action);
+                    }
+                });
+            case Actions_1.MOVE_UNDONE:
+                return (0, immer_1.default)(state, function (draft) {
+                    if (!state.actions || !draft.actions || !state.setup || !state.state) {
+                        return console.error('Cannot undo before actions history is loaded');
+                    }
+                    var action = (0, ArrayUtil_1.findLastItem)(draft.actions, function (action) { return action.id === event.actionId; });
+                    if (!action)
+                        return console.error("Could not find action to undo with this id: ".concat(event.actionId));
+                    if (!action.local && state.playerId === undefined) {
+                        return console.error('Spectators cannot undo moves');
+                    }
+                    action.cancelled = true;
+                    if (!action.local) {
+                        action.cancelPending = true;
+                    }
+                    if (!action.local && (event.delayed || !new GameRules(state.state, state.client).isTurnToPlay(state.playerId))) {
+                        action.delayed = true;
+                    }
+                    else {
+                        animateUndoneAction(action, draft);
+                    }
+                });
+            case Actions_1.ACTION_FAILED:
+                return (0, immer_1.default)(state, function (draft) {
+                    if (draft.actions) {
+                        switch (event.reason) {
+                            case Failure_1.Failure.UNDO_FORBIDDEN:
+                                for (var _i = 0, _a = draft.actions; _i < _a.length; _i++) {
+                                    var action = _a[_i];
+                                    if (action.cancelPending) {
+                                        action.cancelled = false;
+                                        action.cancelPending = false;
+                                    }
+                                }
+                                break;
+                            default:
+                                draft.actions = draft.actions.filter(function (action) { return !action.pending; });
+                                var rules = new GameRules(JSON.parse(JSON.stringify(draft.setup)), state.client);
+                                replayActions(rules, draft.actions, state.state);
+                                draft.state = rules.game;
+                        }
+                    }
+                    draft.failures.push(event.reason);
+                });
+            case Actions_1.CLEAR_FAILURES:
+                return (0, immer_1.default)(state, function (draft) {
+                    draft.failures = [];
+                });
+            case Actions_1.ANIMATION_START:
+                return (0, immer_1.default)(state, function (draft) {
+                    if (!draft.actions)
+                        return;
+                    var action = draft.actions.find(function (action) { return action.id === event.actionId; });
+                    if (action) {
+                        animateAction(action, draft);
+                    }
+                });
+            case Actions_1.ANIMATION_COMPLETE:
+                return (0, immer_1.default)(state, function (draft) {
+                    var _a;
+                    if (draft.actions) {
+                        var action = draft.actions.find(function (action) { var _a; return ((_a = action.animation) === null || _a === void 0 ? void 0 : _a.id) === event.animationId; });
+                        if (!action) {
+                            return console.error('ANIMATION_COMPLETE event received but not animation found with provided id');
+                        }
+                        var step = (_a = action.animation) === null || _a === void 0 ? void 0 : _a.step;
+                        if (action.transient) {
+                            draft.actions.splice(draft.actions.indexOf(action), 1);
+                        }
+                        else {
+                            delete action.animation;
+                        }
+                        if (step === animations_1.AnimationStep.BEFORE_MOVE) {
+                            playNextMove(action, draft);
+                        }
+                        else if (step === animations_1.AnimationStep.BEFORE_UNDO) {
+                            undoNextMove(action, draft);
+                        }
+                        else {
+                            refreshLegalMoves(draft);
+                        }
+                    }
+                });
+            case Actions_1.ANIMATION_PAUSED:
+                return (0, immer_1.default)(state, function (draft) {
+                    draft.animationPaused = event.pause;
+                });
+            case Actions_1.SET_ANIMATIONS_SPEED:
+                return __assign(__assign({}, state), { animationsSpeed: event.speed });
+            case GiveUp_1.GIVE_UP:
+                return __assign(__assign({}, state), { playerId: undefined });
+            case Sound_1.MUTE_SOUNDS:
+                return __assign(__assign({}, state), { soundsMuted: true });
+            case Sound_1.UNMUTE_SOUNDS:
+                return __assign(__assign({}, state), { soundsMuted: false });
+            case Log_1.START_LIVE_LOG:
+                return __assign(__assign({}, state), { liveLogStopped: false });
+            case Log_1.STOP_LIVE_LOG:
+                return __assign(__assign({}, state), { liveLogStopped: true });
+            case PlayerQuit_1.PLAYER_QUIT:
+                return (0, immer_1.default)(state, function (draft) {
+                    var player = draft.players.find(function (p) { return p.id === event.playerId; });
+                    if (player) {
+                        player.quit = true;
+                        player.quitReason = event.reason;
+                    }
+                    if (draft.playerId === event.playerId) {
+                        delete draft.playerId;
+                    }
+                });
+            case Actions_1.GAME_OVER:
+                return __assign(__assign({}, state), { gameOver: true, players: state.players.map(function (player) {
+                        var _a;
+                        var p = event.players.find(function (p) { return p.id === player.id; });
+                        if (!p)
+                            return player;
+                        else
+                            return (__assign(__assign({}, player), { time: (_a = p.time) !== null && _a !== void 0 ? _a : player.time, gamePointsDelta: p.gamePointsDelta, tournamentPoints: p.tournamentPoints }));
+                    }) });
+        }
+        return state;
+    };
+    function playNextMove(action, draft) {
+        var consequenceIndex = action.played === 0 ? undefined : action.played - 1;
+        var move = consequenceIndex === undefined ? action.move : action.consequences[consequenceIndex];
+        var rules = new GameRules(draft.state, draft.client);
+        rules.play(JSON.parse(JSON.stringify(move)), { local: action.local, transient: action.transient });
+        action.played++;
+        if (!action.local && !action.transient && !action.pending) {
+            draft.playedMoves.push({ actionId: action.id, move: move, consequenceIndex: consequenceIndex });
+        }
+        animatePlayedAction(action, draft, animations_1.AnimationStep.AFTER_MOVE);
+    }
+    function undoNextMove(action, draft) {
+        var rules = new GameRules(JSON.parse(JSON.stringify(draft.setup)), draft.client);
+        action.played--;
+        var actionsPlayed = draft.actions.filter(function (action) { return action.played > 0; })
+            .map(function (action) { return (__assign(__assign({}, action), { consequences: action.consequences.slice(0, action.played - 1) })); });
+        replayActions(rules, actionsPlayed, draft.state);
+        draft.state = rules.game;
+        animateUndoneAction(action, draft, animations_1.AnimationStep.AFTER_UNDO);
+    }
+    function setActionsFromPastNotifications(draft, notifications) {
+        var _a;
+        draft.actions = [];
+        draft.playedMoves = [];
+        var _loop_1 = function (i) {
+            var notification = notifications[i];
+            if ((0, Types_1.isMovePlayedNotification)(notification)) {
+                var action = {
+                    id: (_a = notification.actionId) !== null && _a !== void 0 ? _a : undefined,
+                    playerId: notification.playerId, move: notification.moveView,
+                    consequences: notification.consequences,
+                    played: 1 + notification.consequences.length
+                };
+                draft.actions.push(action);
+                draft.playedMoves.push({ actionId: action.id, move: action.move });
+                for (var consequenceIndex = 0; consequenceIndex < action.consequences.length; consequenceIndex++) {
+                    var consequence = action.consequences[consequenceIndex];
+                    draft.playedMoves.push({ actionId: action.id, move: consequence, consequenceIndex: consequenceIndex });
+                }
+            }
+            else if ((0, Types_1.isMoveUndoneNotification)(notification)) {
+                var index = notification.actionId ? (0, ArrayUtil_1.findLastIndex)(draft.actions, function (action) { return action.id === notification.actionId; }) : notification.moveUndone;
+                if (index !== -1) {
+                    draft.actions.splice(index, 1);
+                }
+                draft.playedMoves = draft.playedMoves.filter(function (playedMove) { return playedMove.actionId !== notification.actionId; });
+            }
+        };
+        for (var i = 0; i < draft.nextNotificationIndex; i++) {
+            _loop_1(i);
+        }
+    }
+    function applyPendingNotifications(draft) {
+        if (!draft.actions) {
+            return;
+        }
+        while (draft.pendingNotifications.length && draft.pendingNotifications[0].index <= draft.nextNotificationIndex) {
+            var notification = draft.pendingNotifications.shift();
+            if (notification.index < draft.nextNotificationIndex) {
+                console.info('A notification was received twice: ' + JSON.stringify(notification));
+            }
+            else {
+                draft.nextNotificationIndex++;
+                applyNotification(draft, notification);
+            }
+        }
+    }
+    function applyNotification(draft, notification) {
+        if ((0, Types_1.isMovePlayedNotification)(notification)) {
+            applyMovePlayedNotification(draft, notification);
+        }
+        else if ((0, Types_1.isMoveUndoneNotification)(notification)) {
+            applyMoveUndoneNotification(draft, notification);
+        }
+    }
+    function applyMovePlayedNotification(draft, notification) {
+        var _a;
+        var _b, _c;
+        (0, assert_1.default)(draft.actions !== undefined, 'Cannot apply a notification before action history is loaded');
+        var action;
+        if (notification.playerId == draft.playerId) {
+            action = draft.actions.find(function (action) { return action.pending && action.playerId == notification.playerId; });
+        }
+        if (action) {
+            action.id = (_b = notification.actionId) !== null && _b !== void 0 ? _b : undefined;
+            action.pending = false;
+            if (action.delayed) {
+                action.move = notification.moveView;
+                action.consequences = notification.consequences;
+                delete action.delayed;
+            }
+            else {
+                if (action.played !== 0) {
+                    draft.playedMoves.push({ actionId: action.id, move: action.move });
+                    for (var consequenceIndex = 0; consequenceIndex < action.played - 1; consequenceIndex++) {
+                        var consequence = action.consequences[consequenceIndex];
+                        draft.playedMoves.push({ actionId: action.id, move: consequence, consequenceIndex: consequenceIndex });
+                    }
+                }
+                if (!(0, es_toolkit_1.isEqual)(JSON.parse(JSON.stringify(action.move)), JSON.parse(JSON.stringify(notification.moveView)))) {
+                    var rules = new GameRules(draft.state);
+                    if ((0, rules_api_1.hasUnpredictableMoves)(rules) && rules.canIgnoreServerDifference
+                        && rules.canIgnoreServerDifference(action.move, notification.moveView)) {
+                        action.move = notification.moveView;
+                    }
+                    else {
+                        console.error('An action was played and executed immediately:', JSON.parse(JSON.stringify(action.move)), ', but the notifications does not contain the same data:', JSON.parse(JSON.stringify(notification.moveView)), '(use the "delayed" parameter to postpone execution if the outcome cannot be anticipated).');
+                    }
+                }
+                if (action.consequences.length > notification.consequences.length) {
+                    console.error('The server returned less consequences that what was played locally:', action.consequences, notification.consequences);
+                }
+                else {
+                    for (var i = 0; i < action.consequences.length; i++) {
+                        if (!(0, es_toolkit_1.isEqual)(JSON.parse(JSON.stringify(action.consequences[i])), JSON.parse(JSON.stringify(notification.consequences[i])))) {
+                            var rules = new GameRules(draft.state);
+                            if ((0, rules_api_1.hasUnpredictableMoves)(rules) && rules.canIgnoreServerDifference
+                                && rules.canIgnoreServerDifference(action.consequences[i], notification.consequences[i])) {
+                                action.consequences[i] = notification.consequences[i];
+                            }
+                            else {
+                                console.error("Consequence #".concat(i, " was played on the client, but the server returned a different consequence:"), JSON.parse(JSON.stringify(action.consequences[i])), notification.consequences[i]);
+                            }
+                        }
+                    }
+                    (_a = action.consequences).push.apply(_a, notification.consequences.slice(action.consequences.length));
+                }
+            }
+        }
+        else {
+            draft.actions.splice((0, ArrayUtil_1.findLastIndex)(draft.actions, function (action) { return !action.pending; }) + 1, 0, {
+                id: (_c = notification.actionId) !== null && _c !== void 0 ? _c : undefined,
+                playerId: notification.playerId,
+                move: notification.moveView,
+                consequences: notification.consequences,
+                played: 0
+            });
+        }
+    }
+    function applyMoveUndoneNotification(draft, notification) {
+        (0, assert_1.default)(draft.actions !== undefined, 'Cannot apply a notification before action history is loaded');
+        var index = (0, ArrayUtil_1.findLastIndex)(draft.actions, function (action) { return action.id === notification.actionId; });
+        if (index === -1)
+            return console.error("Received move undone notification, but action ".concat(notification.actionId, " is unknown"));
+        var cancelledAction = draft.actions[index];
+        if (!cancelledAction.played && !cancelledAction.animation) {
+            draft.actions.splice(index, 1);
+        }
+        else {
+            cancelledAction.cancelled = true;
+            delete cancelledAction.cancelPending;
+            delete cancelledAction.delayed;
+        }
+        draft.playedMoves = draft.playedMoves.filter(function (move) { return move.actionId !== notification.actionId; });
+    }
+    function animateAction(action, draft) {
+        if (!action.cancelled) {
+            animatePlayedAction(action, draft);
+        }
+        else {
+            animateUndoneAction(action, draft);
+        }
+    }
+    function animatePlayedAction(action, draft, step) {
+        if (step === void 0) { step = animations_1.AnimationStep.BEFORE_MOVE; }
+        if (action.activePlayers === undefined) {
+            var rules_1 = new GameRules(draft.state, draft.client);
+            action.activePlayers = draft.players.map(function (p) { return p.id; }).filter(function (p) { return rules_1.isTurnToPlay(p); });
+        }
+        var move = (0, DisplayedAction_1.getAnimatedMove)(action, step);
+        var duration = animations.getDuration(move, getAnimationContext(action, draft, step)) / draft.animationsSpeed;
+        if (duration > 0) {
+            action.animation = { id: draft.animationIncrement++, duration: duration, step: step };
+        }
+        else if (step === animations_1.AnimationStep.BEFORE_MOVE) {
+            playNextMove(action, draft);
+        }
+        else if (action.played <= action.consequences.length && !draft.animationPaused) {
+            animatePlayedAction(action, draft);
+        }
+        else {
+            refreshLegalMoves(draft);
+        }
+    }
+    function refreshLegalMoves(draft) {
+        if (draft.playerId !== undefined) {
+            var rules = new GameRules(draft.state, draft.client);
+            draft.legalMoves = (0, immer_1.castDraft)(rules.getLegalMoves(draft.playerId));
+        }
+    }
+    function animateUndoneAction(action, draft, step) {
+        if (step === void 0) { step = animations_1.AnimationStep.BEFORE_UNDO; }
+        var move = (0, DisplayedAction_1.getAnimatedMove)(action, step);
+        var duration = animations.getDuration(move, getAnimationContext(action, draft, step)) / draft.animationsSpeed;
+        if (duration > 0) {
+            action.animation = { id: draft.animationIncrement++, duration: duration, step: step };
+        }
+        else if (step === animations_1.AnimationStep.BEFORE_UNDO) {
+            undoNextMove(action, draft);
+        }
+        else if (action.played > 0) {
+            animateUndoneAction(action, draft);
+        }
+        else {
+            refreshLegalMoves(draft);
+            if (!action.cancelPending) {
+                draft.actions.splice(draft.actions.indexOf(action), 1);
+            }
+        }
+    }
+    function getAnimationContext(action, draft, step) {
+        return __assign(__assign({}, context), { action: action, game: draft.state, playerId: draft.playerId, step: step });
+    }
+}
+function getGameAfterAnimations(state, Rules) {
+    if (!state.actions || !state.setup) {
+        throw new Error('Cannot play move before game history is loaded');
+    }
+    if (state.actions.some(function (action) { return action.animation || action.cancelled; })) {
+        var rules_2 = new Rules(JSON.parse(JSON.stringify(state.setup)), state.client);
+        var actionsToReplay = state.actions.filter(function (action) { return !action.delayed && !action.cancelled; });
+        actionsToReplay.forEach(function (action) { return replayAction(rules_2, action); });
+        return rules_2;
+    }
+    else {
+        return new Rules(JSON.parse(JSON.stringify(state.state)), { player: state.playerId });
+    }
+}
+var estimatedLatency = 100;
+function approximateTimeDelta(serverTime, clientTimeDelta) {
+    return Math.min(serverTime + estimatedLatency - new Date().getTime(), clientTimeDelta || Infinity);
+}
+function replayActions(rules, actions, previousState) {
+    actions.forEach(function (action) { return replayAction(rules, action); });
+    if ((0, rules_api_1.hasUndo)(rules) && rules.restoreTransientState)
+        rules.restoreTransientState(previousState);
+}
+function replayAction(rules, action) {
+    rules.play(JSON.parse(JSON.stringify(action.move)), { local: action.local, transient: action.transient });
+    action.consequences.forEach(function (move) { return rules.play(JSON.parse(JSON.stringify(move)), { local: action.local, transient: action.transient }); });
+}
+function isGameAction(action) {
+    return typeof action === 'object' && typeof action.type === 'number';
+}
 //# sourceMappingURL=gameReducer.js.map