@pai-forge/riichi-mahjong 0.1.0

package/dist/features/shanten/logic/kokushi.js

@@ -0,0 +1,48 @@
+import { isYaochu } from "../../../core/hai";
+import { countHaiKind, validateTehai13 } from "../../../core/tehai";
+import { asHaiKindId } from "../../../utils/assertions";
+/**
+ * 国士無双のシャンテン数を計算します。
+ *
+ * ルール:
+ * - 13種類の么九牌（1,9,字牌）を各1枚ずつ揃える。
+ * - そのうちのどれか1種類が対子（2枚）になっている必要がある。
+ * - 門前限定。
+ *
+ * 計算式:
+ * シャンテン数 = 13 - (么九牌の種類数) - (么九牌の対子があるか ? 1 : 0)
+ *
+ * @param tehai 手牌
+ * @returns シャンテン数 (0: 聴牌, -1: 和了(理論上))。副露している場合は Infinity。
+ */
+export function calculateKokushiShanten(tehai) {
+    // 防御的プログラミング (Defensive Programming):
+    // 公開API（calculateShanten）側でもバリデーションが行われる想定だが（Facadeパターン）、
+    // 内部整合性を保つため、ここでも独立してバリデーションを実施する。
+    validateTehai13(tehai);
+    // 国士無双は門前のみ
+    if (tehai.exposed.length > 0) {
+        return Infinity;
+    }
+    const dist = countHaiKind(tehai.closed);
+    // 么九牌の種類数をカウント
+    // 同時に、么九牌の対子が存在するかもチェック
+    let uniqueYaochuCount = 0;
+    let hasYaochuPair = false;
+    for (let i = 0; i < dist.length; i++) {
+        const kind = asHaiKindId(i);
+        if (!isYaochu(kind)) {
+            continue;
+        }
+        const count = dist[i];
+        if (count !== undefined && count > 0) {
+            uniqueYaochuCount++;
+            if (count >= 2) {
+                hasYaochuPair = true;
+            }
+        }
+    }
+    const pairBonus = hasYaochuPair ? 1 : 0;
+    // シャンテン数 = 13 - (種類の数) - (対子ボーナス)
+    return 13 - uniqueYaochuCount - pairBonus;
+}

package/dist/features/shanten/logic/mentsu-te.d.ts

@@ -0,0 +1,8 @@
+import type { Tehai } from "../../../types";
+/**
+ * 面子手（4面子1雀頭）のシャンテン数を計算する
+ *
+ * @param tehai 手牌 (13枚 or 14枚)
+ * @returns シャンテン数
+ */
+export declare function calculateMentsuTeShanten(tehai: Tehai): number;

package/dist/features/shanten/logic/mentsu-te.js

@@ -0,0 +1,129 @@
+import { countHaiKind, validateTehai } from "../../../core/tehai";
+/**
+ * 面子手（4面子1雀頭）のシャンテン数を計算する
+ *
+ * @param tehai 手牌 (13枚 or 14枚)
+ * @returns シャンテン数
+ */
+export function calculateMentsuTeShanten(tehai) {
+    // 防御的プログラミング
+    validateTehai(tehai);
+    const counts = countHaiKind(tehai.closed);
+    // Mutation is required for the algorithm, so we convert to a mutable number array
+    const mutableCounts = Array.from(counts);
+    const exposedCount = tehai.exposed.length;
+    // 基本シャンテン数 (8 - 2 * 面子数)
+    let minShanten = 8 - 2 * exposedCount;
+    // 1. 雀頭がある場合
+    for (let i = 0; i < 34; i++) {
+        if ((mutableCounts[i] ?? 0) >= 2) {
+            mutableCounts[i] = (mutableCounts[i] ?? 0) - 2;
+            const { m, t } = searchMentsu(mutableCounts);
+            const currentMentsu = exposedCount + m;
+            const effectiveTaatsu = Math.min(4 - currentMentsu, t);
+            const shanten = 8 - 2 * currentMentsu - effectiveTaatsu - 1;
+            minShanten = Math.min(minShanten, shanten);
+            mutableCounts[i] = (mutableCounts[i] ?? 0) + 2;
+        }
+    }
+    // 2. 雀頭がない場合
+    {
+        const { m, t } = searchMentsu(mutableCounts);
+        const currentMentsu = exposedCount + m;
+        const effectiveTaatsu = Math.min(4 - currentMentsu, t);
+        const shanten = 8 - 2 * currentMentsu - effectiveTaatsu;
+        minShanten = Math.min(minShanten, shanten);
+    }
+    return minShanten;
+}
+/**
+ * 面子と塔子の最大数を探索する
+ */
+function searchMentsu(counts) {
+    let maxScore = -1;
+    let bestResult = { m: 0, t: 0 };
+    // copies needed because we mutate counts
+    const w = [...counts];
+    const search = (index, m) => {
+        // 34種類すべて見終わったら塔子を数える
+        if (index >= 34) {
+            const t = countTaatsu(w);
+            const score = 2 * m + t;
+            if (score > maxScore) {
+                maxScore = score;
+                bestResult = { m, t };
+            }
+            return;
+        }
+        // 牌がない場合は次に進む
+        if ((w[index] ?? 0) === 0) {
+            search(index + 1, m);
+            return;
+        }
+        // A. 刻子 (3枚) の場合
+        if ((w[index] ?? 0) >= 3) {
+            w[index] = (w[index] ?? 0) - 3;
+            search(index, m + 1);
+            w[index] = (w[index] ?? 0) + 3;
+        }
+        // B. 順子 (3枚) の場合
+        if (index < 27) {
+            const mod = index % 9;
+            if (mod < 7) {
+                if ((w[index] ?? 0) > 0 &&
+                    (w[index + 1] ?? 0) > 0 &&
+                    (w[index + 2] ?? 0) > 0) {
+                    w[index] = (w[index] ?? 0) - 1;
+                    w[index + 1] = (w[index + 1] ?? 0) - 1;
+                    w[index + 2] = (w[index + 2] ?? 0) - 1;
+                    search(index, m + 1);
+                    w[index] = (w[index] ?? 0) + 1;
+                    w[index + 1] = (w[index + 1] ?? 0) + 1;
+                    w[index + 2] = (w[index + 2] ?? 0) + 1;
+                }
+            }
+        }
+        // C. 面子として使わない場合
+        search(index + 1, m);
+    };
+    search(0, 0);
+    return bestResult;
+}
+/**
+ * 残った牌から塔子（対子、両面、嵌張、辺張）の数を数える
+ */
+function countTaatsu(counts) {
+    let taatsu = 0;
+    // countsのコピーを作成
+    const w = [...counts];
+    for (let i = 0; i < 34; i++) {
+        if ((w[i] ?? 0) === 0)
+            continue;
+        // 順子系の塔子 (1枚 + 1枚)
+        if (i < 27) {
+            const mod = i % 9;
+            // 辺張・両面 (i, i+1)
+            if (mod < 8) {
+                if ((w[i] ?? 0) > 0 && (w[i + 1] ?? 0) > 0) {
+                    w[i] = (w[i] ?? 0) - 1;
+                    w[i + 1] = (w[i + 1] ?? 0) - 1;
+                    taatsu++;
+                }
+            }
+            // 嵌張 (i, i+2)
+            if (mod < 7) {
+                if ((w[i] ?? 0) > 0 && (w[i + 2] ?? 0) > 0) {
+                    w[i] = (w[i] ?? 0) - 1;
+                    w[i + 2] = (w[i + 2] ?? 0) - 1;
+                    taatsu++;
+                }
+            }
+        }
+        // 対子 (2枚)
+        if ((w[i] ?? 0) >= 2) {
+            w[i] = (w[i] ?? 0) - 2;
+            taatsu++;
+        }
+    }
+    return taatsu;
+}

package/dist/features/yaku/factory.d.ts

@@ -0,0 +1,13 @@
+import type { YakuHanConfig, YakuName, HouraStructure } from "./types";
+import { YakuDefinition, HouraContext } from "./types";
+/**
+ * 役定義を作成するファクトリ関数
+ *
+ * @param yaku 役の設定情報（名前、飜数など）
+ * @param check 役の成立条件を判定する関数 (真偽値を返す)
+ * @returns YakuDefinition (isSatisfied, getHansu を持つ)
+ */
+export declare function createYakuDefinition(yaku: Readonly<{
+    name: YakuName;
+    han: YakuHanConfig;
+}>, check: (hand: HouraStructure, context: HouraContext) => boolean): YakuDefinition;

package/dist/features/yaku/factory.js

@@ -0,0 +1,19 @@
+/**
+ * 役定義を作成するファクトリ関数
+ *
+ * @param yaku 役の設定情報（名前、飜数など）
+ * @param check 役の成立条件を判定する関数 (真偽値を返す)
+ * @returns YakuDefinition (isSatisfied, getHansu を持つ)
+ */
+export function createYakuDefinition(yaku, check) {
+    return {
+        yaku,
+        isSatisfied: check,
+        getHansu: (hand, context) => {
+            if (!check(hand, context)) {
+                return 0;
+            }
+            return context.isMenzen ? yaku.han.closed : yaku.han.open;
+        },
+    };
+}

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

@@ -0,0 +1,12 @@
+import type { Tehai14, HaiKindId } from "../../types";
+import type { YakuResult } from "./types";
+export type { HouraStructure, YakuResult, YakuName, Hansu, TehaiYaku, YakuHanConfig, Yakuhai, } from "./types";
+export * from "./lib";
+/**
+ * 手牌の構造役を検出する
+ *
+ * @param tehai 判定対象の手牌
+ * @param agariHai 和了牌
+ * @returns 成立した役と飜数のリスト（最も高得点となる解釈の結果）
+ */
+export declare function detectYaku(tehai: Tehai14, agariHai: HaiKindId, bakaze?: HaiKindId, jikaze?: HaiKindId, doraMarkers?: readonly HaiKindId[], uraDoraMarkers?: readonly HaiKindId[], isTsumo?: boolean): YakuResult;

package/dist/features/yaku/index.js

@@ -0,0 +1,62 @@
+import { getHouraStructures } from "./lib/structures";
+import { isMenzen, isKazehai } from "./utils";
+import { ALL_YAKU_DEFINITIONS } from "./lib/definitions";
+export * from "./lib";
+/**
+ * 手牌の構造役を検出する
+ *
+ * @param tehai 判定対象の手牌
+ * @param agariHai 和了牌
+ * @returns 成立した役と飜数のリスト（最も高得点となる解釈の結果）
+ */
+export function detectYaku(tehai, agariHai, bakaze, jikaze, doraMarkers, uraDoraMarkers, isTsumo) {
+    // 1. 基本情報の抽出
+    const isMenzenValue = isMenzen(tehai);
+    const context = {
+        isMenzen: isMenzenValue,
+        agariHai,
+        bakaze: bakaze !== undefined && isKazehai(bakaze) ? bakaze : undefined,
+        jikaze: jikaze !== undefined && isKazehai(jikaze) ? jikaze : undefined,
+        doraMarkers: doraMarkers ?? [],
+        uraDoraMarkers: uraDoraMarkers ?? [],
+        isTsumo,
+    };
+    let bestResult = [];
+    let maxHan = -1;
+    // 2. 手牌の構造分解（面子手、七対子、国士無双）と役判定
+    const structuralInterpretations = getHouraStructures(tehai);
+    for (const hand of structuralInterpretations) {
+        const currentResult = [];
+        let currentHan = 0;
+        for (const definition of ALL_YAKU_DEFINITIONS) {
+            if (definition.isSatisfied(hand, context)) {
+                const hansu = definition.getHansu(hand, context);
+                // 喰い下がり0の場合は不成立 (getHansuが0を返すはずだが念のため)
+                if (hansu === 0)
+                    continue;
+                // TODO: 役牌のダブル役（ダブ東など）の場合、現状の YakuhaiDefinition は Han * count を返すが、
+                // YakuResult の形式としては [Name, TotalHan] なのか [Name, Han], [Name, Han] なのか議論が必要。
+                // 現状の実装: [checker.yaku.name, hanValue] を count 回 push していた。
+                // 新しい getHansu は total han を返すため、1回 push すればよいのか？
+                // しかし役の数え方としては「役牌：白」「役牌：發」は別だが、「ダブ東」は「役牌：東」が2つ？
+                // 一般的には「自風 東」「場風 東」という2つの役扱い。
+                // しかしここでは YakuhaiDefinition が汎用的になっている。
+                // ユーザー要望の simple refactor に従い、getHansu が返す値をそのまま1つの役として扱う。
+                // ただし Yakuhai の getHansu は (open * count) を返しているので、
+                // ダブ東なら 2飜 の役が1つ、という扱いになる。
+                currentResult.push([definition.yaku.name, hansu]);
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                currentHan += hansu;
+            }
+        }
+        if (currentHan > maxHan) {
+            maxHan = currentHan;
+            bestResult = currentResult;
+        }
+    }
+    // どの構造としても解釈できない、または役が成立しない場合は空配列
+    if (maxHan === -1) {
+        return [];
+    }
+    return bestResult;
+}

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

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

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

@@ -0,0 +1,12 @@
+import { createYakuDefinition } from "../../factory";
+const CHIITOITSU_YAKU = {
+    name: "Chiitoitsu",
+    han: {
+        open: 0, // 門前限定
+        closed: 2,
+    },
+};
+const checkChiitoitsu = (hand) => {
+    return hand.type === "Chiitoitsu";
+};
+export const chiitoitsuDefinition = createYakuDefinition(CHIITOITSU_YAKU, checkChiitoitsu);

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

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

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

@@ -0,0 +1,40 @@
+import { isSuupai, kindIdToHaiType } from "../../../../core/hai";
+import { HaiType } from "../../../../types";
+import { createYakuDefinition } from "../../factory";
+const CHINITSU_YAKU = {
+    name: "Chinitsu",
+    han: {
+        open: 5,
+        closed: 6,
+    },
+};
+const checkChinitsu = (hand) => {
+    let blocks;
+    if (hand.type === "Mentsu") {
+        blocks = [hand.jantou, ...hand.fourMentsu];
+    }
+    else if (hand.type === "Chiitoitsu") {
+        blocks = hand.pairs;
+    }
+    else {
+        return false;
+    }
+    // ブロック内の全ての牌をフラットな配列にする
+    const allHais = blocks.flatMap((b) => b.hais);
+    // 1. 字牌が含まれていないこと
+    const hasJihai = allHais.some((k) => kindIdToHaiType(k) === HaiType.Jihai);
+    if (hasJihai)
+        return false;
+    // 2. 数牌が全て同じ種類であること
+    const suupais = allHais.filter((k) => isSuupai(k));
+    // 数牌が含まれていない（字一色想定だが上記でJihaiチェック済みなので事実上ありえない）場合は不成立
+    if (suupais.length === 0)
+        return false;
+    const firstSuupai = suupais[0];
+    if (firstSuupai === undefined)
+        return false;
+    const firstSuupaiType = kindIdToHaiType(firstSuupai);
+    const isAllSameType = suupais.every((k) => kindIdToHaiType(k) === firstSuupaiType);
+    return isAllSameType;
+};
+export const chinitsuDefinition = createYakuDefinition(CHINITSU_YAKU, checkChinitsu);

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

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

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

@@ -0,0 +1,21 @@
+import { isSuupai, isYaochu } from "../../../../core/hai";
+import { createYakuDefinition } from "../../factory";
+const CHINROUTOU_YAKU = {
+    name: "Chinroutou",
+    han: {
+        open: 13,
+        closed: 13,
+    },
+};
+const checkChinroutou = (hand) => {
+    // 老頭牌は6種類(1m,9m,1p,9p,1s,9s)しかないため、七対子(7種)は成立しない
+    if (hand.type !== "Mentsu")
+        return false;
+    const allBlocks = [hand.jantou, ...hand.fourMentsu];
+    // 全てが老頭牌（字牌以外の么九牌）で構成されていること
+    const allRoutou = allBlocks.every((block) => block.hais.every((k) => isYaochu(k) && isSuupai(k)));
+    if (!allRoutou)
+        return false;
+    return true;
+};
+export const chinroutouDefinition = createYakuDefinition(CHINROUTOU_YAKU, checkChinroutou);

package/dist/features/yaku/lib/definitions/chuuren-poutou.d.ts

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

package/dist/features/yaku/lib/definitions/chuuren-poutou.js

@@ -0,0 +1,69 @@
+import { createYakuDefinition } from "../../factory";
+const CHUUREN_POUTOU_YAKU = {
+    name: "ChuurenPoutou",
+    han: {
+        open: 0, // 門前限定
+        closed: 13,
+    },
+};
+const checkChuurenPoutou = (hand, context) => {
+    // 1. 門前でなければならない
+    if (!context.isMenzen) {
+        return false;
+    }
+    // 構造は Mentsu 手のみ（基本的には）
+    // 構造解析結果がどうあれ、元の手牌構成が九蓮宝燈の形かどうかを確認する
+    const allHais = [];
+    if (hand.type === "Mentsu") {
+        // 面子手の場合
+        for (const mentsu of hand.fourMentsu) {
+            allHais.push(...mentsu.hais);
+        }
+        allHais.push(...hand.jantou.hais);
+    }
+    else {
+        // 九蓮宝燈は通常、面子手の特殊形として扱われることが多いが、
+        // 構造解析器が Mentsu として解釈できない場合も考慮すべきか？
+        // 一旦 Mentsu 型として解釈されていることを前提とする
+        // （九蓮宝燈は 111+234+567+8999+α のように分解可能なので Mentsu になるはず）
+        return false;
+    }
+    // 2. 混一色チェック（全て同じ色、字牌なし）
+    if (allHais.length === 0)
+        return false;
+    const firstHai = allHais[0];
+    if (firstHai === undefined)
+        return false;
+    // 字牌が含まれていたらNG
+    if (firstHai >= 27)
+        return false;
+    const suit = Math.floor(firstHai / 9); // 0, 1, 2
+    for (const hai of allHais) {
+        if (hai >= 27)
+            return false; // 字牌混入
+        if (Math.floor(hai / 9) !== suit)
+            return false; // 色混在
+    }
+    // 3. 数牌のカウントチェック
+    // 1が3枚以上, 9が3枚以上, 2-8が1枚以上
+    const counts = Array(9).fill(0);
+    for (const hai of allHais) {
+        const num = hai % 9; // 0-8
+        counts[num]++;
+    }
+    // 1 (index 0) >= 3
+    if (counts[0] < 3)
+        return false;
+    // 9 (index 8) >= 3
+    if (counts[8] < 3)
+        return false;
+    // 2-8 (index 1-7) >= 1
+    for (let i = 1; i <= 7; i++) {
+        if (counts[i] < 1)
+            return false;
+    }
+    // 合計14枚で上記を満たしていれば、必ず九蓮宝燈の形になる
+    // (3+3+7 = 13枚が必須パーツで、残り1枚は何でもよいため)
+    return true;
+};
+export const chuurenPoutouDefinition = createYakuDefinition(CHUUREN_POUTOU_YAKU, checkChuurenPoutou);

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

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

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

@@ -0,0 +1,26 @@
+import { createYakuDefinition } from "../../factory";
+import { HaiKind } from "../../../../types";
+const DAISANGEN_YAKU = {
+    name: "Daisangen",
+    han: {
+        open: 13,
+        closed: 13,
+    },
+};
+const checkDaisangen = (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++;
+        }
+    }
+    // 大三元の条件: 三元牌の刻子が3つ全てあること
+    return sangenKoutsuCount === 3;
+};
+export const daisangenDefinition = createYakuDefinition(DAISANGEN_YAKU, checkDaisangen);

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

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

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

@@ -0,0 +1,32 @@
+import { createYakuDefinition } from "../../factory";
+import { HaiKind } from "../../../../types";
+const DAISUUSHII_YAKU = {
+    name: "Daisuushii",
+    han: {
+        // TODO: ダブル役満（26飜）とするかはルールによるため、一旦通常の役満として実装
+        open: 13,
+        closed: 13,
+    },
+};
+const checkDaisuushii = (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++;
+        }
+    }
+    // 大四喜の条件: 風牌の刻子が4つ全てあること
+    return windKoutsuCount === 4;
+};
+export const daisuushiiDefinition = createYakuDefinition(DAISUUSHII_YAKU, checkDaisuushii);

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

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

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

@@ -0,0 +1,29 @@
+import { isYaochu, kindIdToHaiType } from "../../../../core/hai";
+import { HaiType } from "../../../../types";
+import { createYakuDefinition } from "../../factory";
+const HONCHAN_YAKU = {
+    name: "Honchan",
+    han: {
+        open: 1,
+        closed: 2,
+    },
+};
+const checkHonchan = (hand) => {
+    if (hand.type !== "Mentsu")
+        return false;
+    const allBlocks = [hand.jantou, ...hand.fourMentsu];
+    // 1. 全ての面子・雀頭に么九牌（1・9・字牌）が含まれること
+    const allHasYaochu = allBlocks.every((block) => block.hais.some((k) => isYaochu(k)));
+    if (!allHasYaochu)
+        return false;
+    // 2. 少なくとも1つの順子が含まれること（混老頭の除外）
+    const hasShuntsu = hand.fourMentsu.some((m) => m.type === "Shuntsu");
+    if (!hasShuntsu)
+        return false;
+    // 3. 少なくとも1つの字牌が含まれること（純全帯幺九の除外）
+    const hasJihai = allBlocks.some((block) => block.hais.some((k) => kindIdToHaiType(k) === HaiType.Jihai));
+    if (!hasJihai)
+        return false;
+    return true;
+};
+export const honchanDefinition = createYakuDefinition(HONCHAN_YAKU, checkHonchan);

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

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

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

@@ -0,0 +1,40 @@
+import { isSuupai, kindIdToHaiType } from "../../../../core/hai";
+import { HaiType } from "../../../../types";
+import { createYakuDefinition } from "../../factory";
+const HONITSU_YAKU = {
+    name: "Honitsu",
+    han: {
+        open: 2,
+        closed: 3,
+    },
+};
+const checkHonitsu = (hand) => {
+    let blocks;
+    if (hand.type === "Mentsu") {
+        blocks = [hand.jantou, ...hand.fourMentsu];
+    }
+    else if (hand.type === "Chiitoitsu") {
+        blocks = hand.pairs;
+    }
+    else {
+        return false;
+    }
+    // ブロック内の全ての牌をフラットな配列にする
+    const allHais = blocks.flatMap((b) => b.hais);
+    // 1. 字牌が少なくとも1つ含まれること（清一色の除外）
+    const hasJihai = allHais.some((k) => kindIdToHaiType(k) === HaiType.Jihai);
+    if (!hasJihai)
+        return false;
+    // 2. 数牌が全て同じ種類であること
+    const suupais = allHais.filter((k) => isSuupai(k));
+    // 数牌が含まれていない場合は字一色（または不成立）なので、ホンイツではない
+    if (suupais.length === 0)
+        return false;
+    const firstSuupai = suupais[0];
+    if (firstSuupai === undefined)
+        return false;
+    const firstSuupaiType = kindIdToHaiType(firstSuupai);
+    const isAllSameType = suupais.every((k) => kindIdToHaiType(k) === firstSuupaiType);
+    return isAllSameType;
+};
+export const honitsuDefinition = createYakuDefinition(HONITSU_YAKU, checkHonitsu);

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

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

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

@@ -0,0 +1,33 @@
+import { isYaochu, kindIdToHaiType } from "../../../../core/hai";
+import { HaiType } from "../../../../types";
+import { createYakuDefinition } from "../../factory";
+const HONROUTOU_YAKU = {
+    name: "Honroutou",
+    han: {
+        open: 2,
+        closed: 2,
+    },
+};
+const checkHonroutou = (hand) => {
+    let blocks;
+    if (hand.type === "Mentsu") {
+        blocks = [hand.jantou, ...hand.fourMentsu];
+    }
+    else if (hand.type === "Chiitoitsu") {
+        blocks = hand.pairs;
+    }
+    else {
+        return false;
+    }
+    // 1. 全ての牌が么九牌（1・9・字牌）であること
+    // これにより順子（123など）が含まれる可能性も排除される（2,3は么九牌ではないため）
+    const allYaochu = blocks.every((block) => block.hais.every((k) => isYaochu(k)));
+    if (!allYaochu)
+        return false;
+    // 2. 少なくとも1つの字牌が含まれること（清老頭の除外）
+    const hasJihai = blocks.some((block) => block.hais.some((k) => kindIdToHaiType(k) === HaiType.Jihai));
+    if (!hasJihai)
+        return false;
+    return true;
+};
+export const honroutouDefinition = createYakuDefinition(HONROUTOU_YAKU, checkHonroutou);

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

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