@konoui/mjimage 0.0.1 → 0.0.2

package/dist/mjs/lib/controller/state-machine.js

@@ -0,0 +1,733 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.incrementalIDGenerator = exports.createControllerMachine = void 0;
+var constants_1 = require("../constants");
+var parser_1 = require("../parser");
+var calculator_1 = require("./../calculator");
+var managers_1 = require("./managers");
+var xstate_1 = require("xstate");
+var createControllerMachine = function (c) {
+    return (0, xstate_1.createMachine)({
+        id: "Untitled",
+        initial: "distribute",
+        context: {
+            currentWind: "1w",
+            oneShotMap: (0, managers_1.createWindMap)(false),
+            missingMap: (0, managers_1.createWindMap)(false),
+            controller: c,
+            genEventID: incrementalIDGenerator(),
+        },
+        states: {
+            distribute: {
+                on: {
+                    NEXT: {
+                        target: "drawn",
+                    },
+                },
+                entry: {
+                    type: "notify_distribution",
+                },
+            },
+            drawn: {
+                entry: {
+                    type: "notify_draw",
+                },
+                on: {
+                    NEXT: {
+                        target: "waiting_user_event_after_drawn",
+                        actions: {
+                            type: "notify_choice_after_drawn",
+                        },
+                        description: "可能なアクションとその詳細を通知\\\nDISCARD の場合は捨てられる牌の一覧",
+                    },
+                },
+            },
+            waiting_user_event_after_drawn: {
+                description: "ツモった1ユーザからのレスポンス待ち",
+                on: {
+                    TSUMO: {
+                        target: "tsumo",
+                        guard: "canWin",
+                    },
+                    REACH: {
+                        target: "discarded",
+                        guard: "canReach",
+                        actions: {
+                            type: "notify_reach",
+                        },
+                        description: "入力に牌が必要\\\n立直直後のロンは立直棒が点数にならないので\\\n別途状態を保つ必要がある",
+                    },
+                    SHO_KAN: {
+                        target: "an_sho_kaned",
+                    },
+                    AN_KAN: {
+                        target: "an_sho_kaned",
+                    },
+                    DISCARD: {
+                        target: "discarded",
+                        description: "入力に牌が必須",
+                        actions: {
+                            type: "disable_one_shot_for_me",
+                        },
+                    },
+                    DRAWN_GAME_BY_NINE_TILES: {
+                        target: "drawn_game",
+                    },
+                },
+            },
+            discarded: {
+                entry: {
+                    type: "notify_discard",
+                },
+                on: {
+                    NEXT: {
+                        target: "waiting_user_event_after_discarded",
+                        actions: {
+                            type: "notify_choice_after_discarded",
+                        },
+                        description: "可能なアクションとその詳細を通知\\\nCHI/PON の場合は鳴ける組み合わせの一覧",
+                    },
+                },
+            },
+            tsumo: {
+                exit: [
+                    {
+                        type: "notify_tsumo",
+                    },
+                    {
+                        type: "notify_end",
+                    },
+                ],
+                type: "final",
+            },
+            waiting_user_event_after_discarded: {
+                description: "最大 4人から choice に対するレスポンスを待つ\\\nユーザからではなく、controller が優先順位を考慮して遷移させる必要がある\\\n通知する choice がない場合、controller が\\*で遷移させる",
+                on: {
+                    RON: {
+                        target: "roned",
+                        guard: "canWin",
+                    },
+                    PON: {
+                        target: "poned",
+                        guard: "canPon",
+                    },
+                    CHI: {
+                        target: "chied",
+                        guard: "canChi",
+                    },
+                    DAI_KAN: {
+                        target: "dai_kaned",
+                    },
+                    "*": {
+                        target: "wildcard_after_discarded",
+                    },
+                },
+            },
+            roned: {
+                exit: [
+                    {
+                        type: "notify_ron",
+                    },
+                    {
+                        type: "notify_end",
+                    },
+                ],
+                type: "final",
+            },
+            poned: {
+                on: {
+                    NEXT: {
+                        target: "waiting_discard_event",
+                        actions: {
+                            type: "notify_choice_after_called",
+                        },
+                    },
+                },
+                entry: [
+                    {
+                        type: "notify_call",
+                    },
+                    {
+                        type: "disable_none_shot",
+                    },
+                ],
+            },
+            chied: {
+                on: {
+                    NEXT: {
+                        target: "waiting_discard_event",
+                        actions: {
+                            type: "notify_choice_after_called",
+                            params: { action: "chi" },
+                        },
+                    },
+                },
+                entry: [
+                    {
+                        type: "notify_call",
+                    },
+                    {
+                        type: "disable_one_shot",
+                    },
+                ],
+            },
+            wildcard_after_discarded: {
+                exit: [],
+                always: [
+                    {
+                        target: "drawn_game",
+                        guard: "cannotContinue",
+                    },
+                    {
+                        target: "drawn",
+                        actions: [
+                            {
+                                type: "updateNextWind",
+                            },
+                        ],
+                    },
+                ],
+            },
+            waiting_discard_event: {
+                description: "鳴いたユーザからの DISCARD イベントを待つ",
+                on: {
+                    DISCARD: {
+                        target: "discarded",
+                    },
+                },
+            },
+            dai_kaned: {
+                on: {
+                    NEXT: {
+                        target: "waiting_user_event_after_drawn",
+                        actions: [
+                            {
+                                type: "notify_draw",
+                                params: { action: "kan" },
+                            },
+                            {
+                                type: "notify_choice_after_drawn",
+                                params: { replacementWin: true },
+                            },
+                        ],
+                    },
+                },
+                entry: [
+                    {
+                        type: "notify_call",
+                    },
+                    {
+                        type: "disable_one_shot",
+                    },
+                ],
+            },
+            an_sho_kaned: {
+                on: {
+                    NEXT: {
+                        target: "waiting_chankan_event",
+                    },
+                },
+                entry: [
+                    {
+                        type: "notify_call",
+                    },
+                    {
+                        type: "disable_one_shot",
+                    },
+                    {
+                        type: "notify_new_dora_if_needed",
+                    },
+                    {
+                        type: "notify_choice_for_chankan",
+                    },
+                ],
+            },
+            waiting_chankan_event: {
+                description: "チャンカンを待つ",
+                exit: [
+                    {
+                        type: "notify_draw",
+                        params: { action: "kan" },
+                    },
+                    {
+                        type: "notify_choice_after_drawn",
+                        params: { replacementWin: true },
+                    },
+                ],
+                on: {
+                    RON: {
+                        target: "roned",
+                        guard: "canWin",
+                    },
+                    "*": {
+                        target: "waiting_user_event_after_drawn",
+                    },
+                },
+            },
+            drawn_game: {
+                exit: {
+                    type: "notify_end",
+                    params: {},
+                },
+                type: "final",
+            },
+        },
+        types: {
+            events: {},
+            context: {},
+        },
+    }, {
+        actions: {
+            updateNextWind: function (_a) {
+                var context = _a.context, event = _a.event;
+                var cur = context.currentWind;
+                context.currentWind = (0, managers_1.nextWind)(cur);
+            },
+            notify_distribution: function (_a) {
+                var context = _a.context, event = _a.event;
+                var id = context.genEventID();
+                var initHands = context.controller.initialHands();
+                for (var _i = 0, _b = Object.values(constants_1.WIND); _i < _b.length; _i++) {
+                    var w = _b[_i];
+                    var hands = (0, managers_1.createWindMap)("_____________");
+                    hands[w] = initHands[w].toString();
+                    var e = {
+                        id: id,
+                        type: "DISTRIBUTE",
+                        hands: hands,
+                        wind: w,
+                        doraMarker: context.controller.wall.doraMarkers[0],
+                        sticks: context.controller.placeManager.sticks,
+                        round: context.controller.placeManager.round,
+                        players: context.controller.playerIDs,
+                        places: context.controller.placeManager.playerMap,
+                        scores: context.controller.scoreManager.summary,
+                    };
+                    context.controller.emit(e);
+                }
+                context.controller.next();
+            },
+            notify_choice_after_drawn: function (_a, params) {
+                var context = _a.context, event = _a.event;
+                var w = context.currentWind;
+                var drawn = context.controller.hand(w).drawn;
+                var id = context.genEventID();
+                var e = {
+                    id: id,
+                    type: "CHOICE_AFTER_DRAWN",
+                    wind: w,
+                    tileInfo: { wind: w, tile: drawn },
+                    choices: {
+                        TSUMO: context.controller.doWin(w, drawn, {
+                            oneShot: context.oneShotMap[w],
+                            replacementWin: params === null || params === void 0 ? void 0 : params.replacementWin,
+                        }),
+                        REACH: context.controller.doReach(w),
+                        AN_KAN: context.controller.doAnKan(w),
+                        SHO_KAN: context.controller.doShoKan(w),
+                        DISCARD: context.controller.doDiscard(w),
+                        DRAWN_GAME_BY_NINE_TILES: context.controller.canDrawnGame(w),
+                    },
+                };
+                context.controller.emit(e);
+                context.controller.pollReplies(id, [w]);
+            },
+            notify_choice_after_discarded: function (_a) {
+                var context = _a.context, event = _a.event;
+                var id = context.genEventID();
+                var discarded = context.controller.river.lastTile;
+                var ltile = discarded.t.clone().add(constants_1.OPERATOR.HORIZONTAL);
+                for (var _i = 0, _b = Object.values(constants_1.WIND); _i < _b.length; _i++) {
+                    var w = _b[_i];
+                    var e = {
+                        id: id,
+                        type: "CHOICE_AFTER_DISCARDED",
+                        wind: w,
+                        tileInfo: { wind: discarded.w, tile: discarded.t },
+                        choices: {
+                            RON: context.controller.doWin(w, ltile, {
+                                whoDiscarded: discarded.w,
+                                oneShot: context.oneShotMap[w],
+                                missingRon: context.missingMap[w],
+                            }),
+                            PON: context.controller.doPon(w, discarded.w, ltile),
+                            CHI: context.controller.doChi(w, discarded.w, ltile),
+                            DAI_KAN: context.controller.doDaiKan(w, discarded.w, ltile),
+                        },
+                    };
+                    if (e.choices.RON)
+                        context.missingMap[w] = true;
+                    context.controller.emit(e);
+                }
+                context.controller.pollReplies(id, Object.values(constants_1.WIND));
+            },
+            notify_choice_after_called: function (_a, params) {
+                var context = _a.context, event = _a.event;
+                var id = context.genEventID();
+                var w = context.currentWind;
+                var discard = context.controller.doDiscard(w);
+                var called = context.controller
+                    .hand(context.currentWind)
+                    .called.at(-1);
+                if (called instanceof parser_1.BlockChi || called instanceof parser_1.BlockPon)
+                    discard = context.controller.doDiscard(w, called);
+                var e = {
+                    id: id,
+                    type: "CHOICE_AFTER_CALLED",
+                    wind: w,
+                    choices: {
+                        DISCARD: discard,
+                    },
+                };
+                context.controller.emit(e);
+                context.controller.pollReplies(id, [w]);
+            },
+            notify_choice_for_chankan: function (_a) {
+                var context = _a.context, event = _a.event;
+                if (event.type != "SHO_KAN" && event.type != "AN_KAN")
+                    throw new Error("unexpected event ".concat(event.type));
+                var id = context.genEventID();
+                var t = event.block.tiles[0].clone().remove(constants_1.OPERATOR.HORIZONTAL);
+                for (var _i = 0, _b = Object.values(constants_1.WIND); _i < _b.length; _i++) {
+                    var w = _b[_i];
+                    var ron = context.controller.doWin(w, event.block.tiles[0].clone().remove(constants_1.OPERATOR.HORIZONTAL), {
+                        whoDiscarded: event.iam,
+                        quadWin: true,
+                        oneShot: context.oneShotMap[w],
+                        missingRon: context.missingMap[event.iam],
+                    });
+                    var e = {
+                        id: id,
+                        type: "CHOICE_FOR_CHAN_KAN",
+                        wind: w,
+                        tileInfo: { wind: event.iam, tile: t },
+                        choices: {
+                            RON: event.type == "SHO_KAN" ? ron : false,
+                        },
+                    };
+                    if (e.choices.RON)
+                        context.missingMap[w] = true;
+                    context.controller.emit(e);
+                }
+                context.controller.pollReplies(id, Object.values(constants_1.WIND));
+            },
+            notify_call: function (_a) {
+                var context = _a.context, event = _a.event;
+                if (!(event.type == "CHI" ||
+                    event.type == "PON" ||
+                    event.type == "DAI_KAN" ||
+                    event.type == "AN_KAN" ||
+                    event.type == "SHO_KAN"))
+                    throw new Error("unexpected event ".concat(event.type));
+                var id = context.genEventID();
+                var iam = event.iam;
+                context.currentWind = iam;
+                for (var _i = 0, _b = Object.values(constants_1.WIND); _i < _b.length; _i++) {
+                    var w = _b[_i];
+                    var e = {
+                        id: id,
+                        type: event.type,
+                        iam: iam,
+                        wind: w,
+                        block: event.block,
+                    };
+                    context.controller.emit(e);
+                }
+                context.controller.next();
+            },
+            notify_discard: function (_a) {
+                var context = _a.context, event = _a.event;
+                if (event.type != "DISCARD" && event.type != "REACH")
+                    throw new Error("unexpected event ".concat(event.type));
+                var id = context.genEventID();
+                var iam = context.currentWind;
+                var t = event.tile;
+                for (var _i = 0, _b = Object.values(constants_1.WIND); _i < _b.length; _i++) {
+                    var w = _b[_i];
+                    var e = {
+                        id: id,
+                        type: "DISCARD",
+                        iam: iam,
+                        wind: w,
+                        tile: t,
+                    };
+                    context.controller.emit(e);
+                }
+                context.controller.next();
+            },
+            notify_draw: function (_a, params) {
+                var context = _a.context, event = _a.event;
+                var id = context.genEventID();
+                var action = params === null || params === void 0 ? void 0 : params.action;
+                var drawn = undefined;
+                if (action == "kan")
+                    drawn = context.controller.wall.kan();
+                else
+                    drawn = context.controller.wall.draw();
+                var iam = context.currentWind;
+                if (!context.controller.hand(iam).reached)
+                    context.missingMap[iam] = false;
+                for (var _i = 0, _b = Object.values(constants_1.WIND); _i < _b.length; _i++) {
+                    var w = _b[_i];
+                    var t = new parser_1.Tile(constants_1.KIND.BACK, 0);
+                    if (w == iam)
+                        t = drawn;
+                    var e = {
+                        id: id,
+                        type: "DRAW",
+                        subType: action,
+                        iam: iam,
+                        wind: w,
+                        tile: t,
+                    };
+                    context.controller.emit(e);
+                }
+                context.controller.next();
+            },
+            notify_ron: function (_a) {
+                var context = _a.context, event = _a.event;
+                var id = context.genEventID();
+                if (event.type == "RON") {
+                    var ronWind = event.targetInfo.wind;
+                    var cur = context.currentWind;
+                    var pushBackReachStick = ronWind == cur && context.oneShotMap[cur] == true;
+                    var iam = event.iam;
+                    for (var _i = 0, _b = Object.values(constants_1.WIND); _i < _b.length; _i++) {
+                        var w = _b[_i];
+                        var e = {
+                            id: id,
+                            type: event.type,
+                            iam: iam,
+                            wind: w,
+                            targetInfo: event.targetInfo,
+                            ret: event.ret,
+                            pushBackReachStick: pushBackReachStick,
+                        };
+                        context.controller.emit(e);
+                    }
+                }
+            },
+            notify_tsumo: function (_a) {
+                var context = _a.context, event = _a.event;
+                if (event.type != "TSUMO")
+                    throw new Error("unexpected event ".concat(event.type));
+                var id = context.genEventID();
+                var iam = context.currentWind;
+                for (var _i = 0, _b = Object.values(constants_1.WIND); _i < _b.length; _i++) {
+                    var w = _b[_i];
+                    var e = {
+                        id: id,
+                        type: event.type,
+                        iam: iam,
+                        wind: w,
+                        lastTile: context.controller.hand(iam).drawn,
+                        ret: event.ret,
+                    };
+                    context.controller.emit(e);
+                }
+            },
+            notify_reach: function (_a) {
+                var context = _a.context, event = _a.event;
+                if (event.type != "REACH")
+                    throw new Error("unexpected event ".concat(event.type));
+                var id = context.genEventID();
+                var iam = event.iam;
+                var t = event.tile.clone().add(constants_1.OPERATOR.HORIZONTAL);
+                context.oneShotMap[iam] = true;
+                for (var _i = 0, _b = Object.values(constants_1.WIND); _i < _b.length; _i++) {
+                    var w = _b[_i];
+                    var e = {
+                        id: id,
+                        type: event.type,
+                        iam: iam,
+                        wind: w,
+                        tile: t,
+                    };
+                    context.controller.emit(e);
+                }
+            },
+            notify_new_dora_if_needed: function (_a) {
+                var context = _a.context, event = _a.event;
+                var id = context.genEventID();
+                if (event.type == "AN_KAN") {
+                    var tile = context.controller.wall.openDoraMarker();
+                    for (var _i = 0, _b = Object.values(constants_1.WIND); _i < _b.length; _i++) {
+                        var w = _b[_i];
+                        var e = {
+                            id: id,
+                            type: "NEW_DORA",
+                            wind: w,
+                            doraMarker: tile,
+                        };
+                        context.controller.emit(e);
+                    }
+                }
+                if (event.type == "SHO_KAN") {
+                }
+            },
+            disable_one_shot: function (_a) {
+                var context = _a.context, event = _a.event;
+                for (var _i = 0, _b = Object.values(constants_1.WIND); _i < _b.length; _i++) {
+                    var w = _b[_i];
+                    context.oneShotMap[w] = false;
+                }
+            },
+            disable_one_shot_for_me: function (_a) {
+                var context = _a.context, event = _a.event;
+                context.oneShotMap[context.currentWind] = false;
+            },
+            notify_end: function (_a) {
+                var context = _a.context, event = _a.event;
+                var id = context.genEventID();
+                var hands = (0, managers_1.createWindMap)("");
+                if (event.type == "DRAWN_GAME_BY_NINE_TILES") {
+                    hands[event.iam] = context.controller.hand(event.iam).toString();
+                    for (var _i = 0, _b = Object.values(constants_1.WIND); _i < _b.length; _i++) {
+                        var w = _b[_i];
+                        var e = {
+                            id: id,
+                            type: "END_GAME",
+                            subType: "NINE_TILES",
+                            wind: w,
+                            shouldContinue: true,
+                            sticks: context.controller.placeManager.sticks,
+                            scores: context.controller.scoreManager.summary,
+                            deltas: (0, managers_1.createWindMap)(0),
+                            hands: hands,
+                        };
+                        context.controller.emit(e);
+                    }
+                }
+                else if (event.type == "RON" || event.type == "TSUMO") {
+                    var shouldContinue = event.iam == "1w";
+                    var finalResults = context.controller.finalResult(event.ret, event.iam);
+                    for (var _c = 0, _d = Object.values(constants_1.WIND); _c < _d.length; _c++) {
+                        var w = _d[_c];
+                        hands[event.iam] = context.controller.hand(event.iam).toString();
+                        var e = {
+                            id: id,
+                            type: "END_GAME",
+                            subType: "WIN_GAME",
+                            wind: w,
+                            shouldContinue: shouldContinue,
+                            sticks: { reach: 0, dead: 0 },
+                            scores: context.controller.scoreManager.summary,
+                            deltas: finalResults.deltas,
+                            hands: hands,
+                        };
+                        context.controller.emit(e);
+                    }
+                }
+                else if (!context.controller.wall.canKan ||
+                    context.controller.river.cannotContinue()) {
+                    var subType = !context.controller.wall.canKan
+                        ? "FOUR_KAN"
+                        : "FOUR_WIND";
+                    for (var _e = 0, _f = Object.values(constants_1.WIND); _e < _f.length; _e++) {
+                        var w = _f[_e];
+                        var e = {
+                            id: id,
+                            type: "END_GAME",
+                            subType: subType,
+                            wind: w,
+                            shouldContinue: true,
+                            sticks: context.controller.placeManager.sticks,
+                            scores: context.controller.scoreManager.summary,
+                            deltas: (0, managers_1.createWindMap)(0),
+                            hands: (0, managers_1.createWindMap)(""),
+                        };
+                        context.controller.emit(e);
+                    }
+                }
+                else if (!context.controller.wall.canDraw) {
+                    var wind = [];
+                    for (var _g = 0, _h = Object.values(constants_1.WIND); _g < _h.length; _g++) {
+                        var w = _h[_g];
+                        var hand = context.controller.hand(w);
+                        var shan = new calculator_1.ShantenCalculator(hand).calc();
+                        if (shan == 0) {
+                            wind.push(w);
+                            hands[w] = hand.toString();
+                        }
+                    }
+                    var nothing = wind.length == 0 || wind.length == 4;
+                    var deltas = (0, managers_1.createWindMap)(0);
+                    for (var _j = 0, _k = Object.values(constants_1.WIND); _j < _k.length; _j++) {
+                        var w = _k[_j];
+                        if (wind.includes(w))
+                            deltas[w] += nothing ? 0 : 3000 / wind.length;
+                        else
+                            deltas[w] -= nothing ? 0 : 3000 / (4 - wind.length);
+                    }
+                    var shouldContinue = wind.length == 4 || deltas["1w"] > 0;
+                    for (var _l = 0, _m = Object.values(constants_1.WIND); _l < _m.length; _l++) {
+                        var w = _m[_l];
+                        var e = {
+                            id: id,
+                            type: "END_GAME",
+                            subType: "DRAWN_GAME",
+                            wind: w,
+                            shouldContinue: shouldContinue,
+                            sticks: context.controller.placeManager.sticks,
+                            scores: context.controller.scoreManager.summary,
+                            deltas: deltas,
+                            hands: hands,
+                        };
+                        context.controller.emit(e);
+                    }
+                }
+                else
+                    throw new Error("unexpected event ".concat(event.type));
+            },
+        },
+        actors: {},
+        guards: {
+            canChi: function (_a, params) {
+                var context = _a.context, event = _a.event;
+                if (event.type == "CHI")
+                    return !!context.controller.doChi(event.iam, context.controller.river.lastTile.w, context.controller.river.lastTile.t);
+                console.error("guards.canChi receive ".concat(event.type));
+                return false;
+            },
+            canPon: function (_a, params) {
+                var context = _a.context, event = _a.event;
+                if (event.type == "PON")
+                    return !!context.controller.doPon(event.iam, context.controller.river.lastTile.w, context.controller.river.lastTile.t);
+                console.error("guards.canPon receive ".concat(event.type));
+                return false;
+            },
+            canWin: function (_a, params) {
+                var context = _a.context, event = _a.event;
+                if (event.type == "TSUMO" || event.type == "RON") {
+                    return true;
+                }
+                console.error("guards.canWin receive ".concat(event.type));
+                return false;
+            },
+            canReach: function (_a, params) {
+                var context = _a.context, event = _a.event;
+                if (event.type == "REACH") {
+                    return !!context.controller.doReach(event.iam);
+                }
+                console.error("guards.canReach receive ".concat(event.type));
+                return false;
+            },
+            cannotContinue: function (_a, params) {
+                var context = _a.context, event = _a.event;
+                return (!context.controller.wall.canDraw ||
+                    !context.controller.wall.canKan ||
+                    context.controller.river.cannotContinue());
+            },
+        },
+        delays: {},
+    });
+};
+exports.createControllerMachine = createControllerMachine;
+function incrementalIDGenerator(start) {
+    if (start === void 0) { start = 0; }
+    var idx = start;
+    return function () {
+        return (idx++).toString();
+    };
+}
+exports.incrementalIDGenerator = incrementalIDGenerator;