@konoui/mjimage 0.0.13 → 0.0.15

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

@@ -0,0 +1,19 @@
+import { Tile } from "../core/parser";
+import { Hand } from "../calculator";
+export interface Candidate {
+    tile: Tile;
+    candidates: Tile[];
+    shanten: number;
+}
+export declare class Efficiency {
+    static calcCandidates(hand: Hand, choices: Tile[]): Candidate[];
+    static candidateTiles(hand: Hand): {
+        shanten: number;
+        candidates: Tile[];
+    };
+    static partialCandidateTiles(input: string): {
+        shanten: number;
+        candidates: Tile[];
+    };
+    static partialShanten(input: string): number;
+}

package/dist/mjs/lib/calculator/efficiency.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Efficiency = void 0;
+var assert_1 = __importDefault(require("assert"));
+var constants_1 = require("../core/constants");
+var parser_1 = require("../core/parser");
+var calculator_1 = require("../calculator");
+var Efficiency = (function () {
+    function Efficiency() {
+    }
+    Efficiency.calcCandidates = function (hand, choices) {
+        (0, assert_1.default)(choices.length > 0, "choices to discard is zero");
+        var ret = [];
+        for (var _i = 0, choices_1 = choices; _i < choices_1.length; _i++) {
+            var t = choices_1[_i];
+            var tiles = hand.dec([t]);
+            var c = Efficiency.candidateTiles(hand);
+            hand.inc(tiles);
+            if (ret.length == 0 || c.shanten < ret[0].shanten) {
+                ret = [
+                    {
+                        shanten: c.shanten,
+                        candidates: c.candidates,
+                        tile: t,
+                    },
+                ];
+            }
+            else if (c.shanten == ret[0].shanten) {
+                ret.push({
+                    candidates: c.candidates,
+                    shanten: c.shanten,
+                    tile: t,
+                });
+            }
+        }
+        return ret;
+    };
+    Efficiency.candidateTiles = function (hand) {
+        var r = Number.POSITIVE_INFINITY;
+        var candidates = [];
+        var sc = new calculator_1.ShantenCalculator(hand);
+        for (var _i = 0, _a = Object.values(constants_1.TYPE); _i < _a.length; _i++) {
+            var t = _a[_i];
+            if (t == constants_1.TYPE.BACK)
+                continue;
+            for (var n = 1; n < hand.getArrayLen(t); n++) {
+                if (hand.get(t, n) >= 4)
+                    continue;
+                var tile = new parser_1.Tile(t, n);
+                var tiles = hand.inc([tile]);
+                var s = sc.calc();
+                hand.dec(tiles);
+                if (s < r) {
+                    r = s;
+                    candidates = [tile];
+                }
+                else if (s == r)
+                    candidates.push(tile);
+            }
+        }
+        return {
+            shanten: r,
+            candidates: candidates,
+        };
+    };
+    Efficiency.partialCandidateTiles = function (input) {
+        var h = new calculator_1.Hand(input, true);
+        Array(13 - h.hands.length)
+            .fill(undefined)
+            .map(function () { return h.inc([new parser_1.Tile(constants_1.TYPE.BACK, 0)]); });
+        return Efficiency.candidateTiles(h);
+    };
+    Efficiency.partialShanten = function (input) {
+        var h = new calculator_1.Hand(input, true);
+        Array(13 - h.hands.length)
+            .fill(undefined)
+            .map(function () { return h.inc([new parser_1.Tile(constants_1.TYPE.BACK, 0)]); });
+        var sc = new calculator_1.ShantenCalculator(h);
+        return sc.calc();
+    };
+    return Efficiency;
+}());
+exports.Efficiency = Efficiency;

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

@@ -1,263 +1,2 @@
-import { TYPE, Round, Wind } from "../constants";
-import { Tile, BlockPon, BlockChi, BlockShoKan, BlockAnKan, BlockDaiKan, Type, Block } from "../parser";
-export type TupleOfSize<T, N extends number, R extends unknown[] = []> = R["length"] extends N ? R : TupleOfSize<T, N, [T, ...R]>;
-export interface HandData {
-    [TYPE.M]: TupleOfSize<number, 10>;
-    [TYPE.S]: TupleOfSize<number, 10>;
-    [TYPE.P]: TupleOfSize<number, 10>;
-    [TYPE.Z]: TupleOfSize<number, 8>;
-    [TYPE.BACK]: [string, number];
-    called: (BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan)[];
-    tsumo: Tile | null;
-    reached: boolean;
-}
-export declare class Hand {
-    private data;
-    constructor(input: string, allowBackBlock?: boolean);
-    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(t: Type): 2 | 8 | 10;
-    sum(t: Type): number;
-    get(t: Type, 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;
-    clone(): Hand;
-}
-export declare class ShantenCalculator {
-    hand: Hand;
-    constructor(hand: Hand);
-    calc(): number;
-    sevenPairs(): number;
-    thirteenOrphans(): number;
-    fourSetsOnePair(): number;
-    private commonByType;
-    private groupRemainingTiles;
-    private calcCommon;
-}
-export declare class BlockCalculator {
-    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 commonByType;
-}
-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 * from "./calc";
+export * from "./efficiency";