@pai-forge/riichi-mahjong 0.2.0 → 0.3.0

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/iipeikou.d.ts

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

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

@@ -0,0 +1,46 @@
+import { createYakuDefinition } from "../../factory";
+const IIPEIKO_YAKU = {
+    name: "Iipeikou",
+    han: {
+        open: 0, // 門前限定
+        closed: 1,
+    },
+};
+const checkIipeikou = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    const shuntsuList = hand.fourMentsu.filter((mentsu) => mentsu.type === "Shuntsu");
+    // 順子が2つ未満なら一盃口はあり得ない
+    if (shuntsuList.length < 2) {
+        return false;
+    }
+    // 同じ順子が2つあるか探す
+    // haisの内容比較が必要。Shuntsu.haisはソート済みであることを前提とするか、
+    // ここで比較用キーを作って判定する。
+    // ライブラリの仕様としてShuntsuのhaisは [T, T, T] だが順序保証は型定義上は明示されていないものの、
+    // 一般的な実装として昇順になっているはず。
+    // 安全のため、各順子の牌をソートした文字列などをキーにして比較する。
+    // ただし、Shuntsu定義上 [T, T, T] で、順子である以上連続しているため、
+    // 先頭の牌（最小の牌）が同じで、種類（萬子/筒子/索子）が同じなら同一順子とみなせる。
+    // しかし HaiKindId の単純な数値比較で十分。
+    // 例えば 1m, 2m, 3m の順子は [0, 1, 2]。
+    // 順子の構成牌IDが完全一致するかどうかを見れば良い。
+    for (let i = 0; i < shuntsuList.length; i++) {
+        for (let j = i + 1; j < shuntsuList.length; j++) {
+            const shuntsuA = shuntsuList[i];
+            const shuntsuB = shuntsuList[j];
+            if (!shuntsuA || !shuntsuB)
+                continue;
+            // 牌のID列が完全に一致するか
+            const isSame = shuntsuA.hais[0] === shuntsuB.hais[0] &&
+                shuntsuA.hais[1] === shuntsuB.hais[1] &&
+                shuntsuA.hais[2] === shuntsuB.hais[2];
+            if (isSame) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+export const iipeikouDefinition = createYakuDefinition(IIPEIKO_YAKU, checkIipeikou);

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

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

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

@@ -0,0 +1,56 @@
+import { createYakuDefinition } from "../../factory";
+const IKKITSUUKAN_YAKU = {
+    name: "Ikkitsuukan",
+    han: {
+        open: 1,
+        closed: 2,
+    },
+};
+const checkIkkitsuukan = (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つの順子がそれぞれ 1-2-3, 4-5-6, 7-8-9 であること
+    //    （インデックスの余りが 0, 3, 6 となること）
+    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);
+                // 全て同じ色でなければならない
+                if (suit1 !== suit2 || suit2 !== suit3)
+                    continue;
+                // 字牌が含まれていないかチェック（念のため）
+                if (suit1 > 2)
+                    continue;
+                // 数値（インデックス）を取得
+                const num1 = firstHai1 % 9;
+                const num2 = firstHai2 % 9;
+                const num3 = firstHai3 % 9;
+                // 0 (1-2-3), 3 (4-5-6), 6 (7-8-9) が揃っていれば成立
+                const nums = new Set([num1, num2, num3]);
+                if (nums.has(0) && nums.has(3) && nums.has(6)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+export const ikkitsuukanDefinition = createYakuDefinition(IKKITSUUKAN_YAKU, checkIkkitsuukan);

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

@@ -0,0 +1,30 @@
+import type { YakuDefinition } from "../../types";
+export * from "./tanyao";
+export * from "./pinfu";
+export * from "./iipeikou";
+export * from "./ryanpeikou";
+export * from "./sanankou";
+export * from "./suuankou";
+export * from "./sankantsu";
+export * from "./suukantsu";
+export * from "./toitoi";
+export * from "./chiitoitsu";
+export * from "./honchan";
+export * from "./junchan";
+export * from "./honroutou";
+export * from "./chinroutou";
+export * from "./shousangen";
+export * from "./daisangen";
+export * from "./tsuuiisou";
+export * from "./ryuuiisou";
+export * from "./shousuushii";
+export * from "./daisuushii";
+export * from "./chuuren-poutou";
+export * from "./kokushi";
+export * from "./sanshoku-doujun";
+export * from "./sanshoku-doukou";
+export * from "./ikkitsuukan";
+export * from "./honitsu";
+export * from "./chinitsu";
+export * from "./yakuhai";
+export declare const ALL_YAKU_DEFINITIONS: YakuDefinition[];

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

@@ -0,0 +1,90 @@
+import { tanyaoDefinition } from "./tanyao";
+import { pinfuDefinition } from "./pinfu";
+import { iipeikouDefinition } from "./iipeikou";
+import { ryanpeikouDefinition } from "./ryanpeikou";
+import { sanankouDefinition } from "./sanankou";
+import { suuankouDefinition } from "./suuankou";
+import { sankantsuDefinition } from "./sankantsu";
+import { suukantsuDefinition } from "./suukantsu";
+import { toitoiDefinition } from "./toitoi";
+import { chiitoitsuDefinition } from "./chiitoitsu";
+import { honchanDefinition } from "./honchan";
+import { junchanDefinition } from "./junchan";
+import { honroutouDefinition } from "./honroutou";
+import { chinroutouDefinition } from "./chinroutou";
+import { shousangenDefinition } from "./shousangen";
+import { daisangenDefinition } from "./daisangen";
+import { tsuuiisouDefinition } from "./tsuuiisou";
+import { ryuuiisouDefinition } from "./ryuuiisou";
+import { shousuushiiDefinition } from "./shousuushii";
+import { daisuushiiDefinition } from "./daisuushii";
+import { chuurenPoutouDefinition } from "./chuuren-poutou";
+import { kokushiDefinition } from "./kokushi";
+import { sanshokuDoujunDefinition } from "./sanshoku-doujun";
+import { sanshokuDoukouDefinition } from "./sanshoku-doukou";
+import { ikkitsuukanDefinition } from "./ikkitsuukan";
+import { honitsuDefinition } from "./honitsu";
+import { chinitsuDefinition } from "./chinitsu";
+import { hakuDefinition, hatsuDefinition, chunDefinition } from "./yakuhai";
+import { menzenTsumoDefinition } from "./menzen-tsumo";
+export * from "./tanyao";
+export * from "./pinfu";
+export * from "./iipeikou";
+export * from "./ryanpeikou";
+export * from "./sanankou";
+export * from "./suuankou";
+export * from "./sankantsu";
+export * from "./suukantsu";
+export * from "./toitoi";
+export * from "./chiitoitsu";
+export * from "./honchan";
+export * from "./junchan";
+export * from "./honroutou";
+export * from "./chinroutou";
+export * from "./shousangen";
+export * from "./daisangen";
+export * from "./tsuuiisou";
+export * from "./ryuuiisou";
+export * from "./shousuushii";
+export * from "./daisuushii";
+export * from "./chuuren-poutou";
+export * from "./kokushi";
+export * from "./sanshoku-doujun";
+export * from "./sanshoku-doukou";
+export * from "./ikkitsuukan";
+export * from "./honitsu";
+export * from "./chinitsu";
+export * from "./yakuhai";
+export const ALL_YAKU_DEFINITIONS = [
+    tanyaoDefinition,
+    pinfuDefinition,
+    iipeikouDefinition,
+    ryanpeikouDefinition,
+    sanankouDefinition,
+    suuankouDefinition,
+    sankantsuDefinition,
+    suukantsuDefinition,
+    toitoiDefinition,
+    chiitoitsuDefinition,
+    honchanDefinition,
+    junchanDefinition,
+    honroutouDefinition,
+    chinroutouDefinition,
+    shousangenDefinition,
+    daisangenDefinition,
+    tsuuiisouDefinition,
+    ryuuiisouDefinition,
+    shousuushiiDefinition,
+    daisuushiiDefinition,
+    chuurenPoutouDefinition,
+    kokushiDefinition,
+    sanshokuDoujunDefinition,
+    sanshokuDoukouDefinition,
+    ikkitsuukanDefinition,
+    honitsuDefinition,
+    chinitsuDefinition,
+    hakuDefinition,
+    hatsuDefinition,
+    chunDefinition,
+    menzenTsumoDefinition,
+];

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

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

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

@@ -0,0 +1,25 @@
+import { isSuupai, isYaochu } from "../../../../core/hai";
+import { createYakuDefinition } from "../../factory";
+const JUNCHAN_YAKU = {
+    name: "Junchan",
+    han: {
+        open: 2,
+        closed: 3,
+    },
+};
+const checkJunchan = (hand) => {
+    if (hand.type !== "Mentsu")
+        return false;
+    const allBlocks = [hand.jantou, ...hand.fourMentsu];
+    // 1. 全ての面子・雀頭に老頭牌（1・9）が含まれること
+    // isYaochu(k) && isSuupai(k) で「字牌を除く么九牌」＝「老頭牌」となる
+    const allHasRoutou = allBlocks.every((block) => block.hais.some((k) => isYaochu(k) && isSuupai(k)));
+    if (!allHasRoutou)
+        return false;
+    // 2. 少なくとも1つの順子が含まれること（清老頭の除外）
+    const hasShuntsu = hand.fourMentsu.some((m) => m.type === "Shuntsu");
+    if (!hasShuntsu)
+        return false;
+    return true;
+};
+export const junchanDefinition = createYakuDefinition(JUNCHAN_YAKU, checkJunchan);

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

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

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

@@ -0,0 +1,12 @@
+import { createYakuDefinition } from "../../factory";
+const checkKokushi = (hand) => {
+    return hand.type === "Kokushi";
+};
+const KOKUSHI_HAN = {
+    closed: 13,
+    open: 0,
+};
+export const kokushiDefinition = createYakuDefinition({
+    name: "KokushiMusou",
+    han: KOKUSHI_HAN,
+}, checkKokushi);

package/dist/features/yaku/lib/definitions/menzen-tsumo.d.ts

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

package/dist/features/yaku/lib/definitions/menzen-tsumo.js

@@ -0,0 +1,8 @@
+import { createYakuDefinition } from "../../factory";
+const definition = {
+    name: "MenzenTsumo",
+    han: { open: 0, closed: 1 },
+};
+export const menzenTsumoDefinition = createYakuDefinition(definition, (hand, context) => {
+    return context.isMenzen && !!context.isTsumo;
+});

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

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

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

@@ -0,0 +1,40 @@
+import { HaiKind } from "../../../../types";
+import { classifyMachi } from "../../../../core/machi";
+import { MahjongArgumentError } from "../../../../errors";
+import { createYakuDefinition } from "../../factory";
+const PINFU_YAKU = {
+    name: "Pinfu",
+    han: {
+        open: 0,
+        closed: 1,
+    },
+};
+const checkPinfu = (hand, context) => {
+    // 1. 門前であること
+    if (!context.isMenzen)
+        return false;
+    if (hand.type !== "Mentsu")
+        return false;
+    // 2. 雀頭が役牌でないこと
+    // 三元牌、場風、自風が含まれていないことを確認
+    const jantouKind = hand.jantou.hais[0];
+    if (context.bakaze === undefined || context.jikaze === undefined) {
+        throw new MahjongArgumentError("Pinfu check requires bakaze and jikaze in context");
+    }
+    const yakuhaiList = [
+        HaiKind.Haku,
+        HaiKind.Hatsu,
+        HaiKind.Chun,
+        context.bakaze,
+        context.jikaze,
+    ];
+    if (yakuhaiList.includes(jantouKind))
+        return false;
+    // 3. 全て順子であること
+    if (!hand.fourMentsu.every((m) => m.type === "Shuntsu"))
+        return false;
+    // 4. 両面待ちであること
+    const waitType = classifyMachi(hand, context.agariHai);
+    return waitType === "Ryanmen";
+};
+export const pinfuDefinition = createYakuDefinition(PINFU_YAKU, checkPinfu);

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

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

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

@@ -0,0 +1,33 @@
+import { createYakuDefinition } from "../../factory";
+const RYANPEIKOU_YAKU = {
+    name: "Ryanpeikou",
+    han: {
+        open: 0, // 門前限定
+        closed: 3,
+    },
+};
+const checkRyanpeikou = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    const shuntsuList = hand.fourMentsu.filter((mentsu) => mentsu.type === "Shuntsu");
+    // 順子が4つなければ二盃口はあり得ない
+    if (shuntsuList.length < 4) {
+        return false;
+    }
+    // 各順子の出現数をカウントする
+    // Shuntsuは [T, T, T] で、先頭の牌IDが同じなら同じ順子とみなす
+    const shuntsuCounts = new Map();
+    for (const shuntsu of shuntsuList) {
+        const key = shuntsu.hais[0];
+        const currentCount = shuntsuCounts.get(key) ?? 0;
+        shuntsuCounts.set(key, currentCount + 1);
+    }
+    let pairCount = 0;
+    for (const count of shuntsuCounts.values()) {
+        // 同じ順子が2つで1ペア。4つなら2ペア。
+        pairCount += Math.floor(count / 2);
+    }
+    return pairCount >= 2;
+};
+export const ryanpeikouDefinition = createYakuDefinition(RYANPEIKOU_YAKU, checkRyanpeikou);

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

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