@pai-forge/riichi-mahjong 0.2.0 → 0.3.0

package/dist/features/yaku/lib/definitions/ryuuiisou.js

@@ -0,0 +1,43 @@
+import { createYakuDefinition } from "../../factory";
+import { HaiKind } from "../../../../types";
+const RYUUIISOU_YAKU = {
+    name: "Ryuuiisou",
+    han: {
+        open: 13,
+        closed: 13,
+    },
+};
+const GREEN_TILES = new Set([
+    HaiKind.SouZu2,
+    HaiKind.SouZu3,
+    HaiKind.SouZu4,
+    HaiKind.SouZu6,
+    HaiKind.SouZu8,
+    HaiKind.Hatsu,
+]);
+const isGreen = (id) => {
+    return GREEN_TILES.has(id);
+};
+const checkRyuuiisou = (hand) => {
+    const allHais = [];
+    if (hand.type === "Mentsu") {
+        // 面子手の場合
+        for (const mentsu of hand.fourMentsu) {
+            allHais.push(...mentsu.hais);
+        }
+        allHais.push(...hand.jantou.hais);
+    }
+    else if (hand.type === "Chiitoitsu") {
+        // 七対子の場合
+        for (const pair of hand.pairs) {
+            allHais.push(...pair.hais);
+        }
+    }
+    else {
+        // 国士無双など
+        return false;
+    }
+    // 全ての牌が緑色牌であれば成立
+    return allHais.every(isGreen);
+};
+export const ryuuiisouDefinition = createYakuDefinition(RYUUIISOU_YAKU, checkRyuuiisou);

package/dist/features/yaku/lib/definitions/sanankou.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const sanankouDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/sanankou.js

@@ -0,0 +1,49 @@
+import { createYakuDefinition } from "../../factory";
+const SANANKOU_YAKU = {
+    name: "Sanankou",
+    han: {
+        open: 2,
+        closed: 2,
+    },
+};
+const checkSanankou = (hand, context) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    // 1. 刻子・槓子を抽出
+    const triplets = hand.fourMentsu.filter((m) => m.type === "Koutsu" || m.type === "Kantsu");
+    let ankouCount = 0;
+    for (const triplet of triplets) {
+        // 副露している刻子は暗刻ではない
+        if (triplet.furo)
+            continue;
+        const isAgariHaiInTriplet = triplet.hais.includes(context.agariHai);
+        // ロン和了の場合、和了牌を含む刻子は明刻扱いとなる（シャボ待ちの場合）。
+        // ただし、単騎待ちの場合は暗刻扱いとなる。
+        // 単騎待ちかどうかの判定: 雀頭の牌が和了牌と同じかどうか
+        const isTanki = hand.jantou.hais[0] === context.agariHai;
+        if (context.isTsumo) {
+            // ツモなら、副露していなければ全て暗刻
+            ankouCount++;
+        }
+        else {
+            // ロン和了の場合
+            if (isAgariHaiInTriplet) {
+                // 和了牌を含む刻子の場合
+                if (isTanki) {
+                    // 単騎待ちなら暗刻
+                    ankouCount++;
+                }
+                else {
+                    // シャボ（等の）待ちでロンした場合は明刻扱いなのでカウントしない
+                }
+            }
+            else {
+                // 和了牌を含まない刻子は暗刻
+                ankouCount++;
+            }
+        }
+    }
+    return ankouCount >= 3;
+};
+export const sanankouDefinition = createYakuDefinition(SANANKOU_YAKU, checkSanankou);

package/dist/features/yaku/lib/definitions/sankantsu.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const sankantsuDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/sankantsu.js

@@ -0,0 +1,18 @@
+import { createYakuDefinition } from "../../factory";
+const SANKANTSU_YAKU = {
+    name: "Sankantsu",
+    han: {
+        open: 2,
+        closed: 2,
+    },
+};
+const checkSankantsu = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    // 1. 槓子を抽出
+    const kantsuList = hand.fourMentsu.filter((m) => m.type === "Kantsu");
+    // 2. 槓子が3つ以上あれば成立
+    return kantsuList.length >= 3;
+};
+export const sankantsuDefinition = createYakuDefinition(SANKANTSU_YAKU, checkSankantsu);

package/dist/features/yaku/lib/definitions/sanshoku-doujun.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const sanshokuDoujunDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/sanshoku-doujun.js

@@ -0,0 +1,58 @@
+import { createYakuDefinition } from "../../factory";
+const SANSHOKU_DOUJUN_YAKU = {
+    name: "SanshokuDoujun",
+    han: {
+        open: 1,
+        closed: 2,
+    },
+};
+const checkSanshokuDoujun = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    const shuntsuList = hand.fourMentsu.filter((mentsu) => mentsu.type === "Shuntsu");
+    if (shuntsuList.length < 3) {
+        return false;
+    }
+    // 順子リストから3つの組み合わせを全てチェックし、三色同順の条件を満たすものを探す
+    // 条件:
+    // 1. 3つの順子がそれぞれ異なる色（萬子、筒子、索子）であること
+    // 2. 3つの順子の構成数字が同じであること（例: 123m, 123p, 123s）
+    // ヘルパーロジック:
+    // HaiKindId の範囲: 0-8 (ManZu), 9-17 (PinZu), 18-26 (SouZu)
+    // 9で割った商が色（0, 1, 2）、余りが数値（0-8）を表す
+    for (let i = 0; i < shuntsuList.length; i++) {
+        for (let j = i + 1; j < shuntsuList.length; j++) {
+            for (let k = j + 1; k < shuntsuList.length; k++) {
+                const s1 = shuntsuList[i];
+                const s2 = shuntsuList[j];
+                const s3 = shuntsuList[k];
+                if (!s1 || !s2 || !s3)
+                    continue;
+                const firstHai1 = s1.hais[0];
+                const firstHai2 = s2.hais[0];
+                const firstHai3 = s3.hais[0];
+                const suit1 = Math.floor(firstHai1 / 9);
+                const suit2 = Math.floor(firstHai2 / 9);
+                const suit3 = Math.floor(firstHai3 / 9);
+                // 異なる色（0, 1, 2）でなければならない
+                const suits = new Set([suit1, suit2, suit3]);
+                if (suits.size !== 3)
+                    continue;
+                // 全て数牌（0, 1, 2）でなければならない
+                // ※通常、Shuntsuに字牌は含まれないが、念のためチェック
+                if (suit1 > 2 || suit2 > 2 || suit3 > 2)
+                    continue;
+                // 数値（インデックス）が一致するかチェック
+                const num1 = firstHai1 % 9;
+                const num2 = firstHai2 % 9;
+                const num3 = firstHai3 % 9;
+                if (num1 === num2 && num2 === num3) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+export const sanshokuDoujunDefinition = createYakuDefinition(SANSHOKU_DOUJUN_YAKU, checkSanshokuDoujun);

package/dist/features/yaku/lib/definitions/sanshoku-doukou.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const sanshokuDoukouDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/sanshoku-doukou.js

@@ -0,0 +1,53 @@
+import { createYakuDefinition } from "../../factory";
+const SANSHOKU_DOUKOU_YAKU = {
+    name: "SanshokuDoukou",
+    han: {
+        open: 2,
+        closed: 2,
+    },
+};
+const checkSanshokuDoukou = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    // 1. 刻子・槓子を抽出
+    const triplets = hand.fourMentsu.filter((m) => m.type === "Koutsu" || m.type === "Kantsu");
+    if (triplets.length < 3) {
+        return false;
+    }
+    // 2. 刻子の組み合わせ(3つ)をチェック
+    for (let i = 0; i < triplets.length; i++) {
+        for (let j = i + 1; j < triplets.length; j++) {
+            for (let k = j + 1; k < triplets.length; k++) {
+                const t1 = triplets[i];
+                const t2 = triplets[j];
+                const t3 = triplets[k];
+                if (!t1 || !t2 || !t3)
+                    continue;
+                const id1 = t1.hais[0];
+                const id2 = t2.hais[0];
+                const id3 = t3.hais[0];
+                // 字牌が含まれていたら対象外 (字牌ID >= 27)
+                if (id1 >= 27 || id2 >= 27 || id3 >= 27)
+                    continue;
+                const suit1 = Math.floor(id1 / 9);
+                const suit2 = Math.floor(id2 / 9);
+                const suit3 = Math.floor(id3 / 9);
+                // ※ 0:萬子, 1:筒子, 2:索子
+                const suits = new Set([suit1, suit2, suit3]);
+                // 異なる3色でなければならない
+                if (suits.size !== 3)
+                    continue;
+                const num1 = id1 % 9;
+                const num2 = id2 % 9;
+                const num3 = id3 % 9;
+                // 同じ数字でなければならない
+                if (num1 === num2 && num2 === num3) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+export const sanshokuDoukouDefinition = createYakuDefinition(SANSHOKU_DOUKOU_YAKU, checkSanshokuDoukou);

package/dist/features/yaku/lib/definitions/shousangen.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const shousangenDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/shousangen.js

@@ -0,0 +1,28 @@
+import { createYakuDefinition } from "../../factory";
+import { HaiKind } from "../../../../types";
+const SHOUSANGEN_YAKU = {
+    name: "Shousangen",
+    han: {
+        open: 2,
+        closed: 2,
+    },
+};
+const checkShousangen = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    const sangenpai = [HaiKind.Haku, HaiKind.Hatsu, HaiKind.Chun];
+    // 1. 三元牌の刻子・槓子をカウント
+    let sangenKoutsuCount = 0;
+    const triplets = hand.fourMentsu.filter((m) => m.type === "Koutsu" || m.type === "Kantsu");
+    for (const triplet of triplets) {
+        if (sangenpai.includes(triplet.hais[0])) {
+            sangenKoutsuCount++;
+        }
+    }
+    // 2. 三元牌の雀頭があるかチェック
+    const isSangenJantou = sangenpai.includes(hand.jantou.hais[0]);
+    // 小三元の条件: 三元牌の刻子が2つ かつ 三元牌の雀頭が1つ
+    return sangenKoutsuCount === 2 && isSangenJantou;
+};
+export const shousangenDefinition = createYakuDefinition(SHOUSANGEN_YAKU, checkShousangen);

package/dist/features/yaku/lib/definitions/shousuushii.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const shousuushiiDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/shousuushii.js

@@ -0,0 +1,34 @@
+import { createYakuDefinition } from "../../factory";
+import { HaiKind } from "../../../../types";
+const SHOUSUUSHII_YAKU = {
+    name: "Shousuushii",
+    han: {
+        open: 13,
+        closed: 13,
+    },
+};
+const checkShousuushii = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    const windTiles = [
+        HaiKind.Ton,
+        HaiKind.Nan,
+        HaiKind.Sha,
+        HaiKind.Pei,
+    ];
+    // 1. 風牌の刻子・槓子をカウント
+    let windKoutsuCount = 0;
+    const triplets = hand.fourMentsu.filter((m) => m.type === "Koutsu" || m.type === "Kantsu");
+    for (const triplet of triplets) {
+        if (windTiles.includes(triplet.hais[0])) {
+            windKoutsuCount++;
+        }
+    }
+    // 2. 風牌の雀頭があるかチェック
+    const isWindJantou = windTiles.includes(hand.jantou.hais[0]);
+    // 小四喜の条件: 風牌の刻子が3つ かつ 風牌の雀頭が1つ
+    // (合計で4種類の風牌が揃うことになる。例: 東東東 南南南 西西西 北北)
+    return windKoutsuCount === 3 && isWindJantou;
+};
+export const shousuushiiDefinition = createYakuDefinition(SHOUSUUSHII_YAKU, checkShousuushii);

package/dist/features/yaku/lib/definitions/suuankou.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const suuankouDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/suuankou.js

@@ -0,0 +1,63 @@
+const SUUANKOU_YAKU = {
+    name: "Suuankou",
+    han: {
+        open: 0, // 門前限定（構造上必然的にそうなるが、定義としても門前）
+        closed: 13, // 通常役満(13) または ダブル役満(26)
+    },
+};
+const checkSuuankou = (hand, context) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    // 1. 刻子・槓子を抽出
+    const triplets = hand.fourMentsu.filter((m) => m.type === "Koutsu" || m.type === "Kantsu");
+    let ankouCount = 0;
+    for (const triplet of triplets) {
+        // 副露している刻子は暗刻ではない
+        if (triplet.furo)
+            continue;
+        const isAgariHaiInTriplet = triplet.hais.includes(context.agariHai);
+        const isTanki = hand.jantou.hais[0] === context.agariHai;
+        if (context.isTsumo) {
+            // ツモなら、副露していなければ全て暗刻
+            ankouCount++;
+        }
+        else {
+            // ロン和了の場合
+            if (isAgariHaiInTriplet) {
+                // 和了牌を含む刻子（シャボ待ちロン）は明刻
+                // 単騎待ちロンなら暗刻
+                if (isTanki) {
+                    ankouCount++;
+                }
+            }
+            else {
+                // 和了牌を含まない刻子は暗刻
+                ankouCount++;
+            }
+        }
+    }
+    return ankouCount === 4;
+};
+// 四暗刻はダブル役満（単騎待ち）判定が必要なため、
+// createYakuDefinitionのデフォルトのgetHansuロジックをオーバーライドするか、
+// このcheck関数内で判定してフラグを渡すなどの工夫が必要。
+// しかし createYakuDefinition は boolean を返す check 関数しか受け取らない。
+// ここでは factory 側を拡張するのではなく、この定義でカスタム実装を行うか、
+// あるいは factory を通さずに直接 YakuDefinition を作る。
+// factoryの改修はスコープ外のため、ここではオブジェクトリテラルで定義を作成する。
+export const suuankouDefinition = {
+    yaku: SUUANKOU_YAKU,
+    isSatisfied: (hand, context) => checkSuuankou(hand, context),
+    getHansu: (hand, context) => {
+        if (!checkSuuankou(hand, context))
+            return 0;
+        // 四暗刻単騎の判定
+        const isTanki = hand.type === "Mentsu" && hand.jantou.hais[0] === context.agariHai;
+        // 単騎待ちならダブル役満(26)
+        if (isTanki) {
+            return 26;
+        }
+        return 13;
+    },
+};

package/dist/features/yaku/lib/definitions/suukantsu.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const suukantsuDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/suukantsu.js

@@ -0,0 +1,18 @@
+import { createYakuDefinition } from "../../factory";
+const SUUKANTSU_YAKU = {
+    name: "Suukantsu",
+    han: {
+        open: 13,
+        closed: 13,
+    },
+};
+const checkSuukantsu = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    // 1. 槓子を抽出
+    const kantsuList = hand.fourMentsu.filter((m) => m.type === "Kantsu");
+    // 2. 槓子が4つあれば成立
+    return kantsuList.length === 4;
+};
+export const suukantsuDefinition = createYakuDefinition(SUUKANTSU_YAKU, checkSuukantsu);

package/dist/features/yaku/lib/definitions/tanyao.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const tanyaoDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/tanyao.js

@@ -0,0 +1,23 @@
+import { isYaochu } from "../../../../core/hai";
+import { createYakuDefinition } from "../../factory";
+const TANYAO_YAKU = {
+    name: "Tanyao",
+    han: {
+        open: 1,
+        closed: 1,
+    },
+};
+const checkTanyao = (hand) => {
+    if (hand.type !== "Mentsu")
+        return false;
+    // 雀頭のチェック
+    if (isYaochu(hand.jantou.hais[0]))
+        return false;
+    // 面子のチェック
+    for (const mentsu of hand.fourMentsu) {
+        if (mentsu.hais.some(isYaochu))
+            return false;
+    }
+    return true;
+};
+export const tanyaoDefinition = createYakuDefinition(TANYAO_YAKU, checkTanyao);

package/dist/features/yaku/lib/definitions/toitoi.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const toitoiDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/toitoi.js

@@ -0,0 +1,16 @@
+import { createYakuDefinition } from "../../factory";
+const TOITOI_YAKU = {
+    name: "Toitoi",
+    han: {
+        open: 2,
+        closed: 2,
+    },
+};
+const checkToitoi = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    // 全ての面子が刻子（Koutsu）または槓子（Kantsu）であることを確認
+    return hand.fourMentsu.every((mentsu) => mentsu.type === "Koutsu" || mentsu.type === "Kantsu");
+};
+export const toitoiDefinition = createYakuDefinition(TOITOI_YAKU, checkToitoi);

package/dist/features/yaku/lib/definitions/tsuuiisou.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const tsuuiisouDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/tsuuiisou.js

@@ -0,0 +1,35 @@
+import { createYakuDefinition } from "../../factory";
+import { HaiKind } from "../../../../types";
+const TSUUIISOU_YAKU = {
+    name: "Tsuuiisou",
+    han: {
+        open: 13,
+        closed: 13,
+    },
+};
+const isJihai = (id) => {
+    return id >= HaiKind.Ton && id <= HaiKind.Chun;
+};
+const checkTsuuiisou = (hand) => {
+    const allHais = [];
+    if (hand.type === "Mentsu") {
+        // 面子手の場合
+        for (const mentsu of hand.fourMentsu) {
+            allHais.push(...mentsu.hais);
+        }
+        allHais.push(...hand.jantou.hais);
+    }
+    else if (hand.type === "Chiitoitsu") {
+        // 七対子の場合
+        for (const pair of hand.pairs) {
+            allHais.push(...pair.hais);
+        }
+    }
+    else {
+        // 国士無双など（国士は字一色にはなり得ないが、構造上は考慮）
+        return false;
+    }
+    // 全ての牌が字牌であれば成立
+    return allHais.every(isJihai);
+};
+export const tsuuiisouDefinition = createYakuDefinition(TSUUIISOU_YAKU, checkTsuuiisou);

package/dist/features/yaku/lib/definitions/yakuhai.d.ts

@@ -0,0 +1,4 @@
+import type { YakuDefinition } from "../../types";
+export declare const hakuDefinition: YakuDefinition;
+export declare const hatsuDefinition: YakuDefinition;
+export declare const chunDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/yakuhai.js

@@ -0,0 +1,21 @@
+import { HaiKind } from "../../../../types";
+import { createYakuDefinition } from "../../factory";
+function createYakuhaiDefinition(name, tile) {
+    const HAN_CONFIG = { closed: 1, open: 1 };
+    const check = (hand) => {
+        if (hand.type !== "Mentsu")
+            return false;
+        for (const mentsu of hand.fourMentsu) {
+            if (mentsu.type === "Koutsu" || mentsu.type === "Kantsu") {
+                if (mentsu.hais[0] === tile) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    return createYakuDefinition({ name, han: HAN_CONFIG }, check);
+}
+export const hakuDefinition = createYakuhaiDefinition("Haku", HaiKind.Haku);
+export const hatsuDefinition = createYakuhaiDefinition("Hatsu", HaiKind.Hatsu);
+export const chunDefinition = createYakuhaiDefinition("Chun", HaiKind.Chun);

package/dist/features/yaku/lib/index.d.ts

@@ -0,0 +1 @@
+export * from "./definitions";

package/dist/features/yaku/lib/index.js

@@ -0,0 +1 @@
+export * from "./definitions";

package/dist/features/yaku/lib/structures/chiitoitsu.d.ts

@@ -0,0 +1,6 @@
+import type { Tehai14 } from "../../../../types";
+import type { ChiitoitsuHouraStructure } from "../../types";
+/**
+ * 手牌を七対子（7つの対子）として構造化する。
+ */
+export declare function getHouraStructuresForChiitoitsu(tehai: Tehai14): ChiitoitsuHouraStructure[];

package/dist/features/yaku/lib/structures/chiitoitsu.js

@@ -0,0 +1,38 @@
+import { countHaiKind } from "../../../../core/tehai";
+/**
+ * 手牌を七対子（7つの対子）として構造化する。
+ */
+export function getHouraStructuresForChiitoitsu(tehai) {
+    // 七対子は門前のみ（定義によっては鳴きも許容する場合があるが、一般的には門前）
+    if (tehai.exposed.length > 0)
+        return [];
+    const counts = countHaiKind(tehai.closed);
+    const pairs = [];
+    for (let i = 0; i < 34; i++) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const kind = i;
+        const count = counts[kind];
+        if (count === 2) {
+            pairs.push({ type: "Toitsu", hais: [kind, kind] });
+        }
+        else if (count === 4) {
+            // 4枚使いの七対子を認めるか（ローカルルール次第だが、通常は認めない）
+            // ここでは標準的なルールに従い、4枚あっても2対子とはみなさない実装とする
+            // ※4枚使い七対子を実装する場合は pairs.push(...) を2回行う
+            return [];
+        }
+        else if (count > 0) {
+            // 2枚でない牌がある場合は七対子不成立
+            return [];
+        }
+    }
+    if (pairs.length !== 7)
+        return [];
+    return [
+        {
+            type: "Chiitoitsu",
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            pairs: pairs,
+        },
+    ];
+}

package/dist/features/yaku/lib/structures/index.d.ts

@@ -0,0 +1,10 @@
+import type { Tehai14 } from "../../../../types";
+import type { HouraStructure } from "../../types";
+export * from "./mentsu-te";
+export * from "./chiitoitsu";
+export * from "./kokushi";
+/**
+ * 手牌をすべての可能な和了形に構造化する。
+ * 面子手、七対子、国士無双の全ての可能性を探索する。
+ */
+export declare function getHouraStructures(tehai: Tehai14): HouraStructure[];

package/dist/features/yaku/lib/structures/index.js

@@ -0,0 +1,17 @@
+import { getHouraStructuresForMentsuTe } from "./mentsu-te";
+import { getHouraStructuresForChiitoitsu } from "./chiitoitsu";
+import { getHouraStructuresForKokushi } from "./kokushi";
+export * from "./mentsu-te";
+export * from "./chiitoitsu";
+export * from "./kokushi";
+/**
+ * 手牌をすべての可能な和了形に構造化する。
+ * 面子手、七対子、国士無双の全ての可能性を探索する。
+ */
+export function getHouraStructures(tehai) {
+    return [
+        ...getHouraStructuresForMentsuTe(tehai),
+        ...getHouraStructuresForChiitoitsu(tehai),
+        ...getHouraStructuresForKokushi(tehai),
+    ];
+}

package/dist/features/yaku/lib/structures/kokushi.d.ts

@@ -0,0 +1,6 @@
+import type { Tehai14 } from "../../../../types";
+import type { KokushiHouraStructure } from "../../types";
+/**
+ * 手牌を国士無双（13種の么九牌＋雀頭）として構造化する。
+ */
+export declare function getHouraStructuresForKokushi(tehai: Tehai14): KokushiHouraStructure[];

package/dist/features/yaku/lib/structures/kokushi.js

@@ -0,0 +1,43 @@
+import { countHaiKind } from "../../../../core/tehai";
+import { isYaochu } from "../../../../core/hai";
+/**
+ * 手牌を国士無双（13種の么九牌＋雀頭）として構造化する。
+ */
+export function getHouraStructuresForKokushi(tehai) {
+    // 国士無双は門前のみ
+    if (tehai.exposed.length > 0)
+        return [];
+    const counts = countHaiKind(tehai.closed);
+    const yaochuList = [];
+    let jantou;
+    for (let i = 0; i < 34; i++) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const kind = i;
+        const count = counts[kind];
+        if (count > 0) {
+            if (!isYaochu(kind))
+                return []; // 么九牌以外が含まれていれば不成立
+            if (count === 1) {
+                yaochuList.push(kind);
+            }
+            else if (count === 2) {
+                if (jantou !== undefined)
+                    return []; // 雀頭が既に存在すれば不成立（複数棋の雀頭候補）
+                jantou = kind;
+                yaochuList.push(kind);
+            }
+            else {
+                return []; // 3枚以上あれば不成立
+            }
+        }
+    }
+    if (yaochuList.length !== 13 || jantou === undefined)
+        return [];
+    return [
+        {
+            type: "Kokushi",
+            yaochu: yaochuList,
+            jantou,
+        },
+    ];
+}