@konoui/mjimage 0.0.1 → 0.0.2

package/README.md

@@ -1,4 +1,4 @@
-[![npm version](https://badge.fury.io/js/@konoui%2Fmj-image.svg)](https://badge.fury.io/js/@konoui%2Fmj-image)
+[![npm version](https://badge.fury.io/js/@konoui%2Fmjimage.svg)](https://badge.fury.io/js/@konoui%2Fmjimage)
 
 ## 麻雀牌ジェネレーター
 
@@ -28,7 +28,7 @@
 | ,    | ブロックの塊を表す                 | 123,-123    |
 | t    | ツモ牌を表す                       | 123,t3p     |
 | d    | ドラ牌を表す                       | 123,t3p,d4p |
-| g    | ツモ切りを表す（牌の色が暗くなる） | 3g56m       |
+| ^    | ツモ切りを表す（牌の色が暗くなる） | 3^56m       |
 
 ### 入力例
 

package/dist/mjs/cmd/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mjs/cmd/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+var controller_1 = require("./../lib/controller");
+var replay_1 = require("../lib/controller/replay");
+var helper_1 = require("./../lib/__tests__/utils/helper");
+var type = process.argv[2];
+if (!["test", "single", "game"].includes(type))
+    throw new Error("unexpected type");
+var count = (_a = Number(process.argv[3])) !== null && _a !== void 0 ? _a : 1;
+var filename = "games.json";
+if (type == "test") {
+    var games = (0, helper_1.loadArrayData)(filename);
+    for (var _i = 0, games_1 = games; _i < games_1.length; _i++) {
+        var game = games_1[_i];
+        var r = new replay_1.Replayer(game);
+        r.auto();
+    }
+}
+if (type == "game" || type == "single") {
+    for (var i = 0; i < count; i++) {
+        console.debug("".concat(type, "(").concat(i, ")==="));
+        var c = (0, controller_1.createLocalGame)();
+        var starter = factory(c, type);
+        subscribeError(c);
+        try {
+            starter();
+        }
+        catch (e) {
+            console.error("Error", e);
+            (0, helper_1.storeArrayData)(filename, c.export());
+        }
+    }
+}
+function factory(c, type) {
+    if (type == "single")
+        return function () { return c.start(); };
+    else
+        return function () { return c.startGame(); };
+}
+function subscribeError(c) {
+    c.actor.subscribe({
+        error: function (err) {
+            console.error("Error", err);
+            (0, helper_1.storeArrayData)(filename, c.export());
+            process.exit(1);
+        },
+    });
+}

package/dist/mjs/index.d.ts

@@ -1,6 +1,6 @@
 export * from "./lib/mjimage";
 export * from "./lib/constants";
-export * from "./lib/context";
+export * from "./lib/measure-text";
 export * from "./lib/lexer";
 export * from "./lib/image";
 export * from "./lib/parser";

package/dist/mjs/index.js

@@ -16,7 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./lib/mjimage"), exports);
 __exportStar(require("./lib/constants"), exports);
-__exportStar(require("./lib/context"), exports);
+__exportStar(require("./lib/measure-text"), exports);
 __exportStar(require("./lib/lexer"), exports);
 __exportStar(require("./lib/image"), exports);
 __exportStar(require("./lib/parser"), exports);

package/dist/mjs/lib/calculator/index.d.ts

@@ -0,0 +1,284 @@
+import { KIND, Round, Wind } from "../constants";
+import { Tile, BlockPon, BlockChi, BlockShoKan, BlockAnKan, BlockDaiKan, Kind, Block } from "../parser";
+type FixedNumber = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export interface HandData {
+    [KIND.M]: FixedNumber;
+    [KIND.S]: FixedNumber;
+    [KIND.P]: FixedNumber;
+    [KIND.Z]: [number, number, number, number, number, number, number, number];
+    [KIND.BACK]: [number];
+    called: (BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan)[];
+    tsumo: Tile | null;
+    reached: boolean;
+}
+export declare class Hand {
+    private data;
+    constructor(input: string);
+    private init;
+    get hands(): Tile[];
+    toString(): string;
+    get called(): (BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan)[];
+    get reached(): boolean;
+    get drawn(): Tile | null;
+    get menzen(): boolean;
+    getArrayLen(k: Kind): 1 | 8 | 10;
+    sum(k: Kind): number;
+    get(k: Kind, n: number): number;
+    inc(tiles: Tile[]): Tile[];
+    dec(tiles: Tile[]): Tile[];
+    draw(t: Tile): void;
+    discard(t: Tile): void;
+    reach(): void;
+    call(b: BlockPon | BlockChi | BlockDaiKan): void;
+    kan(b: BlockAnKan | BlockShoKan): void;
+    get canReach(): boolean;
+    clone(): Hand;
+}
+export declare class ShantenCalculator {
+    hand: Hand;
+    constructor(hand: Hand);
+    calc(): number;
+    sevenPairs(): number;
+    thirteenOrphans(): number;
+    fourSetsOnePair(): number;
+    private commonByKind;
+    private groupRemainingTiles;
+    private calcCommon;
+}
+export declare class ExShantenCalculator {
+    h: Hand;
+    private c;
+    constructor(h: Hand);
+    menzen(): number;
+    yakuhai(): number;
+    tanyao(): void;
+}
+export declare class TileCalculator {
+    hand: Hand;
+    constructor(hand: Hand);
+    calc(lastTile: Tile): Block[][];
+    markDrawn(hands: Block[][], lastTile: Tile): Block[][];
+    sevenPairs(): Block[][];
+    thirteenOrphans(): Block[][];
+    nineGates(): Block[][];
+    fourSetsOnePair(): Block[][];
+    private commonAll;
+    private commonByKind;
+}
+export interface BoardParams {
+    doraMarkers: Tile[];
+    blindDoraMarkers?: Tile[];
+    round: Round;
+    myWind: Wind;
+    ronWind?: Wind;
+    sticks?: {
+        reach: number;
+        dead: number;
+    };
+    reached?: 1 | 2;
+    replacementWin?: boolean;
+    quadWin?: boolean;
+    finalWallWin?: boolean;
+    finalDiscardWin?: boolean;
+    oneShotWin?: boolean;
+}
+export interface WinResult {
+    deltas: {
+        [w in Wind]: number;
+    };
+    sum: number;
+    fu: number;
+    points: {
+        name: string;
+        double: number;
+    }[];
+    point: number;
+    hand: Block[];
+    params: BoardParams;
+}
+export declare class DoubleCalculator {
+    hand: Hand;
+    cfg: {
+        doras: Tile[];
+        blindDoras: Tile[];
+        roundWind: Tile;
+        myWind: Tile;
+        reached: 0 | 1 | 2;
+        sticks: {
+            reach: number;
+            dead: number;
+        };
+        replacementWin: boolean;
+        quadWin: boolean;
+        finalWallWin: boolean;
+        finalDiscardWin: boolean;
+        oneShotWin: boolean;
+        orig: BoardParams;
+    };
+    constructor(hand: Hand, params: BoardParams);
+    calc(hands: Block[][]): WinResult | false;
+    calcPatterns(hands: Block[][]): {
+        points: {
+            name: string;
+            double: number;
+        }[];
+        fu: number;
+        hand: Block[];
+    }[];
+    private minus;
+    dA1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dB1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dC1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dD1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dE1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dF1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dG1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dH1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dI1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dJ1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dK1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dX1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dA2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dB2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dC2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dD2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dE2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dF2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dG2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dH2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dI2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dJ2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dA3(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dB3(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dC3(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dA6(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dA13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dB13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dC13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dD13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dE13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dF13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dG13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dH13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dI13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dJ13(h: Block[]): never[];
+    dK13(h: Block[]): never[];
+    calcFu(h: Block[]): number;
+}
+export {};