mahjong_engine 1.0.0

package/modules/yaku/normal/MenzenTsumoChecker.ts

@@ -0,0 +1,15 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+export class MenzenTsumoChecker extends YakuCheckerBase{
+    protected yakuName: string = "門前清自摸和";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 1;
+    }
+
+    protected isSatisfied(): boolean {
+        return this.isMenzen() && this.context.ctx.isTsumo;
+    }
+}

package/modules/yaku/normal/PinfuChecker.ts

@@ -0,0 +1,26 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+import { BlockHais } from '../../BlockHais';
+import { MachiType } from '../../MahjongConsts';
+import { MentsuAnalyzer } from '../../MentsuAnalyzer';
+
+export class PinfuChecker extends YakuCheckerBase{
+    protected yakuName: string = "平和";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 1;
+    }
+
+    protected isSatisfied(): boolean {
+        const analyzer = new MentsuAnalyzer(this.context.block.getBlockHais(), this.context.melds);
+        const pw = this.context.ctx.playerWind;
+        const rw = this.context.ctx.roundWind;
+        if(!this.isMenzen()) return false;
+        if(analyzer.hasYakuhaiMentsu(m => m instanceof BlockHais && m.isJanto(), pw, rw)) return false;
+        if(!analyzer.getAll().every(m => m.isShuntsu() || (m instanceof BlockHais && m.isJanto()))) return false;
+        if(!this.context.block.calcMachiType(this.context.ctx.agariHai.getId()).has(MachiType.RYANMEN)) return false;
+        
+        return true;
+    }
+}

package/modules/yaku/normal/RenpuuhaiChecker.ts

@@ -0,0 +1,21 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+import { MentsuAnalyzer } from '../../MentsuAnalyzer';
+
+export class RenpuuhaiChecker extends YakuCheckerBase{
+    protected yakuName: string;
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 2;
+        this.hanFuro = 2;
+        this.yakuName = `連風牌:${this.context.ctx.playerWind.name}`;
+    }
+
+    protected isSatisfied(): boolean {
+        const analyzer = new MentsuAnalyzer(this.context.block.getBlockHais(), this.context.melds);
+        const pw = this.context.ctx.playerWind;
+        const rw = this.context.ctx.roundWind;
+        return analyzer.hasDoubleWindMentsu(m => m.isKotsuOrKantsu(), pw, rw);
+    }
+}

package/modules/yaku/normal/RyanpekoChecker.ts

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

package/modules/yaku/normal/SanankoChecker.ts

@@ -0,0 +1,17 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+
+export class SanankoChecker extends YakuCheckerBase{
+    protected yakuName: string = "三暗刻";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 2;
+        this.hanFuro = 2;
+    }
+
+    protected isSatisfied(): boolean {
+        return this.countAnko() === 3;
+    }
+}

package/modules/yaku/normal/SankantsuChecker.ts

@@ -0,0 +1,16 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+export class SankantsuChecker extends YakuCheckerBase{
+    protected yakuName: string = "三槓子";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 2;
+        this.hanFuro = 2;
+    }
+    
+    protected isSatisfied(): boolean {
+        return this.countKantsu() === 3;
+    }
+}

package/modules/yaku/normal/SanshokuChecker.ts

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

package/modules/yaku/normal/ShosangenChecker.ts

@@ -0,0 +1,21 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+
+export class ShosangenChecker extends YakuCheckerBase{
+    protected yakuName: string = "小三元";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 2;
+        this.hanFuro = 2;
+    }
+
+    protected isSatisfied(): boolean {
+        const {foundTargets, mentsuCount, jantoCount} = this.countTargetBlocks(this.context.block, [32,33,34]);
+
+        if(foundTargets.size !== 3) return false;
+
+        return mentsuCount === 2 && jantoCount === 1;
+    }
+}

package/modules/yaku/normal/TanyaoChecker.ts

@@ -0,0 +1,18 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+
+export class TanyaoChecker extends YakuCheckerBase{
+    protected yakuName: string = "断么九";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 1;
+        this.hanFuro = 1;
+    }
+
+    protected isSatisfied(): boolean {
+        const allTiles = this.getAllTiles();
+        return allTiles.every(h => h.isChuchanHai()) && (this.context.ctx.kuitan || this.isMenzen());
+    }
+}

package/modules/yaku/normal/ToitoiChecker.ts

@@ -0,0 +1,17 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+
+export class ToitoiChecker extends YakuCheckerBase{
+    protected yakuName: string = "対々和";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 2;
+        this.hanFuro = 2;
+    }
+
+    protected isSatisfied(): boolean {
+        return this.countKotsu() === 4;
+    }
+}

package/modules/yaku/normal/YakuhaiChecker.ts

@@ -0,0 +1,22 @@
+import { YakuContext } from '../YakuContext';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+import { IMentsu } from '../../IMentsu';
+import { MentsuAnalyzer } from '../../MentsuAnalyzer';
+
+export class YakuhaiChecker extends YakuCheckerBase{
+    protected yakuName: string;
+    private targetHai: number;
+
+    constructor(context: YakuContext, targetHai: number, yakuName: string){
+        super(context);
+        this.targetHai = targetHai;
+        this.yakuName = yakuName;
+        this.hanMenzen = 1;
+        this.hanFuro = 1;
+    }
+
+    protected isSatisfied(): boolean {
+        const allMentsu: IMentsu[] = new MentsuAnalyzer(this.context.block.getBlockHais(), this.context.melds).getAll();
+        return allMentsu.some(mentsu => mentsu.isKotsuOrKantsu() && mentsu.containsHai(this.targetHai));
+    }
+}

package/modules/yaku/yakuman/ChinrotoChecker.ts

@@ -0,0 +1,11 @@
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+
+export class ChinrotoChecker extends YakuCheckerBase{
+    protected yakuName: string = "清老頭";
+
+    protected isSatisfied(): boolean {
+        const allTiles = this.getAllTiles();
+        return allTiles.every(h => h.isRoutouHai());
+    }
+}

package/modules/yaku/yakuman/Churen9Checker.ts

@@ -0,0 +1,16 @@
+import { ExtendedYakumanChecker } from './ExtendedYakumanChecker';
+import { YakuContext } from '../YakuContext';
+import { ChurenChecker } from './ChurenChecker';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+export class Churen9Checker extends ExtendedYakumanChecker{
+    protected yakuName: string = "純正九蓮宝燈";
+    protected baseChecker: YakuCheckerBase;
+    protected requiredMachiCount: number;
+
+    constructor(context: YakuContext){
+        super(context);
+        this.baseChecker = new ChurenChecker(context);
+        this.requiredMachiCount = 9;
+    }
+}

package/modules/yaku/yakuman/ChurenChecker.ts

@@ -0,0 +1,31 @@
+import { YakuCheckerBase } from '../YakuCheckerBase';
+import { ChinitsuChecker } from '../normal/ChinitsuChecker';
+
+
+export class ChurenChecker extends YakuCheckerBase{
+    protected yakuName: string = "九蓮宝燈";
+
+    protected isSatisfied(): boolean {
+        const chinitsuChecker = new ChinitsuChecker(this.context);
+        if(!chinitsuChecker.isChinitsu()) return false;
+        if(!this.isMenzen()) return false;
+        
+        const count = new Array(9).fill(0);
+        const hais = this.context.hais.map(h => h.clone());
+        hais.forEach(h => count[h.num - 1]++);
+        
+        //1と9は3枚以上
+        const hasEnoughTerminals = count[0] >= 3 && count[8] >= 3;
+        if(!hasEnoughTerminals) return false;
+        //2から8は1枚以上
+        for(let i = 1; i <= 7; i++){
+            if(count[i] < 1) return false;
+        }
+
+        return true;
+    }
+
+    public isChuren(): boolean {
+        return this.isSatisfied();
+    }
+}

package/modules/yaku/yakuman/DaisangenChecker.ts

@@ -0,0 +1,14 @@
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+
+export class DaisangenChecker extends YakuCheckerBase{
+    protected yakuName: string = "大三元";
+
+    protected isSatisfied(): boolean {
+        const {foundTargets, mentsuCount, jantoCount} = this.countTargetBlocks(this.context.block, [32,33,34]);
+
+        if(foundTargets.size !== 3) return false;
+
+        return mentsuCount === 3 && jantoCount === 0;
+    }
+}

package/modules/yaku/yakuman/DaisushiChecker.ts

@@ -0,0 +1,21 @@
+import { YakuCheckerBase } from '../YakuCheckerBase';
+import { YakuContext } from '../YakuContext';
+
+
+export class DaisushiChecker extends YakuCheckerBase{
+    protected yakuName: string = "大四喜";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 26;
+        this.hanFuro = 26;
+    }
+    
+    protected isSatisfied(): boolean {
+        const {foundTargets, mentsuCount, jantoCount} = this.countTargetBlocks(this.context.block, [28,29,30,31]);
+
+        if(foundTargets.size !== 4) return false;
+
+        return mentsuCount === 4 && jantoCount === 0;
+    }
+}

package/modules/yaku/yakuman/ExtendedYakumanChecker.ts

@@ -0,0 +1,18 @@
+import { YakuCheckerBase } from '../YakuCheckerBase';
+import { YakuContext } from '../YakuContext';
+
+export abstract class ExtendedYakumanChecker extends YakuCheckerBase{
+    protected abstract baseChecker: YakuCheckerBase;
+    protected abstract requiredMachiCount: number;
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 26;
+        this.hanFuro = 26;
+    }
+
+    public isSatisfied(): boolean {
+        if(!this.baseChecker.check()) return false;
+        return this.calculateMachiCount() === this.requiredMachiCount;
+    }
+}

package/modules/yaku/yakuman/Kokushi13Checker.ts

@@ -0,0 +1,16 @@
+import { ExtendedYakumanChecker } from './ExtendedYakumanChecker';
+import { YakuContext } from '../YakuContext';
+import { KokushiChecker } from './KokushiChecker';
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+export class Kokushi13Checker extends ExtendedYakumanChecker{
+    protected yakuName: string = "国士無双13面待ち";
+    protected baseChecker: YakuCheckerBase;
+    protected requiredMachiCount: number;
+
+    constructor(context: YakuContext){
+        super(context);
+        this.baseChecker = new KokushiChecker(context);
+        this.requiredMachiCount = 13;
+    }
+}

package/modules/yaku/yakuman/KokushiChecker.ts

@@ -0,0 +1,15 @@
+import { YakuCheckerBase } from '../YakuCheckerBase';
+import { BlockType } from '../../MahjongConsts';
+
+export class KokushiChecker extends YakuCheckerBase{
+    protected yakuName: string = "国士無双";
+
+    protected isSatisfied(): boolean {
+        if(!this.isMenzen()) return false;
+        return this.context.block.getBlockHais().some(b => b.getType() === BlockType.KOKUSHI);
+    }
+
+    public isKokushi(): boolean {
+        return this.isSatisfied();
+    }
+}

package/modules/yaku/yakuman/RyuisoChecker.ts

@@ -0,0 +1,16 @@
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+export class RyuisoChecker extends YakuCheckerBase{
+    protected yakuName: string = "緑一色";
+    
+    protected isSatisfied(): boolean {
+        const greenNums = new Set([20, 21, 22, 24, 26, 33]);
+
+        const allTiles = [
+            ...this.context.hais,
+            ...this.context.melds.flatMap(m => m.getHais())
+        ];
+
+        return allTiles.every(h => greenNums.has(h.getId()));
+    }
+}

package/modules/yaku/yakuman/ShosushiChecker.ts

@@ -0,0 +1,13 @@
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+export class ShosushiChecker extends YakuCheckerBase{
+    protected yakuName: string = "小四喜";
+
+    protected isSatisfied(): boolean {
+        const {foundTargets, mentsuCount, jantoCount} = this.countTargetBlocks(this.context.block, [28,29,30,31]);
+
+        if(foundTargets.size !== 4) return false;
+
+        return mentsuCount === 3 && jantoCount === 1;
+    }
+}

package/modules/yaku/yakuman/SuankoChecker.ts

@@ -0,0 +1,14 @@
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+export class SuankoChecker extends YakuCheckerBase{
+    protected yakuName: string = "四暗刻";
+
+    protected isSatisfied(): boolean {
+        if(!this.isMenzen()) return false;
+        return this.countAnko() === 4;
+    }
+
+    public isSuanko(): boolean {
+        return this.isSatisfied();
+    }
+}

package/modules/yaku/yakuman/SuankoTankiChecker.ts

@@ -0,0 +1,28 @@
+import { YakuCheckerBase } from '../YakuCheckerBase';
+import { BlockType } from '../../MahjongConsts';
+import { SuankoChecker } from './SuankoChecker';
+import { YakuContext } from '../YakuContext';
+
+
+export class SuankoTankiChecker extends YakuCheckerBase{
+    protected yakuName: string = "四暗刻単騎";
+
+    constructor(context: YakuContext){
+        super(context);
+        this.hanMenzen = 26;
+        this.hanFuro = 26;
+    }
+
+    protected isSatisfied(): boolean {
+        const base = new SuankoChecker(this.context)
+        if(!base.isSuanko()) return false;
+
+        for(const blockhais of this.context.block){
+            if(blockhais.getType() === BlockType.JANTO){
+                if(blockhais.getHais().some(h => h.getId() == this.context.ctx.agariHai.getId())) return true;
+            }
+        }
+
+        return false;
+    }
+}

package/modules/yaku/yakuman/SukantsuChecker.ts

@@ -0,0 +1,9 @@
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+export class SukantsuChecker extends YakuCheckerBase{
+    protected yakuName: string = "四槓子";
+
+    protected isSatisfied(): boolean {
+        return this.countKantsu() === 4;
+    }
+}

package/modules/yaku/yakuman/TsuisoChecker.ts

@@ -0,0 +1,10 @@
+import { YakuCheckerBase } from '../YakuCheckerBase';
+
+export class TsuisoChecker extends YakuCheckerBase{
+    protected yakuName: string = "字一色";
+
+    protected isSatisfied(): boolean {
+        const allTiles = this.getAllTiles();
+        return allTiles.every(h => h.isJihai());
+    }
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "mahjong_engine",
+  "version": "1.0.0",
+  "description": "mahjong",
+  "homepage": "https://github.com/daicharn/IsTheOrderaMahjong#readme",
+  "bugs": {
+    "url": "https://github.com/daicharn/IsTheOrderaMahjong/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/daicharn/IsTheOrderaMahjong.git"
+  },
+  "license": "ISC",
+  "author": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "jest",
+    "coverage": "jest --coverage",
+    "build": "npx tsc && npm run copy-assets",
+    "copy-assets": "xcopy images dist\\images /E /I /Y"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "jest": "^30.4.2",
+    "ts-jest": "^29.4.12"
+  }
+}

package/tests/fu.test.ts

@@ -0,0 +1,44 @@
+import { YakuChecker } from "../modules/yaku/YakuChecker";
+import { FuSpec, TehaiCase } from './testConsts';
+import { YakuContext } from '../modules/yaku/YakuContext';
+import { TehaiCaseRunner } from './tehaiCaseRunner';
+import { FuCalculator } from "../modules/tensuu/FuCalculator";
+import { caseFu } from './tensuu/fu';
+import { FuDetail } from "../modules/tensuu/FuDetail";
+
+type fuList = FuSpec[][];
+
+function sortFuspecs(specs: fuList): FuSpec[][] {
+    const sortedSpecs: FuSpec[][] = [];
+    for(const spec of specs){
+        sortedSpecs.push([...spec].sort((a, b) => a.name.localeCompare(b.name)));
+    }
+    return sortedSpecs;
+}
+
+const testcases: TehaiCase<fuList>[] = [];
+caseFu.forEach(casefu => testcases.push(casefu));
+
+testcases.forEach(testcase => {
+    describe(testcase.desc, () => {
+        test(testcase.name, () => {
+            const fuList: FuDetail[][] = [];
+            const runner: TehaiCaseRunner<fuList> = new TehaiCaseRunner(testcase);
+            const blocks = runner.blocks;
+            blocks.forEach((block) => {
+                const context = new YakuContext(runner.hand, runner.ctx, block);
+                const yaku_map = new YakuChecker(context).check();
+                fuList.push(new FuCalculator(context, yaku_map).calcFu());
+            });
+            const expected: FuDetail[][] = [];
+            for(const specs of testcase.expected){
+                const details: FuDetail[] = [];
+                for(const spec of specs){
+                    details.push(new FuDetail(spec.name, spec.fu, spec.mentsu));
+                }
+                expected.push(details);
+            }
+            expect(sortFuspecs(fuList)).toEqual(sortFuspecs(expected));
+        });
+    });
+});