@konoui/mjimage 0.0.1 → 0.0.3

package/dist/mjs/lib/mjai/event.js

@@ -0,0 +1,348 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MJAIPlayer = void 0;
+var constants_1 = require("../constants");
+var parser_1 = require("../parser");
+var controller_1 = require("./../controller");
+var M = ["5mr", "1m", "2m", "3m", "4m", "5m", "6m", "7m", "8m", "9m"];
+var S = ["5sr", "1s", "2s", "3s", "4s", "5s", "6s", "7s", "8s", "9s"];
+var P = ["5pr", "1p", "2p", "3p", "4p", "5p", "6p", "7p", "8p", "9p"];
+var Z = ["ERROR-WIND", "E", "S", "W", "N", "P", "F", "C"];
+var UNSCREEN = "?";
+var MJAIPlayer = (function () {
+    function MJAIPlayer() {
+        var _this = this;
+        this.genID = (0, controller_1.incrementalIDGenerator)();
+        this.reachEventRecorder = {};
+        this.toPlayerEvent = function (myWind, pm, e) {
+            var _a, _b;
+            var kyoku = toKyoku(pm.round);
+            switch (e.type) {
+                case "start_kyoku": {
+                    var pe = {
+                        id: _this.genID(),
+                        type: "DISTRIBUTE",
+                        hands: toHands(e.tehais, e.kyoku),
+                        wind: myWind,
+                        doraMarker: toTile(e.dora_marker),
+                        sticks: { reach: e.kyotaku, dead: e.honba },
+                        scores: toScores(e.scores),
+                        round: toRound(e.bakaze, e.kyotaku),
+                        places: toPlaces(e.kyoku),
+                        players: ["0", "1", "2", "3"],
+                    };
+                    return pe;
+                }
+                case "tsumo": {
+                    var pe = {
+                        id: _this.genID(),
+                        type: "DRAW",
+                        iam: toPlayerWind(e.actor, kyoku),
+                        wind: myWind,
+                        tile: toTile(e.pai),
+                    };
+                    return pe;
+                }
+                case "dahai": {
+                    if (_this.reachEventRecorder[e.actor]) {
+                        _this.reachEventRecorder[e.actor] = false;
+                        var pe_1 = {
+                            id: _this.genID(),
+                            type: "REACH",
+                            wind: myWind,
+                            iam: toPlayerWind(e.actor, kyoku),
+                            tile: toTile(e.pai),
+                        };
+                        return pe_1;
+                    }
+                    var pe = {
+                        id: _this.genID(),
+                        type: "DISCARD",
+                        iam: toPlayerWind(e.actor, kyoku),
+                        wind: myWind,
+                        tile: toTile(e.pai),
+                    };
+                    return pe;
+                }
+                case "dora": {
+                    var pe = {
+                        id: _this.genID(),
+                        type: "NEW_DORA",
+                        doraMarker: toTile(e.dora_marker),
+                        wind: myWind,
+                    };
+                    return pe;
+                }
+                case "ankan": {
+                    var tiles = __spreadArray([toTile(e.pai)], toTiles(e.consumed), true);
+                    var pe = {
+                        id: _this.genID(),
+                        type: "AN_KAN",
+                        wind: myWind,
+                        iam: toPlayerWind(e.actor, kyoku),
+                        block: new parser_1.BlockAnKan(tiles),
+                    };
+                    return pe;
+                }
+                case "chi": {
+                    var block = new parser_1.BlockChi([
+                        toTile(e.pai).add(constants_1.OPERATOR.HORIZONTAL),
+                        toTile(e.consumed[0]),
+                        toTile(e.consumed[1]),
+                    ]);
+                    var pe = {
+                        id: _this.genID(),
+                        type: "CHI",
+                        wind: myWind,
+                        iam: toPlayerWind(e.actor, kyoku),
+                        block: block,
+                    };
+                    return pe;
+                }
+                case "pon": {
+                    var idx = Math.abs(e.actor - e.target);
+                    if (idx == 3)
+                        idx = 0;
+                    if (idx == 2)
+                        idx = 1;
+                    if (idx == 1)
+                        idx = 2;
+                    var block = new parser_1.BlockPon([
+                        toTile(e.pai).add(constants_1.OPERATOR.HORIZONTAL),
+                        toTile(e.consumed[0]),
+                        toTile(e.consumed[1]),
+                    ]);
+                    _a = [block.tiles[idx], block.tiles[0]], block.tiles[0] = _a[0], block.tiles[idx] = _a[1];
+                    var pe = {
+                        id: _this.genID(),
+                        type: "CHI",
+                        wind: myWind,
+                        iam: toPlayerWind(e.actor, kyoku),
+                        block: block,
+                    };
+                    return pe;
+                }
+                case "daiminkan": {
+                    var idx = Math.abs(e.actor - e.target);
+                    if (idx == 3)
+                        idx = 0;
+                    if (idx == 2)
+                        idx = 1;
+                    if (idx == 1)
+                        idx = 2;
+                    var block = new parser_1.BlockDaiKan([
+                        toTile(e.pai).add(constants_1.OPERATOR.HORIZONTAL),
+                        toTile(e.consumed[0]),
+                        toTile(e.consumed[1]),
+                        toTile(e.consumed[2]),
+                    ]);
+                    _b = [block.tiles[idx], block.tiles[0]], block.tiles[0] = _b[0], block.tiles[idx] = _b[1];
+                    var pe = {
+                        id: _this.genID(),
+                        type: "CHI",
+                        wind: myWind,
+                        iam: toPlayerWind(e.actor, kyoku),
+                        block: block,
+                    };
+                    return pe;
+                }
+                case "kakan": {
+                    var block = new parser_1.BlockAnKan([
+                        toTile(e.pai).add(constants_1.OPERATOR.HORIZONTAL),
+                        toTile(e.consumed[0]).add(constants_1.OPERATOR.HORIZONTAL),
+                        toTile(e.consumed[1]),
+                        toTile(e.consumed[2]),
+                    ]);
+                    var pe = {
+                        id: _this.genID(),
+                        type: "CHI",
+                        wind: myWind,
+                        iam: toPlayerWind(e.actor, kyoku),
+                        block: block,
+                    };
+                    return pe;
+                }
+                case "hora": {
+                    if (e.actor != e.target) {
+                        var pe = {
+                            id: _this.genID(),
+                            wind: myWind,
+                            type: "RON",
+                            iam: toPlayerWind(e.actor, kyoku),
+                            targetInfo: {
+                                wind: toPlayerWind(e.target, kyoku),
+                                tile: toTile(e.pai),
+                            },
+                            pushBackReachStick: false,
+                            ret: toWinResult(e.hora_tehais, e.fan, e.fu, e.yakus, e.hora_points, e.deltas, toKyoku(pm.round)),
+                        };
+                        return pe;
+                    }
+                    else {
+                        var pe = {
+                            id: _this.genID(),
+                            wind: myWind,
+                            type: "TSUMO",
+                            iam: toPlayerWind(e.actor, kyoku),
+                            lastTile: toTile(e.pai),
+                            ret: toWinResult(e.hora_tehais, e.fan, e.fu, e.yakus, e.hora_points, e.deltas, toKyoku(pm.round)),
+                        };
+                        return pe;
+                    }
+                }
+                default:
+                    throw new Error("unexpected MJAI event ".concat(e));
+            }
+        };
+        var _a = (0, controller_1.createEventPipe)(), ce = _a[0], pe = _a[1];
+        this.from = ce;
+        this.to = pe;
+        this.player = new controller_1.Player("-1", this.to);
+        this.from.on(function (e) {
+        });
+    }
+    MJAIPlayer.prototype.react = function (e) {
+        var _this = this;
+        var events = JSON.parse(e);
+        events.forEach(function (e) {
+            _this.handle(e);
+        });
+    };
+    MJAIPlayer.prototype.handle = function (e) {
+        switch (e.type) {
+            case "start_game": {
+                this.player.id = e.id.toString();
+                break;
+            }
+            case "reach": {
+                this.reachEventRecorder[e.actor] = true;
+                break;
+            }
+            case "end_game":
+                break;
+            default:
+                var pe = this.toPlayerEvent(this.player.myWind, this.player.placeManager, e);
+                this.from.emit(pe);
+        }
+    };
+    return MJAIPlayer;
+}());
+exports.MJAIPlayer = MJAIPlayer;
+var toWinResult = function (tehais, fan, fu, yaku, hora_points, deltas, kyoku) {
+    var d = (0, controller_1.createWindMap)(0);
+    d[toPlayerWind(0, kyoku)] = deltas[0];
+    d[toPlayerWind(1, kyoku)] = deltas[1];
+    d[toPlayerWind(2, kyoku)] = deltas[2];
+    d[toPlayerWind(3, kyoku)] = deltas[3];
+    var points = yaku.map(function (v) {
+        return { double: v[1], name: v[0] };
+    });
+    var ret = {
+        deltas: d,
+        fu: fu,
+        sum: fan,
+        points: points,
+        point: hora_points,
+        hand: [],
+        params: {
+            doraMarkers: [new parser_1.Tile(constants_1.KIND.BACK, 0)],
+            round: "1w1",
+            myWind: "1w",
+        },
+    };
+    return ret;
+};
+var toPlaces = function (kyoku) {
+    return {
+        "0": toPlayerWind(0, kyoku),
+        "1": toPlayerWind(1, kyoku),
+        "2": toPlayerWind(2, kyoku),
+        "3": toPlayerWind(3, kyoku),
+    };
+};
+var toScores = function (scores) {
+    return {
+        "0": scores[0],
+        "1": scores[1],
+        "2": scores[2],
+        "3": scores[3],
+    };
+};
+var toHands = function (tehais, kyoku) {
+    var hands = (0, controller_1.createWindMap)("");
+    for (var actor = 0; actor < tehais.length; actor++) {
+        var w = toPlayerWind(actor, kyoku);
+        var tehai = tehais[actor];
+        hands[w] = toTiles(tehai).toString();
+    }
+    return hands;
+};
+var toPlayerWind = function (actor, kyoku) {
+    var idx = Math.abs(actor + 1 - kyoku) + 1;
+    return toWind(Z[idx]);
+};
+var toRound = function (b, kyoku) {
+    return "".concat(toWind(b)).concat(kyoku);
+};
+var toKyoku = function (round) {
+    return Number(round[2]);
+};
+var toWind = function (b) {
+    var idx = Z.findIndex(function (v) { return v == b; });
+    return "".concat(idx, "w");
+};
+var toBakaze = function (b) {
+    var idx = b[0];
+    return Z[Number(idx)];
+};
+var toTile = function (hai) {
+    var idx = Z.findIndex(function (v) { return v == hai; });
+    if (idx >= 0)
+        return new parser_1.Tile(constants_1.KIND.Z, idx);
+    idx = M.findIndex(function (v) { return v == hai; });
+    if (idx >= 0)
+        return new parser_1.Tile(constants_1.KIND.M, idx);
+    idx = S.findIndex(function (v) { return v == hai; });
+    if (idx >= 0)
+        return new parser_1.Tile(constants_1.KIND.S, idx);
+    idx = P.findIndex(function (v) { return v == hai; });
+    if (idx >= 0)
+        return new parser_1.Tile(constants_1.KIND.P, idx);
+    return new parser_1.Tile(constants_1.KIND.BACK, 0);
+};
+var toTiles = function (hais) {
+    var tiles = [];
+    for (var _i = 0, hais_1 = hais; _i < hais_1.length; _i++) {
+        var hai = hais_1[_i];
+        tiles.push(toTile(hai));
+    }
+    return tiles;
+};
+var toHais = function (tiles) {
+    var hais = [];
+    for (var _i = 0, tiles_1 = tiles; _i < tiles_1.length; _i++) {
+        var tile = tiles_1[_i];
+        var n = tile.n;
+        var k = tile.k;
+        if (k == constants_1.KIND.Z)
+            hais.push(Z[n]);
+        if (k == constants_1.KIND.M)
+            hais.push(M[n]);
+        if (k == constants_1.KIND.S)
+            hais.push(S[n]);
+        if (k == constants_1.KIND.P)
+            hais.push(P[n]);
+        if (k == constants_1.KIND.BACK)
+            hais.push(UNSCREEN);
+    }
+    return hais;
+};

package/dist/mjs/lib/mjimage.d.ts

@@ -5,7 +5,6 @@ interface InitializeConfig extends Omit<ImageHelperConfig, "scale"> {
     tableScale?: number;
 }
 export declare class mjimage {
-    static svgURL: () => string;
     static initialize: (props?: InitializeConfig) => void;
 }
 export {};

package/dist/mjs/lib/mjimage.js

@@ -10,19 +10,14 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mjimage = void 0;
-var assert_1 = __importDefault(require("assert"));
 var parser_1 = require("./parser");
 var image_1 = require("./image");
-var context_1 = require("./context");
+var measure_text_1 = require("./measure-text");
 var table_1 = require("./table");
 var constants_1 = require("./constants");
 var svg_js_1 = require("@svgdotjs/svg.js");
-var tiles_svg_1 = __importDefault(require("./tiles.svg"));
 var defaultQuerySelector = ".mjimage";
 var defaultScale = 1.6;
 var defaultSvgSprite = false;
@@ -34,9 +29,6 @@ var calculateScale = function (scale, textHeight) {
 var mjimage = (function () {
     function mjimage() {
     }
-    mjimage.svgURL = function () {
-        return tiles_svg_1.default;
-    };
     mjimage.initialize = function (props) {
         var _a, _b, _c, _d;
         if (props === void 0) { props = {}; }
@@ -47,8 +39,7 @@ var mjimage = (function () {
         var svgSprite = (_d = props.svgSprite) !== null && _d !== void 0 ? _d : defaultSvgSprite;
         if (typeof querySelector === "string")
             querySelector = [querySelector];
-        var ctx = document.createElement("canvas").getContext("2d");
-        (0, assert_1.default)(ctx != null);
+        var mtext = new measure_text_1.MeasureText();
         querySelector.forEach(function (qs) {
             console.debug("try to find", qs);
             var targets = document.querySelectorAll(qs);
@@ -68,7 +59,7 @@ var mjimage = (function () {
                 try {
                     if (tableRegex.test(input)) {
                         var scale = calculateScale(tableScale, textHeight);
-                        var fontCtx = (0, context_1.getTableFontContext)(ctx, scale);
+                        var fontCtx = mtext.measureTableFontContext(scale);
                         (0, table_1.drawTable)(svg, input, __assign(__assign({}, props), { svgSprite: svgSprite, scale: scale }), fontCtx);
                     }
                     else {

package/dist/mjs/lib/parser.d.ts

@@ -1,14 +1,20 @@
-import { BLOCK, OPERATOR, KIND } from "./constants";
+import { BLOCK, OPERATOR, KIND, INPUT_SEPARATOR } from "./constants";
+type Separator = typeof INPUT_SEPARATOR;
 export declare const tileSortFunc: (i: Tile, j: Tile) => number;
-type Kind = (typeof KIND)[keyof typeof KIND];
+export type Kind = (typeof KIND)[keyof typeof KIND];
 export declare function isKind(v: string): [Kind, boolean];
 type Operator = (typeof OPERATOR)[keyof typeof OPERATOR];
 export declare class Tile {
     k: Kind;
     n: number;
-    op?: Operator | undefined;
-    constructor(k: Kind, n: number, op?: Operator | undefined);
+    ops: Operator[];
+    constructor(k: Kind, n: number, ops?: Operator[]);
     toString(): string;
+    clone(): Tile;
+    has(op: Operator): boolean;
+    add(op: Operator): Tile;
+    remove(op: Operator): Tile;
+    isNum(): boolean;
     equals(t: Tile, ignoreRed?: boolean): boolean;
 }
 type BLOCK = (typeof BLOCK)[keyof typeof BLOCK];
@@ -17,13 +23,51 @@ export declare class Block {
     type: BLOCK;
     constructor(tiles: Tile[], type: BLOCK);
     toString(): string;
+    is(type: BLOCK): boolean;
+    isCalled(): boolean;
+    equals(b: Block): boolean;
+    minTile(): Tile;
+    clone(): Block | BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan | BlockPair | BlockSet | BlockIsolated;
 }
+export declare class BlockChi extends Block {
+    constructor(tiles: [Tile, Tile, Tile]);
+}
+export declare class BlockPon extends Block {
+    constructor(tiles: [Tile, Tile, Tile]);
+}
+export declare class BlockAnKan extends Block {
+    constructor(tiles: Tile[]);
+    toString(): string;
+}
+export declare class BlockDaiKan extends Block {
+    constructor(tiles: Tile[]);
+}
+export declare class BlockShoKan extends Block {
+    constructor(tiles: Tile[]);
+}
+export declare class BlockPair extends Block {
+    constructor(tile1: Tile, tile2: Tile);
+}
+declare class BlockSet extends Block {
+    constructor(tiles: [Tile, Tile, Tile]);
+}
+export declare class BlockThree extends BlockSet {
+    constructor(tiles: [Tile, Tile, Tile]);
+}
+export declare class BlockRun extends BlockSet {
+    constructor(tiles: [Tile, Tile, Tile]);
+}
+export declare class BlockIsolated extends Block {
+    constructor(tile: Tile);
+}
+export declare const blockWrapper: (tiles: Tile[], type: BLOCK) => Block | BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan | BlockPair | BlockSet | BlockIsolated;
 export declare class Parser {
     readonly input: string;
-    readonly maxInputLength = 128;
+    readonly maxInputLength = 600;
     constructor(input: string);
-    parse(): Block[];
-    parseInput(): Tile[];
+    parse(): (Block | BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan)[];
+    tiles(): Tile[];
+    tileSeparators(): (Tile | Separator)[];
     private makeBlocks;
     validate(input: string): void;
 }