mahjong_engine 1.0.0

package/modules/tensuu/TensuuResult.ts

@@ -0,0 +1,21 @@
+export class TensuuResult{
+    public readonly base: number;
+    public readonly ronOya: number;
+    public readonly ronKo: number;
+    public readonly tsumoOya: number;
+    public readonly tsumoKo: {oya: number, ko: number};
+
+    constructor(
+        base: number,
+        ronOya: number,
+        ronKo: number,
+        tsumoOya: number,
+        tsumoKo: {oya: number, ko: number}
+    ){
+        this.base = base;
+        this.ronOya = ronOya;
+        this.ronKo = ronKo;
+        this.tsumoOya = tsumoOya;
+        this.tsumoKo = tsumoKo;
+    }
+}

package/modules/tileDefs.ts

@@ -0,0 +1,24 @@
+//牌を数値として定義
+export const TILE = {
+    MANZU: [1,2,3,4,5,6,7,8,9],
+    PINZU: [10,11,12,13,14,15,16,17,18],
+    SOUZU: [19,20,21,22,23,24,25,26,27],
+    JIHAI: [28,29,30,31,32,33,34],
+
+    WIND: {
+        EAST: { id: 28, name: "東" },
+        SOUTH: { id: 29, name: "南" },
+        WEST: { id: 30, name: "西" },
+        NORTH: { id: 31, name: "北" }
+    },
+    DRAGON: {
+        WHITE: { id: 32, name: "白" },
+        GREEN: { id: 33, name: "發" },
+        RED: { id: 34, name: "中" }
+    },
+
+    BACK: 100,
+} as const;
+
+export type Wind = typeof TILE.WIND[keyof typeof TILE.WIND];
+export type Dragon = typeof TILE.DRAGON[keyof typeof TILE.DRAGON];

package/modules/yaku/NormalYakuChecker.ts

@@ -0,0 +1,31 @@
+import { WinEvent } from '../MahjongConsts';
+import { YakuContext } from './YakuContext';
+import { NormalYakuCheckers } from './index';
+
+export class NormalYakuChecker{
+    protected readonly context: YakuContext;
+
+    constructor(context: YakuContext){
+        this.context = context;
+    }
+
+    //役判定
+    check(): Map<string, number> {
+        const yaku_map: Map<string, number> = new Map();
+        for(const Checker of NormalYakuCheckers) {
+            const checker = Checker(this.context);
+            if(checker.check()) yaku_map.set(checker.getName(), checker.getHan());
+        }
+
+        if(this.context.ctx.riichi) yaku_map.set("立直", 1);
+        if(this.context.ctx.daburii) yaku_map.set("ダブル立直", 2);
+        if(this.context.ctx.ippatsu) yaku_map.set("一発", 1);
+        if(this.context.ctx.event === WinEvent.RINSHAN) yaku_map.set("嶺上開花", 1);
+        if(this.context.ctx.event === WinEvent.CHANKAN) yaku_map.set("槍槓", 1);
+        if(this.context.ctx.event === WinEvent.HAITEI) yaku_map.set("海底摸月", 1);
+        if(this.context.ctx.event === WinEvent.HOUTEI) yaku_map.set("河底撈魚", 1);
+        
+
+        return yaku_map;
+    }
+}

package/modules/yaku/YakuChecker.ts

@@ -0,0 +1,29 @@
+import { PlayerHand } from '../PlayerHand';
+import { PlayerContext } from '../PlayerContext';
+import { YakumanChecker } from './YakumanChecker';
+import { BlockHaisList } from '../BlockHaisList';
+import { YakuContext } from './YakuContext';
+import { NormalYakuChecker } from './NormalYakuChecker';
+
+export class YakuChecker {
+    private context: YakuContext
+
+    constructor(context: YakuContext){
+        this.context = context;
+    }
+
+    check(): Map<string, number> {
+        //手牌と鳴き（カンを考慮して鳴き一つを3と数える）が計14枚かどうか確認する
+        const tehai_num = this.context.hais.length;
+        const furo_num = this.context.melds.length;
+        if(tehai_num + furo_num * 3 !== 14) return new Map<string, number>();
+
+        const yakuman_map = new YakumanChecker(this.context).check();
+        if(yakuman_map.size === 0){
+            return new NormalYakuChecker(this.context).check();
+        }
+        else{
+            return yakuman_map;
+        }
+    }
+}

package/modules/yaku/YakuCheckerBase.ts

@@ -0,0 +1,180 @@
+import { Hai } from '../Hai';
+import { YakuContext } from './YakuContext';
+import { BlockHaisList } from '../BlockHaisList';
+import { MachiCalculator } from '../MachiCalculator';
+import { IMentsu } from '../IMentsu';
+import { BlockType, MeldType, HaiType } from '../MahjongConsts';
+import { MentsuAnalyzer } from '../MentsuAnalyzer';
+
+export abstract class YakuCheckerBase {
+    protected readonly context: YakuContext;
+    protected hanMenzen: number;
+    protected hanFuro: number;
+    protected abstract yakuName: string;
+    protected isYakuman: boolean;
+    
+    constructor(context: YakuContext){
+        this.context = context;
+        this.hanMenzen = 13;
+        this.hanFuro = 13;
+        this.isYakuman = false;
+    }
+
+    protected abstract isSatisfied(): boolean;
+
+    public check(): boolean {
+        return this.isSatisfied();
+    }
+
+    public getHan(): number {
+        return this.isMenzen() ? this.hanMenzen : this.hanFuro;
+    }
+
+    public getName(): string {
+        return this.yakuName;
+    }
+
+    //グループ内にマンズ、ピンズ、ソーズすべてが含まれているかどうかを調べる
+    protected hasThreeTypesInGroups(groups: Map<string, IMentsu[]>): boolean {
+        for(const group of groups.values()){
+            const types = new Set(group.map(m => m.minHai.type));
+            if(types.has(HaiType.MANZU) && types.has(HaiType.PINZU) && types.has(HaiType.SOUZU)) return true;
+        }
+        return false;
+    }
+
+    //三色関係の判定
+    protected checkSanshoku(
+        filter: (m: IMentsu) => boolean
+    ): boolean {
+        const groups = this.getGroupsMentsu(filter, (m) => `${m.minHai.num}-${m.maxHai.num}`);
+        return this.hasThreeTypesInGroups(groups);
+    }
+
+    //アガリ牌を除いた手牌の待ちの数を計算する
+    protected calculateMachiCount(): number {
+        const haisWithoutAgari = this.getHaisWithoutAgariHai();
+        const machi = new MachiCalculator(haisWithoutAgari).calculate();
+        return machi.length;
+    }
+
+    //手牌と鳴き牌を含めた牌のコピー配列を作成
+    protected getAllTiles(): Hai[] {
+        return this.context.hand.getAllTiles();
+    }
+
+    //全く同じ順子のグループ数を数える
+    protected countSameShuntsuGroups(): number {
+        const groups = this.getGroupsMentsu(
+            (m) => m.isShuntsu(),
+            (m) => `${m.minHai.getId()}-${m.maxHai.getId()}`
+        );
+        let count = 0;
+        for(const group of groups.values()){
+            if(group.length >= 2){
+                count += Math.floor(group.length / 2);
+            }
+        }
+        return count;
+    }
+
+    //面子ごとにグループを作成する
+    protected getGroupsMentsu(
+        filter: (m: IMentsu) => boolean,
+        keySelector: (m: IMentsu) => string
+    ): Map<string, IMentsu[]> {
+        const mentsuList: IMentsu[] = new MentsuAnalyzer(this.context.block.getBlockHais(), this.context.melds).getAll();
+        const filteredMentsu = mentsuList.filter(filter);
+        const groups = new Map<string, IMentsu[]>();
+        for(const mentsu of filteredMentsu){
+            const key = keySelector(mentsu);
+            if(!groups.has(key)){
+                groups.set(key, []);
+            }
+            groups.get(key)?.push(mentsu);
+        }
+        return groups;
+    }
+
+    //指定された牌の数を手牌と鳴き牌から数える
+    protected countTargetBlocks(blockedhaislist: BlockHaisList, target: number[]) {
+        const targetNums = new Set(target);
+        const foundTargets = new Set<number>();
+        let mentsuCount = 0;
+        let jantoCount = 0;
+        for(const blockhais of blockedhaislist){
+            const id = blockhais.getHais()[0].getId();
+            if(targetNums.has(id)){
+                foundTargets.add(id);
+                if(blockhais.getType() === BlockType.KOTSU) mentsuCount++;
+                if(blockhais.getType() === BlockType.JANTO) jantoCount++;
+            }
+        }
+        for(const meld of this.context.melds){
+            const id = meld.getHais()[0].getId();
+            if(targetNums.has(id)){
+                //ポン、カンであれば面子としてカウント
+                if(meld.getType() !== MeldType.CHI){
+                    foundTargets.add(id);
+                    mentsuCount++;
+                }
+            }
+        }
+
+        return {foundTargets, mentsuCount, jantoCount};
+    }
+
+    //暗刻の数を数える
+    protected countAnko(): number {
+        let ankoCount = 0;
+        for(const blockhais of this.context.block){
+            if(blockhais.getType() === BlockType.KOTSU){
+                //ロンであり刻子にアガリ牌が含まれている場合暗刻として認めない
+                if(!this.context.ctx.isTsumo && blockhais.getHais().some(h => h.getId() == this.context.ctx.agariHai.getId())) continue;
+                ankoCount++;
+            }
+        }
+        for(const meld of this.context.melds){
+            if(meld.getType() === MeldType.ANKAN) ankoCount++;
+        }
+        
+        return ankoCount;
+    }
+
+    //刻子の数を数える
+    protected countKotsu(): number {
+        let kotsuCount = 0;
+        const allMentsu: IMentsu[] = [...this.context.block, ...this.context.melds];
+
+        allMentsu.forEach(mentsu => {
+            if(mentsu.isKotsuOrKantsu()) kotsuCount++;
+        });
+
+        return kotsuCount;
+    }
+
+    //槓子の数を数える
+    protected countKantsu(): number {
+        let kantsuCount = 0;
+        for(const meld of this.context.melds){
+            if(meld.getType() === MeldType.ANKAN || meld.getType() === MeldType.MINKAN) kantsuCount++;
+        }
+
+        return kantsuCount;
+    }
+
+    //面前かどうか
+    protected isMenzen(): boolean {
+        return this.context.hand.isMenzen();
+    }
+
+    //アガリ牌を除いた手牌のコピーを作成
+    protected getHaisWithoutAgariHai(): Hai[] {
+        const hais = this.context.hais.map(h => h.clone());
+        const agariId = this.context.ctx.agariHai.getId();
+        const index = this.context.hais.findIndex(h => h.getId() === agariId);
+        hais.splice(index, 1);
+
+        return hais;
+    }
+}

package/modules/yaku/YakuContext.ts

@@ -0,0 +1,25 @@
+import { Hai } from '../Hai';
+import { Meld } from '../Meld';
+import { PlayerHand } from '../PlayerHand';
+import { PlayerContext } from '../PlayerContext';
+import { BlockHaisList } from '../BlockHaisList';
+
+export class YakuContext {
+    readonly hand: PlayerHand;
+    readonly block: BlockHaisList;
+    readonly ctx: PlayerContext;
+
+    constructor(hand: PlayerHand, ctx: PlayerContext, block: BlockHaisList){
+        this.hand = hand;
+        this.ctx = ctx;
+        this.block = block;
+    }
+
+    get hais(): Hai[]{
+        return this.hand.getTehai();
+    }
+
+    get melds(): Meld[]{
+        return this.hand.getFuro();
+    }
+}

package/modules/yaku/YakumanChecker.ts

@@ -0,0 +1,34 @@
+import { WinEvent } from '../MahjongConsts';
+import { YakuContext } from './YakuContext';
+import { YakumanCheckers } from './index';
+
+export class YakumanChecker{
+    protected readonly context: YakuContext;
+
+    constructor(context: YakuContext){
+        this.context = context;
+    }
+
+    //役判定
+    check(): Map<string, number> {
+        const excludes = [
+            { main: "純正九蓮宝燈", sub: "九蓮宝燈"},
+            { main: "四暗刻単騎", sub: "四暗刻"},
+            { main: "国士無双13面待ち", sub: "国士無双"},
+        ];
+        const yaku_map: Map<string, number> = new Map();
+        for(const Checker of YakumanCheckers) {
+            const checker = Checker(this.context);
+            if(checker.check()) yaku_map.set(checker.getName(), checker.getHan());
+        }
+
+        for(const { main, sub } of excludes) {
+            if(yaku_map.has(main)) yaku_map.delete(sub);
+        }
+
+        if(this.context.ctx.event === WinEvent.TENHO) yaku_map.set("天和", 13);
+        if(this.context.ctx.event === WinEvent.CHIHO) yaku_map.set("地和", 13);
+
+        return yaku_map;
+    }
+}

package/modules/yaku/index.ts

@@ -0,0 +1,83 @@
+import { YakuCheckerBase } from './YakuCheckerBase';
+import { YakuContext } from './YakuContext';
+import { TsuisoChecker } from './yakuman/TsuisoChecker';
+import { ChinrotoChecker } from './yakuman/ChinrotoChecker';
+import { RyuisoChecker } from './yakuman/RyuisoChecker';
+import { SukantsuChecker } from './yakuman/SukantsuChecker';
+import { ChurenChecker } from './yakuman/ChurenChecker';
+import { Churen9Checker } from './yakuman/Churen9Checker';
+import { SuankoChecker } from './yakuman/SuankoChecker';
+import { SuankoTankiChecker } from './yakuman/SuankoTankiChecker';
+import { KokushiChecker } from './yakuman/KokushiChecker';
+import { Kokushi13Checker } from './yakuman/Kokushi13Checker';
+import { DaisushiChecker } from './yakuman/DaisushiChecker';
+import { ShosushiChecker } from './yakuman/ShosushiChecker';
+import { DaisangenChecker } from './yakuman/DaisangenChecker';
+
+import { ChinitsuChecker } from './normal/ChinitsuChecker';
+import { HonitsuChecker } from './normal/HonitsuChecker';
+import { JunchanChecker } from './normal/JunchanChecker';
+import { HonchanChecker } from './normal/HonchanChecker';
+import { HonrotoChecker } from './normal/HonrotoChecker';
+import { RyanpekoChecker } from './normal/RyanpekoChecker';
+import { ChitoitsuChecker } from './normal/ChitoitsuChecker';
+import { SanankoChecker } from './normal/SanankoChecker';
+import { ToitoiChecker } from './normal/ToitoiChecker';
+import { IipekoChecker } from './normal/IipekoChecker';
+import { ShosangenChecker } from './normal/ShosangenChecker';
+import { SanshokuChecker } from './normal/SanshokuChecker';
+import { DoukouChecker } from './normal/DoukouChecker';
+import { IttsuuChecker } from './normal/IttsuuChecker';
+import { TanyaoChecker } from './normal/TanyaoChecker';
+import { SankantsuChecker } from './normal/SankantsuChecker';
+import { MenzenTsumoChecker } from './normal/MenzenTsumoChecker';
+import { PinfuChecker } from './normal/PinfuChecker';
+import { RenpuuhaiChecker } from './normal/RenpuuhaiChecker';
+import { YakuhaiChecker } from './normal/YakuhaiChecker';
+import { KazehaiChecker } from './normal/KazehaiChecker';
+
+export type YakuCheckerFactory =
+    (context: YakuContext) => YakuCheckerBase;
+
+export const YakumanCheckers: YakuCheckerFactory[] = [
+    ctx => new TsuisoChecker(ctx),
+    ctx => new ChinrotoChecker(ctx),
+    ctx => new RyuisoChecker(ctx),
+    ctx => new SukantsuChecker(ctx),
+    ctx => new ChurenChecker(ctx),
+    ctx => new Churen9Checker(ctx),
+    ctx => new SuankoChecker(ctx),
+    ctx => new SuankoTankiChecker(ctx),
+    ctx => new KokushiChecker(ctx),
+    ctx => new Kokushi13Checker(ctx),
+    ctx => new DaisushiChecker(ctx),
+    ctx => new ShosushiChecker(ctx),
+    ctx => new DaisangenChecker(ctx),
+];
+
+export const NormalYakuCheckers: YakuCheckerFactory[] = [
+    ctx => new ChinitsuChecker(ctx),
+    ctx => new HonitsuChecker(ctx),
+    ctx => new JunchanChecker(ctx),
+    ctx => new HonchanChecker(ctx),
+    ctx => new HonrotoChecker(ctx),
+    ctx => new RyanpekoChecker(ctx),
+    ctx => new ChitoitsuChecker(ctx),
+    ctx => new SanankoChecker(ctx),
+    ctx => new ToitoiChecker(ctx),
+    ctx => new IipekoChecker(ctx),
+    ctx => new ShosangenChecker(ctx),
+    ctx => new SanshokuChecker(ctx),
+    ctx => new DoukouChecker(ctx),
+    ctx => new IttsuuChecker(ctx),
+    ctx => new TanyaoChecker(ctx),
+    ctx => new SankantsuChecker(ctx),
+    ctx => new MenzenTsumoChecker(ctx),
+    ctx => new PinfuChecker(ctx),
+    ctx => new RenpuuhaiChecker(ctx),
+    ctx => new KazehaiChecker(ctx, "自風牌", ctx.ctx.playerWind, ctx.ctx.roundWind),
+    ctx => new KazehaiChecker(ctx, "場風牌", ctx.ctx.roundWind, ctx.ctx.playerWind),
+    ctx => new YakuhaiChecker(ctx, 32, "白"),
+    ctx => new YakuhaiChecker(ctx, 33, "發"),
+    ctx => new YakuhaiChecker(ctx, 34, "中"),
+];

package/modules/yaku/normal/ChinitsuChecker.ts

@@ -0,0 +1,25 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+
+export class ChinitsuChecker extends YakuCheckerBase{
+    protected yakuName: string = "清一色";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 6;
+        this.hanFuro = 5;
+    }
+
+    protected isSatisfied(): boolean {
+        const allTiles = this.getAllTiles();
+        if(allTiles.length === 0) return false;
+        const suitType = allTiles[0].type;
+        
+        return allTiles.every(h => h.type === suitType);
+    }
+
+    public isChinitsu(): boolean {
+        return this.isSatisfied();
+    }
+}

package/modules/yaku/normal/ChitoitsuChecker.ts

@@ -0,0 +1,20 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+import { BlockType } from '../../MahjongConsts';
+
+
+export class ChitoitsuChecker extends YakuCheckerBase{
+    protected yakuName: string = "七対子";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 2;
+    }
+
+    protected isSatisfied(): boolean {
+        if(!this.isMenzen()) return false;
+
+        return this.context.block.getBlockHais().length === 7 
+            && this.context.block.getBlockHais().every(block => block.getType() ===  BlockType.CHITOI);
+    }
+}

package/modules/yaku/normal/DoukouChecker.ts

@@ -0,0 +1,16 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+export class DoukouChecker extends YakuCheckerBase{
+    protected yakuName: string = "三色同刻";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 2;
+        this.hanFuro = 2;
+    }
+
+    protected isSatisfied(): boolean {
+        return this.checkSanshoku((m) => m.isKotsuOrKantsu());
+    }
+}

package/modules/yaku/normal/HonchanChecker.ts

@@ -0,0 +1,24 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+import { IMentsu } from '../../IMentsu';
+import { MentsuAnalyzer } from '../../MentsuAnalyzer';
+
+
+export class HonchanChecker extends YakuCheckerBase{
+    protected yakuName: string = "混全帯么九";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 2;
+        this.hanFuro = 1;
+    }
+    
+    protected isSatisfied(): boolean {
+        const allMentsu: IMentsu[] = new MentsuAnalyzer(this.context.block.getBlockHais(), this.context.melds).getAll();
+        const allYaochu = allMentsu.every(mentsu => (mentsu.hasRoutouHai() || mentsu.hasJihai()));
+        const hasShuntsu = allMentsu.some(mentsu => mentsu.isShuntsu());
+        const hasJihai = allMentsu.some(mentsu => mentsu.hasJihai());
+
+        return allYaochu && hasShuntsu && hasJihai;
+    }
+}

package/modules/yaku/normal/HonitsuChecker.ts

@@ -0,0 +1,20 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+import { HaiType } from '../../MahjongConsts';
+
+
+export class HonitsuChecker extends YakuCheckerBase{
+    protected yakuName: string = "混一色";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 3;
+        this.hanFuro = 2;
+    }
+
+    protected isSatisfied(): boolean {
+        const allTiles = this.getAllTiles();
+        const suits = new Set(allTiles.map(h => h.type));
+        return suits.size === 2 && suits.has(HaiType.JIHAI);   
+    }
+}

package/modules/yaku/normal/HonrotoChecker.ts

@@ -0,0 +1,23 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+import { IMentsu } from '../../IMentsu';
+import { MentsuAnalyzer } from '../../MentsuAnalyzer';
+
+
+export class HonrotoChecker extends YakuCheckerBase{
+    protected yakuName: string = "混老頭";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 2;
+        this.hanFuro = 2;
+    }
+
+    protected isSatisfied(): boolean {
+        const allMentsu: IMentsu[] = new MentsuAnalyzer(this.context.block.getBlockHais(), this.context.melds).getAll();
+        const allYaochu = allMentsu.every(mentsu => (mentsu.hasRoutouHai() || mentsu.hasJihai()));
+        const allNotShuntsu = allMentsu.every(mentsu => !mentsu.isShuntsu());
+
+        return allYaochu && allNotShuntsu;
+    }
+}

package/modules/yaku/normal/IipekoChecker.ts

@@ -0,0 +1,17 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+
+export class IipekoChecker extends YakuCheckerBase{
+    protected yakuName: string = "一盃口";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 1;
+    }
+
+    protected isSatisfied(): boolean {
+        if(!this.isMenzen()) return false;
+        return this.countSameShuntsuGroups() === 1;
+    }
+}

package/modules/yaku/normal/IttsuuChecker.ts

@@ -0,0 +1,32 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+import { HaiType } from '../../MahjongConsts';
+
+
+
+export class IttsuuChecker extends YakuCheckerBase{
+    protected yakuName: string = "一気通貫";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 2;
+        this.hanFuro = 1;
+    }
+
+    protected isSatisfied(): boolean {
+        const shuntsuGroups = this.getGroupsMentsu(
+            (m) => m.isShuntsu(),
+            (m) => m.minHai.type.toString()
+        );
+
+        for(const group of shuntsuGroups.values()){
+            const hai123 = group.some(m => m.minHai.num === 1 && m.maxHai.num === 3);
+            const hai456 = group.some(m => m.minHai.num === 4 && m.maxHai.num === 6);
+            const hai789 = group.some(m => m.minHai.num === 7 && m.maxHai.num === 9);
+
+            if(hai123 && hai456 && hai789) return true;
+        }
+
+        return false;
+    }
+}

package/modules/yaku/normal/JunchanChecker.ts

@@ -0,0 +1,20 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+import { IMentsu } from '../../IMentsu';
+import { MentsuAnalyzer } from '../../MentsuAnalyzer';
+
+
+export class JunchanChecker extends YakuCheckerBase{
+    protected yakuName: string = "純全帯么九";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 3;
+        this.hanFuro = 2;
+    }
+
+    protected isSatisfied(): boolean {
+        const allMentsu: IMentsu[] = new MentsuAnalyzer(this.context.block.getBlockHais(), this.context.melds).getAll();
+        return allMentsu.every(mentsu => mentsu.hasRoutouHai());
+    }
+}

package/modules/yaku/normal/KazehaiChecker.ts

@@ -0,0 +1,25 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+import { MentsuAnalyzer } from '../../MentsuAnalyzer';
+import { Wind } from '../../tileDefs';
+
+
+export class KazehaiChecker extends YakuCheckerBase{
+    protected yakuName: string;
+    private requiredWind: Wind;
+    private forbiddenWind: Wind;
+
+    constructor(context: YakuContext, yakuName: string, requiredWind: Wind, forbiddenWind: Wind){
+        super(context);
+        this.hanMenzen = 1;
+        this.hanFuro = 1;
+        this.requiredWind = requiredWind;
+        this.forbiddenWind = forbiddenWind;
+        this.yakuName = `${yakuName}:${requiredWind.name}`;
+    }
+
+    protected isSatisfied(): boolean {
+        const analyzer = new MentsuAnalyzer(this.context.block.getBlockHais(), this.context.melds);
+        return analyzer.hasSingleWindMentsu(m => m.isKotsuOrKantsu(), this.requiredWind, this.forbiddenWind);
+    }
+}