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

package/dist/Store/gameReducer.js

@@ -1,347 +1,278 @@
-"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 = {
+import { hasUndo, hasUnpredictableMoves, loopWithFuse } from '@gamepark/rules-api';
+import { createReducer } from '@reduxjs/toolkit';
+import assert from 'assert';
+import { isEqual, merge } from 'es-toolkit';
+import { uniqueId } from 'es-toolkit/compat';
+import { castDraft } from 'immer';
+import { clearFailures, giveUp, playMove, receiveNotifications, setAnimationsSpeed, setGameOver, undoMove } from '../Actions';
+import { loadGameState } from '../Actions/loadGameState';
+import { removePlayer } from '../Actions/removePlayer';
+import { reportFailure } from '../Actions/reportFailure';
+import { startAnimation } from '../Actions/startAnimation';
+import { Animations, AnimationStep } from '../animations';
+import { Failure } from '../Failure';
+import { startLiveLog, stopLiveLog } from '../Log';
+import { muteSounds, soundsMuted, unmuteSounds } from '../Sound';
+import { isMovePlayedNotification, isMoveUndoneNotification } from '../Types';
+import { findLastIndex, findLastItem } from '../util/ArrayUtil';
+import { getAnimatedMove } from './DisplayedAction';
+import { endAnimation } from './endAnimation';
+export function gameReducer(context) {
+    const GameRules = context?.Rules;
+    const animations = context?.animations ?? new Animations();
+    const initialState = {
         players: [], pendingNotifications: [], nextNotificationIndex: 0, legalMoves: [], failures: [],
-        animationIncrement: 0, animationsSpeed: 1, animationPaused: false,
-        soundsMuted: (0, Sound_1.soundsMuted)(), clientTimeDelta: 0, liveLogStopped: false
+        animationIncrement: 0, animationsSpeed: 1,
+        soundsMuted: 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);
+    return createReducer(initialState, (builder) => {
+        builder.addCase(loadGameState, (draft, { payload }) => {
+            if (payload.serverTime) {
+                draft.clientTimeDelta = approximateTimeDelta(payload.serverTime, draft.clientTimeDelta);
+            }
+            draft.players = payload.players;
+            draft.options = payload.options;
+            draft.playerId = payload.playerId;
+            draft.state = payload.state;
+            if (payload.playerId !== undefined) {
+                draft.legalMoves = castDraft(new GameRules(payload.state).getLegalMoves(payload.playerId));
+            }
+            draft.setup = payload.setup;
+            draft.gameOver = !!payload.endDate;
+            draft.gameMode = payload.mode;
+            draft.tournament = payload.tournament;
+            draft.nextNotificationIndex = payload.notifications.length;
+            if (!payload.endDate) {
+                draft.client = { player: payload.playerId };
+            }
+            setActionsFromPastNotifications(draft, payload.notifications);
+        });
+        builder.addCase(receiveNotifications, (draft, { payload }) => {
+            if (payload.serverTime) {
+                draft.clientTimeDelta = approximateTimeDelta(payload.serverTime, draft.clientTimeDelta);
+            }
+            for (const player of draft.players) {
+                const newPlayerTime = payload.players.find(p => p.id === player.id)?.time;
+                player.time = newPlayerTime ?? player.time;
+            }
+            if (payload.notificationsIndex == 0 && !draft.actions) {
+                setActionsFromPastNotifications(draft, payload.notifications);
+            }
+            for (let i = Math.max(draft.nextNotificationIndex - payload.notificationsIndex, 0); i < payload.notifications.length; i++) {
+                draft.pendingNotifications.push({ ...payload.notifications[i], index: i + payload.notificationsIndex });
+            }
+            draft.pendingNotifications.sort((n1, n2) => n1.index - n2.index);
+            if (draft.state) {
+                applyPendingNotifications(draft);
+            }
+        });
+        builder.addCase(playMove, (draft, { payload: { move, options } }) => {
+            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');
+            const transient = options?.transient;
+            const local = options?.local ?? transient;
+            if (draft.playerId === undefined && !local)
+                throw new Error('Spectators cannot play');
+            const action = {
+                id: 'local-' + uniqueId(),
+                playerId: draft.playerId,
+                move,
+                consequences: [],
+                played: 0,
+                pending: !local,
+                local,
+                transient
+            };
+            const rules = getGameAfterAnimations(draft, GameRules);
+            const isUnpredictable = (move) => hasUnpredictableMoves(rules) && rules.isUnpredictableMove(move, action.playerId);
+            if (!local && (options?.delayed || isUnpredictable(move))) {
+                action.delayed = true;
+            }
+            else {
+                action.consequences = [];
+                const pendingMoves = rules.play(JSON.parse(JSON.stringify(move)), { local, transient });
+                loopWithFuse(() => {
+                    const move = pendingMoves.shift();
+                    if (!move || isUnpredictable(move))
+                        return false;
+                    action.consequences.push(move);
+                    pendingMoves.unshift(...rules.play(JSON.parse(JSON.stringify(move)), { local, transient }));
+                    return true;
+                }, { errorFn: () => new Error(`Infinite loop detected while applying move consequences: ${JSON.stringify(action)})`) });
+                if (options?.skipAnimation) {
+                    playNextMove(action, draft);
+                }
+                else {
+                    animatePlayedAction(action, draft);
+                }
+            }
+            if (!transient || action.animation) {
+                draft.actions.push(action);
+            }
+        });
+        builder.addCase(undoMove, (draft, { payload: { actionId, delayed } }) => {
+            if (!draft.actions || !draft.setup || !draft.state) {
+                return console.error('Cannot undo before actions history is loaded');
+            }
+            const action = findLastItem(draft.actions, action => action.id === actionId);
+            if (!action)
+                return console.error(`Could not find action to undo with this id: ${actionId}`);
+            if (!action.local && draft.playerId === undefined) {
+                return console.error('Spectators cannot undo moves');
+            }
+            action.cancelled = true;
+            if (!action.local) {
+                action.cancelPending = true;
+            }
+            if (!action.local && (delayed || !new GameRules(draft.state, draft.client).isTurnToPlay(draft.playerId))) {
+                action.delayed = true;
+            }
+            else {
+                animateUndoneAction(action, draft);
+            }
+        });
+        builder.addCase(reportFailure, (draft, { payload: reason }) => {
+            if (draft.actions) {
+                switch (reason) {
+                    case Failure.UNDO_FORBIDDEN:
+                        for (const action of draft.actions) {
+                            if (action.cancelPending) {
+                                action.cancelled = false;
+                                action.cancelPending = false;
+                            }
                         }
-                    }
-                });
-            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;
-    };
+                        break;
+                    default:
+                        draft.actions = draft.actions.filter(action => !action.pending);
+                        const rules = new GameRules(JSON.parse(JSON.stringify(draft.setup)), draft.client);
+                        replayActions(rules, draft.actions, draft.state);
+                        draft.state = rules.game;
+                }
+            }
+            draft.failures.push(reason);
+        });
+        builder.addCase(clearFailures, (draft) => {
+            draft.failures = [];
+        });
+        builder.addCase(startAnimation, (draft, { payload: actionId }) => {
+            if (!draft.actions)
+                return;
+            const action = draft.actions.find(action => action.id === actionId);
+            if (action) {
+                animateAction(action, draft);
+            }
+        });
+        builder.addCase(endAnimation, (draft, { payload: animationId }) => {
+            if (draft.actions) {
+                const action = draft.actions.find(action => action.animation?.id === animationId);
+                if (!action) {
+                    return console.error('endAnimation action received but not animation found with provided id');
+                }
+                const step = action.animation?.step;
+                if (action.transient) {
+                    draft.actions.splice(draft.actions.indexOf(action), 1);
+                }
+                else {
+                    delete action.animation;
+                }
+                if (step === AnimationStep.BEFORE_MOVE) {
+                    playNextMove(action, draft);
+                }
+                else if (step === AnimationStep.BEFORE_UNDO) {
+                    undoNextMove(action, draft);
+                }
+                else {
+                    refreshLegalMoves(draft);
+                }
+            }
+        });
+        builder.addCase(setAnimationsSpeed, (draft, { payload: speed }) => {
+            draft.animationsSpeed = speed;
+        });
+        builder.addCase(giveUp, (draft) => {
+            draft.playerId = undefined;
+        });
+        builder.addCase(muteSounds, (draft) => {
+            draft.soundsMuted = true;
+        });
+        builder.addCase(unmuteSounds, (draft) => {
+            draft.soundsMuted = false;
+        });
+        builder.addCase(startLiveLog, (draft) => {
+            draft.liveLogStopped = false;
+        });
+        builder.addCase(stopLiveLog, (draft) => {
+            draft.liveLogStopped = true;
+        });
+        builder.addCase(removePlayer, (draft, { payload: { playerId, reason } }) => {
+            const player = draft.players.find(p => p.id === playerId);
+            if (player) {
+                player.quit = true;
+                player.quitReason = reason;
+            }
+            if (draft.playerId === playerId) {
+                delete draft.playerId;
+            }
+        });
+        builder.addCase(setGameOver, (draft, { payload: players }) => {
+            draft.gameOver = true;
+            for (const player of draft.players) {
+                const newPlayerData = players.find(p => p.id === player.id) ?? {};
+                merge(player, newPlayerData);
+            }
+        });
+    });
     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);
+        const consequenceIndex = action.played === 0 ? undefined : action.played - 1;
+        const move = consequenceIndex === undefined ? action.move : action.consequences[consequenceIndex];
+        const 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 });
+            draft.playedMoves.push({ actionId: action.id, move, consequenceIndex });
         }
-        animatePlayedAction(action, draft, animations_1.AnimationStep.AFTER_MOVE);
+        animatePlayedAction(action, draft, AnimationStep.AFTER_MOVE);
     }
     function undoNextMove(action, draft) {
-        var rules = new GameRules(JSON.parse(JSON.stringify(draft.setup)), draft.client);
+        const 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) })); });
+        const actionsPlayed = draft.actions.filter(action => action.played > 0)
+            .map(action => ({
+            ...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);
+        animateUndoneAction(action, draft, 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,
+        for (let i = 0; i < draft.nextNotificationIndex; i++) {
+            const notification = notifications[i];
+            if (isMovePlayedNotification(notification)) {
+                const action = {
+                    id: notification.actionId ?? 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 });
+                for (let consequenceIndex = 0; consequenceIndex < action.consequences.length; consequenceIndex++) {
+                    const consequence = action.consequences[consequenceIndex];
+                    draft.playedMoves.push({ actionId: action.id, move: consequence, 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;
+            else if (isMoveUndoneNotification(notification)) {
+                const index = notification.actionId ? findLastIndex(draft.actions, action => 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; });
+                draft.playedMoves = draft.playedMoves.filter((playedMove) => playedMove.actionId !== notification.actionId);
             }
-        };
-        for (var i = 0; i < draft.nextNotificationIndex; i++) {
-            _loop_1(i);
         }
     }
     function applyPendingNotifications(draft) {
@@ -349,7 +280,7 @@ function gameReducer(context) {
             return;
         }
         while (draft.pendingNotifications.length && draft.pendingNotifications[0].index <= draft.nextNotificationIndex) {
-            var notification = draft.pendingNotifications.shift();
+            const notification = draft.pendingNotifications.shift();
             if (notification.index < draft.nextNotificationIndex) {
                 console.info('A notification was received twice: ' + JSON.stringify(notification));
             }
@@ -360,23 +291,21 @@ function gameReducer(context) {
         }
     }
     function applyNotification(draft, notification) {
-        if ((0, Types_1.isMovePlayedNotification)(notification)) {
+        if (isMovePlayedNotification(notification)) {
             applyMovePlayedNotification(draft, notification);
         }
-        else if ((0, Types_1.isMoveUndoneNotification)(notification)) {
+        else if (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; });
+        assert(draft.actions !== undefined, 'Cannot apply a notification before action history is loaded');
+        let action;
+        if (notification.playerId === draft.playerId) {
+            action = draft.actions.find(action => action.pending && action.playerId == notification.playerId);
         }
         if (action) {
-            action.id = (_b = notification.actionId) !== null && _b !== void 0 ? _b : undefined;
+            action.id = notification.actionId ?? undefined;
             action.pending = false;
             if (action.delayed) {
                 action.move = notification.moveView;
@@ -386,14 +315,14 @@ function gameReducer(context) {
             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 });
+                    for (let consequenceIndex = 0; consequenceIndex < action.played - 1; consequenceIndex++) {
+                        const consequence = action.consequences[consequenceIndex];
+                        draft.playedMoves.push({ actionId: action.id, move: consequence, 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
+                if (!isEqual(JSON.parse(JSON.stringify(action.move)), JSON.parse(JSON.stringify(notification.moveView)))) {
+                    const rules = new GameRules(draft.state);
+                    if (hasUnpredictableMoves(rules) && rules.canIgnoreServerDifference
                         && rules.canIgnoreServerDifference(action.move, notification.moveView)) {
                         action.move = notification.moveView;
                     }
@@ -405,25 +334,25 @@ function gameReducer(context) {
                     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
+                    for (let i = 0; i < action.consequences.length; i++) {
+                        if (!isEqual(JSON.parse(JSON.stringify(action.consequences[i])), JSON.parse(JSON.stringify(notification.consequences[i])))) {
+                            const rules = new GameRules(draft.state);
+                            if (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]);
+                                console.error(`Consequence #${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));
+                    action.consequences.push(...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,
+            draft.actions.splice(findLastIndex(draft.actions, action => !action.pending) + 1, 0, {
+                id: notification.actionId ?? undefined,
                 playerId: notification.playerId,
                 move: notification.moveView,
                 consequences: notification.consequences,
@@ -432,11 +361,11 @@ function gameReducer(context) {
         }
     }
     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; });
+        assert(draft.actions !== undefined, 'Cannot apply a notification before action history is loaded');
+        const index = findLastIndex(draft.actions, action => 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];
+            return console.error(`Received move undone notification, but action ${notification.actionId} is unknown`);
+        const cancelledAction = draft.actions[index];
         if (!cancelledAction.played && !cancelledAction.animation) {
             draft.actions.splice(index, 1);
         }
@@ -445,7 +374,7 @@ function gameReducer(context) {
             delete cancelledAction.cancelPending;
             delete cancelledAction.delayed;
         }
-        draft.playedMoves = draft.playedMoves.filter(function (move) { return move.actionId !== notification.actionId; });
+        draft.playedMoves = draft.playedMoves.filter((move) => move.actionId !== notification.actionId);
     }
     function animateAction(action, draft) {
         if (!action.cancelled) {
@@ -455,21 +384,20 @@ function gameReducer(context) {
             animateUndoneAction(action, draft);
         }
     }
-    function animatePlayedAction(action, draft, step) {
-        if (step === void 0) { step = animations_1.AnimationStep.BEFORE_MOVE; }
+    function animatePlayedAction(action, draft, step = 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); });
+            const rules = new GameRules(draft.state, draft.client);
+            action.activePlayers = draft.players.map(p => p.id).filter(p => rules.isTurnToPlay(p));
         }
-        var move = (0, DisplayedAction_1.getAnimatedMove)(action, step);
-        var duration = animations.getDuration(move, getAnimationContext(action, draft, step)) / draft.animationsSpeed;
+        const move = getAnimatedMove(action, step);
+        const duration = animations.getDuration(move, getAnimationContext(action, draft, step)) / draft.animationsSpeed;
         if (duration > 0) {
-            action.animation = { id: draft.animationIncrement++, duration: duration, step: step };
+            action.animation = { id: draft.animationIncrement++, duration, step };
         }
-        else if (step === animations_1.AnimationStep.BEFORE_MOVE) {
+        else if (step === AnimationStep.BEFORE_MOVE) {
             playNextMove(action, draft);
         }
-        else if (action.played <= action.consequences.length && !draft.animationPaused) {
+        else if (action.played <= action.consequences.length) {
             animatePlayedAction(action, draft);
         }
         else {
@@ -478,18 +406,17 @@ function gameReducer(context) {
     }
     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));
+            const rules = new GameRules(draft.state, draft.client);
+            draft.legalMoves = 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;
+    function animateUndoneAction(action, draft, step = AnimationStep.BEFORE_UNDO) {
+        const move = getAnimatedMove(action, step);
+        const duration = animations.getDuration(move, getAnimationContext(action, draft, step)) / draft.animationsSpeed;
         if (duration > 0) {
-            action.animation = { id: draft.animationIncrement++, duration: duration, step: step };
+            action.animation = { id: draft.animationIncrement++, duration, step };
         }
-        else if (step === animations_1.AnimationStep.BEFORE_UNDO) {
+        else if (step === AnimationStep.BEFORE_UNDO) {
             undoNextMove(action, draft);
         }
         else if (action.played > 0) {
@@ -503,37 +430,34 @@ function gameReducer(context) {
         }
     }
     function getAnimationContext(action, draft, step) {
-        return __assign(__assign({}, context), { action: action, game: draft.state, playerId: draft.playerId, step: step });
+        return { ...context, action: action, game: draft.state, playerId: draft.playerId, step };
     }
 }
-function getGameAfterAnimations(state, Rules) {
+export 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;
+    if (state.actions.some(action => action.animation || action.cancelled)) {
+        const rules = new Rules(JSON.parse(JSON.stringify(state.setup)), state.client);
+        const actionsToReplay = state.actions.filter(action => !action.delayed && !action.cancelled);
+        actionsToReplay.forEach(action => replayAction(rules, action));
+        return rules;
     }
     else {
         return new Rules(JSON.parse(JSON.stringify(state.state)), { player: state.playerId });
     }
 }
-var estimatedLatency = 100;
+const 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)
+export function replayActions(rules, actions, previousState) {
+    actions.forEach(action => replayAction(rules, action));
+    if (hasUndo(rules) && rules.restoreTransientState)
         rules.restoreTransientState(previousState);
 }
-function replayAction(rules, action) {
+export 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';
+    action.consequences.forEach(move => rules.play(JSON.parse(JSON.stringify(move)), { local: action.local, transient: action.transient }));
 }
 //# sourceMappingURL=gameReducer.js.map