mahjong_engine 1.0.0

package/tests/machi/chinitsu.ts

@@ -0,0 +1,137 @@
+export const casesChinitsu = [
+  {
+    name: "machi_9men",
+    hais: [1,1,1,2,3,4,5,6,7,8,9,9,9],
+    expected: [1,2,3,4,5,6,7,8,9]
+  },
+  {
+    name: "machi_8men_1",
+    hais: [1,1,1,2,2,2,3,4,5,6,7,7,7],
+    expected: [1,2,3,4,5,6,7,8]
+  },
+  {
+    name: "machi_8men_2",
+    hais: [1,1,1,2,3,4,5,6,6,6,6,7,8],
+    expected: [1,2,3,4,5,7,8,9]
+  },
+  {
+    name: "machi_8men_3",
+    hais: [1,1,1,3,3,3,4,5,6,7,8,8,8],
+    expected: [2,3,4,5,6,7,8,9]
+  },
+  {
+    name: "machi_7men_1",
+    hais: [1,1,2,2,2,3,3,3,4,5,6,6,6],
+    expected: [1,2,3,4,5,6,7]
+  },
+  {
+    name: "machi_7men_2",
+    hais: [2,2,2,3,4,5,6,6,6,7,7,8,8],
+    expected: [1,3,4,6,7,8,9]
+  },
+  {
+    name: "machi_7men_3",
+    hais: [2,3,3,4,4,5,5,5,5,6,7,7,7],
+    expected: [1,2,3,4,6,7,8]
+  },
+  {
+    name: "machi_7men_4",
+    hais: [2,2,3,3,4,4,4,5,6,6,6,6,7],
+    expected: [1,2,3,4,5,7,8]
+  },
+  {
+    name: "machi_6men_1",
+    hais: [3,3,4,4,5,5,5,6,7,8,9,9,9],
+    expected: [2,3,4,5,7,8]
+  },
+  {
+    name: "machi_6men_2",
+    hais: [2,2,2,3,3,3,4,4,4,5,5,5,6],
+    expected: [1,3,4,5,6,7]
+  },
+  {
+    name: "machi_6men_3",
+    hais: [2,2,2,3,3,3,4,4,4,4,5,6,7],
+    expected: [1,2,3,5,7,8]
+  },
+  {
+    name: "machi_5men_1",
+    hais: [2,3,4,4,4,5,5,6,7,8,9,9,9],
+    expected: [1,3,4,5,6]
+  },
+  {
+    name: "machi_5men_2",
+    hais: [1,1,1,2,3,3,4,5,5,5,6,7,8],
+    expected: [1,2,3,4,5]
+  },
+  {
+    name: "machi_5men_3",
+    hais: [3,4,5,5,6,6,7,7,8,8,8,8,9],
+    expected: [3,4,6,7,9]
+  },
+  {
+    name: "machi_4men_1",
+    hais: [1,1,1,3,4,5,7,7,7,8,9,9,9],
+    expected: [6,7,8,9]
+  },
+  {
+    name: "machi_4men_2",
+    hais: [2,3,4,4,4,5,5,5,6,6,6,9,9],
+    expected: [1,4,7,9]
+  },
+  {
+    name: "machi_4men_3",
+    hais: [2,2,3,4,4,4,5,5,5,5,6,6,6],
+    expected: [2,3,4,7]
+  },
+  {
+    name: "machi_3men_1",
+    hais: [1,1,1,2,2,3,4,4,5,6,6,7,8],
+    expected: [2,3,5]
+  },
+  {
+    name: "machi_3men_2",
+    hais: [1,1,2,2,2,3,3,4,5,6,7,7,7],
+    expected: [1,2,3]
+  },
+  {
+    name: "machi_3men_3",
+    hais: [1,2,3,3,3,4,5,6,7,8,9,9,9],
+    expected: [3,6,9]
+  },
+  {
+    name: "machi_2men_1",
+    hais: [1,2,2,2,3,3,4,5,5,6,7,8,9],
+    expected: [4,7]
+  },
+  {
+    name: "machi_2men_2",
+    hais: [2,2,2,3,3,4,4,4,6,7,7,7,8],
+    expected: [3,7]
+  },
+  {
+    name: "machi_2men_3",
+    hais: [4,4,4,4,5,5,5,5,7,7,8,8,8],
+    expected: [3,6]
+  },
+  {
+    name: "machi_1men_1",
+    hais: [2,2,3,4,4,4,5,5,5,6,6,8,9],
+    expected: [7]
+  },
+  {
+    name: "machi_1men_2",
+    hais: [1,2,2,3,4,4,5,6,7,7,7,8,9],
+    expected: [3]
+  },
+  {
+    name: "machi_1men_3",
+    hais: [3,3,4,4,4,4,5,5,5,6,7,7,9],
+    expected: [8]
+  },
+  {
+    name: "machi_1men_4",
+    hais: [1,2,2,2,2,3,3,4,5,5,7,8,9],
+    expected: [5]
+  },
+];

package/tests/machi/chitoitsu.ts

@@ -0,0 +1,12 @@
+export const casesChitoitsu = [
+  {
+    name: "chitoi_1",
+    hais: [1,1,3,3,5,5,12,12,14,14,22,22,31],
+    expected: [31]
+  },
+  {
+    name: "chitoi_2",
+    hais: [1,1,2,2,3,3,4,4,5,5,6,6,7],
+    expected: [1,4,7]
+  },
+];

package/tests/machi/kokushi.ts

@@ -0,0 +1,22 @@
+export const casesKokushi = [
+  {
+    name: "kokushi_13men",
+    hais: [1,9,10,18,19,27,28,29,30,31,32,33,34],
+    expected: [1,9,10,18,19,27,28,29,30,31,32,33,34]
+  },
+  {
+    name: "kokushi_normal_1",
+    hais: [1,1,10,18,19,27,28,29,30,31,32,33,34],
+    expected: [9]
+  },
+  {
+    name: "kokushi_normal_2",
+    hais: [1,9,10,18,19,27,28,29,30,31,32,33,33],
+    expected: [34]
+  },
+  {
+    name: "kokushi_normal_3",
+    hais: [1,9,10,18,19,27,27,29,30,31,32,33,34],
+    expected: [28]
+  },
+];

package/tests/machi/maisuu.ts

@@ -0,0 +1,77 @@
+export const casesMaisuu = [
+  {
+    name: "maisuu_14",
+    hais: [1,1,1,2,3,4,5,5,6,7,8,9,9,9],
+    expected: []
+  },
+  {
+    name: "maisuu_13",
+    hais: [1,1,2,3,4,5,5,6,7,8,9,9,9],
+    expected: [1,5]
+  },
+  {
+    name: "maisuu_12",
+    hais: [1,1,2,3,4,5,6,7,8,9,9,9],
+    expected: []
+  },
+  {
+    name: "maisuu_11",
+    hais: [1,1,2,3,4,5,6,7,8,9,9],
+    expected: []
+  },
+  {
+    name: "maisuu_10",
+    hais: [1,1,2,3,4,5,6,7,8,9],
+    expected: [1,4,7]
+  },
+  {
+    name: "maisuu_9",
+    hais: [1,2,3,4,5,6,7,8,9],
+    expected: []
+  },
+  {
+    name: "maisuu_8",
+    hais: [1,2,3,4,5,6,7,8],
+    expected: []
+  },
+  {
+    name: "maisuu_7",
+    hais: [1,2,3,4,5,6,7],
+    expected: [1,4,7]
+  },
+  {
+    name: "maisuu_6",
+    hais: [1,2,3,4,5,6],
+    expected: []
+  },
+  {
+    name: "maisuu_5",
+    hais: [2,3,4,5,6],
+    expected: []
+  },
+  {
+    name: "maisuu_4",
+    hais: [2,3,4,5],
+    expected: [2,5]
+  },
+  {
+    name: "maisuu_3",
+    hais: [2,3,4],
+    expected: []
+  },
+  {
+    name: "maisuu_2",
+    hais: [2,3],
+    expected: []
+  },
+  {
+    name: "maisuu_1",
+    hais: [2],
+    expected: [2]
+  },
+  {
+    name: "maisuu_0",
+    hais: [],
+    expected: []
+  },
+];

package/tests/machi.test.ts

@@ -0,0 +1,100 @@
+import { Hai } from '../modules/Hai';
+import { Hais } from '../modules/Hais';
+import { MachiCalculator } from '../modules/MachiCalculator';
+import { PAI_TYPE_NUM } from '../modules/MahjongConsts';
+import { casesChinitsu } from './machi/chinitsu';
+import { casesChitoitsu } from './machi/chitoitsu';
+import { casesKokushi } from './machi/kokushi';
+import { BlockHaisList } from "../modules/BlockHaisList";
+import { BlockDivider } from '../modules/BlockDivider';
+import { casesMaisuu } from './machi/maisuu';
+
+type MachiCase = {
+    name: string,
+    hais: number[],
+    expected: number[]
+};
+
+function getMachi(hais_num: number[]): number[] {
+    return new MachiCalculator(new Hais(hais_num).getHais()).calculate();
+};
+//4枚使いの待ちを削除する
+function removeFour(hais: number[], results: number[]): number[]{ 
+    return results.filter(n => hais.filter(hn => hn === n).length !== 4);
+};
+
+function generateRandomTehai(mentsunum: number): number[] {
+    let tehainum: number[] = new Array(PAI_TYPE_NUM).fill(4);
+    const ids: number[] = Array.from({ length: PAI_TYPE_NUM }, (_, i) => i + 1);
+    const tehai: number[] = [];
+    const jantohai = Math.floor(Math.random() * tehainum.length);
+
+    //雀頭
+    tehainum[jantohai] -= 2;
+    tehai.push(jantohai + 1, jantohai + 1);
+    //面子
+    for(let i = 0; i < mentsunum; i++){
+        //順子
+        if(Math.random() < 0.5){
+            const candidate_shuntsu = ids.filter(id => {
+                const hai = new Hai(id);
+                return hai.isNumberHai() && hai.num <= 7 && 
+                    tehainum[id - 1] >= 1 &&
+                    tehainum[id] >= 1 &&
+                    tehainum[id + 1] >= 1
+            });
+            const shuntsuhai = candidate_shuntsu[Math.floor(Math.random() * candidate_shuntsu.length)];
+            tehainum[shuntsuhai - 1]--;
+            tehainum[shuntsuhai]--;
+            tehainum[shuntsuhai + 1]--;
+            tehai.push(shuntsuhai, shuntsuhai + 1, shuntsuhai + 2);
+        }
+        //刻子
+        else{
+            const candidate_kotsu = ids.filter(id => tehainum[id - 1] >= 3);
+            const kotsuhai = candidate_kotsu[Math.floor(Math.random() * candidate_kotsu.length)];
+            tehainum[kotsuhai - 1] -= 3;
+            tehai.push(kotsuhai, kotsuhai, kotsuhai);
+        }
+    }
+
+    return tehai;
+}
+
+const testcases: Map<string, MachiCase[]> = new Map();
+testcases.set("清一色", casesChinitsu);
+testcases.set("七対子", casesChitoitsu);
+testcases.set("国士無双", casesKokushi);
+testcases.set("枚数", casesMaisuu);
+
+testcases.forEach((value, key) => {
+    describe(key, () => {
+        test.each(value)('$name', ({hais, expected}) => {
+            const results = removeFour(hais, getMachi(hais));
+            expect(results).toEqual(expected);
+        });
+    });
+});
+
+describe("ランダム", () => {
+    test('random', () => {
+        let count = new Array(9).fill(0);
+
+        for(let i = 0; i < 100; i++){
+            const hais = generateRandomTehai(4);
+            const index = Math.floor(Math.random() * hais.length);
+            hais.splice(index, 1);
+
+            const machi = getMachi(hais);
+            if(machi.length > 0) count[machi.length - 1]++;
+            //待ちから完成系の手牌を作成して成立するかどうか調べる
+            for(const hai of machi){
+                const hais_agari = [...hais, hai];
+                const blocks: BlockHaisList[] = new BlockDivider(new Hais(hais_agari).getHais()).divide();
+                expect(blocks).not.toHaveLength(0);
+            }
+        }
+
+        console.log(count.map((v, i) => `${i + 1}men->${v}`));
+    });
+});

package/tests/machiType.test.ts

@@ -0,0 +1,93 @@
+import { Hais } from "../modules/Hais";
+import { BlockHaisList } from "../modules/BlockHaisList";
+import { BlockDivider } from '../modules/BlockDivider';
+import { MachiType } from "../modules/MahjongConsts";
+
+function getBlockHaisList(haisNum: number[]): BlockHaisList[]{
+    return new BlockDivider(new Hais(haisNum).getHais()).divide();
+}
+function getMachiTypeSet(haisNum: number[], haiId: number){
+    const results = getBlockHaisList(haisNum);
+    let resultMachiType: Set<MachiType> = new Set();
+    if(results.length === 1) resultMachiType = results[0].calcMachiType(haiId);
+    return resultMachiType;
+}
+
+test("tanki_1", () => {
+    const resultMachiType = getMachiTypeSet([1,2,3,4,5,6,7,8,9,10,10,10,12,12], 12);
+
+    const expected = new Set([MachiType.TANKI]);
+    expect(resultMachiType).toEqual(expected);
+});
+test("shanpon_1", () => {
+    const resultMachiType = getMachiTypeSet([1,2,3,4,5,6,7,8,9,10,10,10,12,12], 10);
+
+    const expected = new Set([MachiType.SHANPON]);
+    expect(resultMachiType).toEqual(expected);
+});
+test("ryanmen_1", () => {
+    const resultMachiType = getMachiTypeSet([1,2,3,4,5,6,7,8,9,10,10,10,12,12], 1);
+
+    const expected = new Set([MachiType.RYANMEN]);
+    expect(resultMachiType).toEqual(expected);
+});
+test("ryanmen_2", () => {
+    const resultMachiType = getMachiTypeSet([1,2,3,4,5,6,7,8,9,10,10,10,12,12], 4);
+
+    const expected = new Set([MachiType.RYANMEN]);
+    expect(resultMachiType).toEqual(expected);
+});
+test("ryanmen_3", () => {
+    const resultMachiType = getMachiTypeSet([1,2,3,4,5,6,7,8,9,10,10,10,12,12], 6);
+
+    const expected = new Set([MachiType.RYANMEN]);
+    expect(resultMachiType).toEqual(expected);
+});
+test("penchan_1", () => {
+    const resultMachiType = getMachiTypeSet([1,2,3,4,5,6,7,8,9,10,10,10,12,12], 3);
+
+    const expected = new Set([MachiType.PENCHAN]);
+    expect(resultMachiType).toEqual(expected);
+});
+test("penchan_2", () => {
+    const resultMachiType = getMachiTypeSet([1,2,3,4,5,6,7,8,9,10,10,10,12,12], 7);
+
+    const expected = new Set([MachiType.PENCHAN]);
+    expect(resultMachiType).toEqual(expected);
+});
+test("kanchan_1", () => {
+    const resultMachiType = getMachiTypeSet([1,2,3,4,5,6,7,8,9,10,10,10,12,12], 5);
+
+    const expected = new Set([MachiType.KANCHAN]);
+    expect(resultMachiType).toEqual(expected);
+});
+test("complex_1", () => {
+    const resultMachiType = getMachiTypeSet([1,2,2,2,3,4,5,6,7,8,9,10,10,10], 2);
+
+    const expected = new Set([MachiType.KANCHAN, MachiType.TANKI]);
+    expect(resultMachiType).toEqual(expected);
+});
+test("complex_2", () => {
+    const resultMachiType = getMachiTypeSet([1,2,2,2,2,3,4,5,6,7,8,9,10,10], 2);
+
+    const expected = new Set([MachiType.SHANPON, MachiType.KANCHAN]);
+    expect(resultMachiType).toEqual(expected);
+});
+test("complex_3", () => {
+    const resultMachiType = getMachiTypeSet([1,1,1,2,3,4,5,6,7,8,9,11,11,11], 1);
+
+    const expected = new Set([MachiType.RYANMEN, MachiType.TANKI]);
+    expect(resultMachiType).toEqual(expected);
+});
+test("multi_1", () => {
+    const resultMachiType = getMachiTypeSet([1,1,2,2,3,3,5,5,5,6,6,6,7,7], 2);
+
+    const expected = new Set([MachiType.KANCHAN]);
+    expect(resultMachiType).toEqual(expected);
+});
+test("multi_2", () => {
+    const resultMachiType = getMachiTypeSet([1,1,2,3,4,4,5,6,7,8,9,11,11,11], 4);
+
+    const expected = new Set([MachiType.RYANMEN]);
+    expect(resultMachiType).toEqual(expected);
+});

package/tests/score.test.ts

@@ -0,0 +1,27 @@
+import { YakuChecker } from "../modules/yaku/YakuChecker";
+import { casesScore } from './tensuu/score';
+import { TehaiCase, Score } from './testConsts';
+import { YakuContext } from '../modules/yaku/YakuContext';
+import { TehaiCaseRunner } from './tehaiCaseRunner';
+import { ScoreResolver } from '../modules/tensuu/ScoreResolver';
+
+const testcases: TehaiCase<Score[]>[] = [];
+casesScore.forEach(casesscore => testcases.push(casesscore));
+
+testcases.forEach(testcase => {
+    describe(testcase.desc, () => {
+        test(testcase.name, () => {
+            const scoreResults: Score[] = [];
+            const runner: TehaiCaseRunner<Score[]> = new TehaiCaseRunner(testcase);
+            const blocks = runner.blocks;
+            blocks.forEach((block) => {
+                const context = new YakuContext(runner.hand, runner.ctx, block);
+                const yakuMap = new YakuChecker(context).check();
+                const scoreResult = new ScoreResolver(context, yakuMap).resolve();
+                scoreResults.push({han: scoreResult.han, fuBasic: scoreResult.fuBasic, fuCeiled: scoreResult.fuCeiled});
+                console.log(scoreResult.fuDetail);
+            });
+            expect(scoreResults).toEqual(testcase.expected);
+        });
+    });
+});

package/tests/tehaiCaseRunner.ts

@@ -0,0 +1,57 @@
+import { BlockDivider } from "../modules/BlockDivider";
+import { BlockHaisList } from "../modules/BlockHaisList";
+import { Hai } from "../modules/Hai";
+import { WinEvent } from "../modules/MahjongConsts";
+import { Meld } from "../modules/Meld";
+import { Melds } from "../modules/Melds";
+import { PlayerContext } from "../modules/PlayerContext";
+import { PlayerHand } from "../modules/PlayerHand";
+import { TILE } from "../modules/tileDefs";
+import { TehaiCase } from "./testConsts";
+
+export class TehaiCaseRunner<T> {
+    private readonly testCase: TehaiCase<T>;
+    private readonly hais: Hai[];
+    private readonly melds: Melds;
+    public readonly hand: PlayerHand;
+    public readonly ctx: PlayerContext;
+    public readonly blocks: BlockHaisList[];
+
+    constructor(testcase: TehaiCase<T>){
+        this.testCase = testcase;
+        this.hais = this.testCase.hais.map(n => new Hai(n));
+        this.melds = this.makeMelds();
+        this.hand = this.makeHand();
+        this.ctx = this.makeContext();
+        this.blocks = this.divideBlocks();
+    }
+
+    private makeContext(): PlayerContext{
+        const ctx = new PlayerContext({agariHai: new Hai(this.testCase.agariHai), 
+            isTsumo: this.testCase.isTsumo, 
+            playerWind: this.testCase.playerWind ?? TILE.WIND.EAST,
+            roundWind: this.testCase.roundWind ?? TILE.WIND.EAST,
+            event: this.testCase.event ?? WinEvent.NONE,
+            riichi: this.testCase.riichi ?? false,
+            daburii: this.testCase.daburii ?? false,
+            ippatsu: this.testCase.ippatsu ?? false,
+            kuitan: this.testCase.kuitan ?? false
+        });
+
+        return ctx;
+    }
+
+    private makeMelds(): Melds{
+        const melds = new Melds();
+        this.testCase.melds.forEach(m => melds.add(Meld.from(m.hai, m.type)));
+        return melds;
+    }
+
+    private makeHand(): PlayerHand{
+        return new PlayerHand(this.hais, [...this.melds]);
+    }
+
+    private divideBlocks(): BlockHaisList[]{
+        return new BlockDivider(this.hais).divide();
+    }
+}