mahjong_engine 1.0.0

package/modules/Hai.ts

@@ -0,0 +1,67 @@
+import { HaiType } from "./MahjongConsts";
+import { TILE } from "./tileDefs";
+
+export class Hai{
+    private readonly id: number;
+
+    constructor(id: number){
+        this.id = id;
+    }
+
+    get type(): HaiType{
+        if((TILE.MANZU as readonly number[]).includes(this.id)) return HaiType.MANZU;
+        if((TILE.PINZU as readonly number[]).includes(this.id)) return HaiType.PINZU;
+        if((TILE.SOUZU as readonly number[]).includes(this.id)) return HaiType.SOUZU;
+        if((TILE.JIHAI as readonly number[]).includes(this.id)) return HaiType.JIHAI;
+        return HaiType.BACK;
+    }
+
+    get num(): number{
+        if(this.type == HaiType.MANZU) return this.id;
+        if(this.type == HaiType.PINZU) return this.id - 9;
+        if(this.type == HaiType.SOUZU) return this.id - 18;
+        if(this.type == HaiType.JIHAI) return this.id;
+        return TILE.BACK;
+    }
+
+    get imageUrl(): string{
+        //萬子
+        if(this.type === HaiType.MANZU) return `m_${this.num}.png`;
+        //筒子
+        if(this.type === HaiType.PINZU) return `p_${this.num}.png`;
+        //索子
+        if(this.type === HaiType.SOUZU) return `s_${this.num}.png`;
+        //字牌
+        if(this.type === HaiType.JIHAI) return `j_${this.num - 27}.png`;
+        
+        return `back.png`;
+    }
+
+    isRoutouHai(): boolean {
+        return (this.num === 1 || this.num === 9) && this.isNumberHai();
+    }
+
+    isNumberHai(): boolean {
+        return this.type === HaiType.MANZU || this.type === HaiType.PINZU || this.type === HaiType.SOUZU;
+    }
+
+    isJihai(): boolean {
+        return this.type === HaiType.JIHAI;
+    }
+
+    isYaochuHai(): boolean {
+        return this.isRoutouHai() || this.isJihai();
+    }
+
+    isChuchanHai(): boolean {
+        return !this.isYaochuHai();
+    }
+
+    getId(): number {
+        return this.id;
+    }
+
+    clone(): Hai {
+        return new Hai(this.id);
+    }
+}

package/modules/Hais.ts

@@ -0,0 +1,49 @@
+import {Hai} from './Hai';
+
+export class Hais{
+    private readonly hais: Hai[];
+
+    constructor(ids: number[] = []){
+        this.hais = ids.map(id => new Hai(id));
+    }
+
+    [Symbol.iterator]() { return this.hais[Symbol.iterator](); }
+
+    //末尾に追加
+    push(id: number){
+        this.hais.push(new Hai(id));
+    }
+
+    //末尾を取り除く
+    pop(): Hai | undefined {
+        return this.hais.pop()
+    }
+
+    //任意の牌を取り除く
+    remove(id: number) {
+        const index = this.hais.findIndex(h => h.getId() === id);
+        if(index !== -1) this.hais.splice(index, 1);
+    }
+
+    //牌を昇順に並び替える
+    sort() {
+        this.hais.sort((a, b) => a.getId() - b.getId());
+    }
+
+    //指定された牌がいくつあるか数える
+    count(id: number): number {
+        return this.hais.filter(h => h.getId() === id).length;
+    }
+
+    getHais(): Hai[] {
+        return this.hais;
+    }
+
+    get ids(): number[] {
+        return this.hais.map(h => h.getId());
+    }
+
+    get length(): number {
+        return this.hais.length;
+    }
+}

package/modules/IMentsu.ts

@@ -0,0 +1,20 @@
+import { BlockType, MeldType } from "./MahjongConsts";
+import { Hai } from "./Hai";
+import { Wind } from "./tileDefs";
+
+export interface IMentsu {
+    getType(): BlockType | MeldType;
+    getHais(): Hai[];
+    hasRoutouHai(): boolean;
+    hasJihai(): boolean;
+    isShuntsu(): boolean;
+    isKotsuOrKantsu(): boolean;
+    isDragon(): boolean;
+    isSingleWind(playerWind: Wind): boolean;
+    isDoubleWind(playerWind: Wind, roundWind: Wind): boolean
+    isYakuhai(playerWind: Wind, roundWind: Wind): boolean
+    containsHai(...haiIds: number[]): boolean;
+    clone(): IMentsu;
+    get minHai(): Hai;
+    get maxHai(): Hai;
+}

package/modules/MachiCalculator.ts

@@ -0,0 +1,25 @@
+import { Hai } from './Hai';
+import { BlockDivider } from './BlockDivider';
+import { PAI_TYPE_NUM } from './MahjongConsts';
+
+export class MachiCalculator{
+    private readonly hais: Hai[];
+
+    constructor(hais: Hai[]){
+        this.hais = hais.map(h => h.clone()).sort((a, b) => a.getId() - b.getId());
+    }
+
+    calculate(): number[] {
+        const machi: number[] = [];
+
+        for(let i = 1; i <= PAI_TYPE_NUM; i++){
+            const testhais = [...this.hais, new Hai(i)];
+            const divided = new BlockDivider(testhais).divide();
+            if(divided.length > 0){
+                machi.push(i);
+            }
+        }
+
+        return machi;
+    }
+}

package/modules/MahjongConsts.ts

@@ -0,0 +1,46 @@
+//手配の数
+export const TEHAI_NUMBER: number = 14;
+//牌の種類数
+export const PAI_TYPE_NUM: number = 34;
+
+//鳴きのタイプ
+export enum MeldType{
+    CHI = "chi",
+    PON = "pon",
+    ANKAN = "ankan",
+    MINKAN = "minkan"
+}
+//牌のタイプ
+export enum HaiType{
+    MANZU,
+    PINZU,
+    SOUZU,
+    JIHAI,
+    BACK
+}
+//ブロックのタイプ
+export enum BlockType{
+    JANTO = "janto",
+    KOTSU = "kotsu",
+    SHUNTSU = "shuntsu",
+    CHITOI = "chitoi",
+    KOKUSHI = "kokushi"
+}
+//待ちのタイプ
+export enum MachiType{
+    TANKI,
+    SHANPON,
+    RYANMEN,
+    KANCHAN,
+    PENCHAN,
+}
+//アガリ時に付随する条件式の役
+export enum WinEvent{
+    NONE,
+    TENHO,
+    CHIHO,
+    RINSHAN,
+    CHANKAN,
+    HAITEI,
+    HOUTEI
+}

package/modules/Meld.ts

@@ -0,0 +1,85 @@
+import { Hai } from './Hai';
+import { MeldType } from './MahjongConsts';
+import { IMentsu } from './IMentsu';
+import { TILE, Wind } from "./tileDefs";
+
+export class Meld implements IMentsu {
+    private readonly hais: Hai[];
+    private readonly type: MeldType;
+
+    constructor(hais: Hai[], type: MeldType){
+        this.hais = hais;
+        this.type = type;
+    }
+
+    static from(haiId: number, type: MeldType): Meld {
+        const hai = new Hai(haiId);
+        if(type === MeldType.PON){
+            return new Meld([hai.clone(), hai.clone(), hai.clone()], type);
+        }
+        if(type === MeldType.CHI){
+            return new Meld([hai.clone(), new Hai(haiId + 1), new Hai(haiId + 2)], type);
+        }
+        else
+            return new Meld([hai.clone(), hai.clone(), hai.clone(), hai.clone()], type);
+    }
+
+    getHais(): Hai[] {
+        return this.hais;
+    }
+
+    getType(): MeldType {
+        return this.type;
+    }
+
+    hasRoutouHai(): boolean {
+        return this.hais.some(h => h.isRoutouHai());
+    }
+
+    hasJihai(): boolean {
+        return this.hais.some(h => h.isJihai());
+    }
+
+    isShuntsu(): boolean {
+        return this.type === MeldType.CHI;
+    }
+
+    isKotsuOrKantsu(): boolean {
+        return this.type === MeldType.PON || this.type === MeldType.ANKAN || this.type === MeldType.MINKAN;
+    }
+
+    isDragon(): boolean {
+        return this.containsHai(TILE.DRAGON.WHITE.id, TILE.DRAGON.GREEN.id, TILE.DRAGON.RED.id);
+    }
+
+    isSingleWind(targetWind: Wind): boolean {
+        return this.containsHai(targetWind.id);
+    }
+
+    isDoubleWind(playerWind: Wind, roundWind: Wind): boolean {
+        return this.isSingleWind(playerWind) && this.isSingleWind(roundWind);
+    }
+
+    isYakuhai(playerWind: Wind, roundWind: Wind): boolean {
+        return this.isDragon() ||
+               this.isSingleWind(playerWind) ||
+               this.isSingleWind(roundWind) ||
+               this.isDoubleWind(playerWind, roundWind);
+    }
+
+    containsHai(...haiIds: number[]): boolean {
+        return this.hais.some(h => haiIds.includes(h.getId()));
+    }
+
+    clone(): Meld {
+        return new Meld(this.hais.map(h => h.clone()), this.type);
+    }
+
+    get minHai(): Hai {
+        return this.hais.reduce((min, h) => h.num < min.num ? h : min);
+    }
+
+    get maxHai(): Hai {
+        return this.hais.reduce((max, h) => h.num > max.num ? h : max);
+    }
+}

package/modules/Melds.ts

@@ -0,0 +1,19 @@
+import {Meld} from "./Meld";
+
+export class Melds {
+    private readonly melds: Meld[] = [];
+
+    constructor(melds: Meld[] = []) {
+        this.melds = melds;
+    }
+
+    [Symbol.iterator]() { return this.melds[Symbol.iterator](); }
+
+    add(meld: Meld){
+        this.melds.push(meld);
+    }
+
+    get length() {
+        return this.melds.length;
+    }
+}

package/modules/MentsuAnalyzer.ts

@@ -0,0 +1,37 @@
+import { IMentsu } from './IMentsu';
+import { Wind } from './tileDefs';
+
+export class MentsuAnalyzer {
+    private readonly allMentsu: IMentsu[];
+    constructor(block: IMentsu[], melds: IMentsu[]){
+        this.allMentsu = [...block, ...melds];
+    }
+
+    getAll(): IMentsu[]{
+        return this.allMentsu;
+    }
+
+    hasSingleWindMentsu(
+        filter: (m: IMentsu) => boolean,
+        requiredWind: Wind,
+        forbiddenWind: Wind
+    ): boolean {
+        return this.allMentsu.some(m => filter(m) && m.isSingleWind(requiredWind) && !m.isSingleWind(forbiddenWind));
+    }
+
+    hasDoubleWindMentsu(
+        filter: (m: IMentsu) => boolean,
+        playerWind: Wind,
+        roundWind: Wind
+    ): boolean {
+        return this.allMentsu.some(m => filter(m) && m.isDoubleWind(playerWind, roundWind));
+    }
+
+    hasYakuhaiMentsu(
+        filter: (m: IMentsu) => boolean,
+        playerWind: Wind,
+        roundWind: Wind
+    ): boolean {
+        return this.allMentsu.some(m => filter(m) && m.isYakuhai(playerWind, roundWind));
+    }
+}

package/modules/PlayerContext.ts

@@ -0,0 +1,39 @@
+import { Hai } from "./Hai";
+import { WinEvent } from "./MahjongConsts";
+import { Wind } from "./tileDefs";
+
+interface UserOptions {
+    agariHai: Hai
+    isTsumo: boolean;
+    playerWind: Wind;
+    roundWind: Wind;
+    event?: WinEvent;
+    riichi?: boolean;
+    daburii?: boolean;
+    ippatsu?: boolean;
+    kuitan?: boolean;
+}
+
+export class PlayerContext{
+    agariHai: Hai;
+    isTsumo: boolean;
+    playerWind: Wind;
+    roundWind: Wind;
+    event: WinEvent;
+    riichi: boolean;
+    daburii: boolean;
+    ippatsu: boolean;
+    kuitan: boolean;
+
+    constructor(options: UserOptions) {
+        this.agariHai = options.agariHai;
+        this.isTsumo = options.isTsumo;
+        this.playerWind = options.playerWind;
+        this.roundWind = options.roundWind;
+        this.event = options.event ?? WinEvent.NONE;
+        this.riichi =  options.riichi ?? false;
+        this.daburii =  options.daburii ?? false;
+        this.ippatsu =  options.ippatsu ?? false;
+        this.kuitan =  options.kuitan ?? false;
+    }
+}

package/modules/PlayerHand.ts

@@ -0,0 +1,32 @@
+import { Hai } from './Hai';
+import { Meld } from './Meld';
+import { MeldType } from './MahjongConsts';
+
+export class PlayerHand {
+    private readonly tehai: Hai[];
+    private readonly furo: Meld[];
+
+    constructor(tehai: Hai[], furo: Meld[]){
+        this.tehai = tehai;
+        this.furo = furo;
+    }
+
+    getTehai(): Hai[] {
+        return this.tehai;
+    }
+
+    getFuro(): Meld[] {
+        return this.furo;
+    }
+
+    isMenzen(){
+        return this.furo.every(meld => meld.getType() === MeldType.ANKAN);
+    }
+
+    getAllTiles(): Hai[] {
+        const hais = this.tehai.map(h => h.clone());
+        const meldHais = this.furo.flatMap(m => m.getHais().map(h => h.clone()));
+        return [...hais, ...meldHais];
+    }
+
+}

package/modules/index.ts

@@ -0,0 +1,11 @@
+export { Hai } from './Hai.js';
+export { Hais } from './Hais.js';
+export { Melds } from './Melds.js';
+export { BlockDivider } from './BlockDivider.js';
+export { PlayerHand } from './PlayerHand.js';
+export { PlayerContext } from './PlayerContext.js';
+export { ScoreResolver } from './tensuu/ScoreResolver.js';
+export { YakuContext } from './yaku/YakuContext.js';
+export { YakuChecker } from './yaku/YakuChecker.js';
+export { TILE } from './tileDefs.js';
+export { ScoreResult } from './tensuu/ScoreResult.js';

package/modules/tensuu/FuCalculator.ts

@@ -0,0 +1,118 @@
+import { BlockHais } from '../BlockHais';
+import { BlockType, MachiType, MeldType } from '../MahjongConsts';
+import { MentsuAnalyzer } from '../MentsuAnalyzer';
+import { YakuContext } from '../yaku/YakuContext';
+import { FuDetail } from './FuDetail';
+
+type MentsuFuSpec = {
+    yaochu: {name: string, fu: number};
+    chuchan: {name: string, fu: number};
+};
+
+const MENTSU_FU_TABLE: Record<string, MentsuFuSpec> = {
+        [BlockType.KOTSU]: {
+            yaochu: {name: "么九牌暗刻", fu: 8},
+            chuchan: {name: "中張牌暗刻", fu: 4}
+        },
+        [MeldType.PON]: {
+            yaochu: {name: "么九牌明刻", fu: 4},
+            chuchan: {name: "中張牌明刻", fu: 2}
+        },
+        [MeldType.MINKAN]: {
+            yaochu: {name: "么九牌明槓", fu: 16},
+            chuchan: {name: "中張牌明槓", fu: 8}
+        },
+        [MeldType.ANKAN]: {
+            yaochu: {name: "么九牌暗槓", fu: 32},
+            chuchan: {name: "中張牌暗槓", fu: 16}
+        }
+    } as const;
+
+export class FuCalculator{
+    private readonly context: YakuContext;
+    private readonly yaku: Map<string, number>;
+
+    constructor(context: YakuContext, yaku: Map<string, number>){
+        this.context = context;
+        this.yaku = yaku;
+    }
+
+    private calcSpecialFu(): FuDetail | null{
+        if(this.yaku.has("平和") && this.context.ctx.isTsumo) return new FuDetail("平和ツモ", 20);
+        if(this.yaku.has("七対子")) return new FuDetail("七対子", 25);
+
+        return null;
+    }
+
+    private calcBaseFu(): FuDetail[]{
+        const baseFu: FuDetail[] = [new FuDetail("符底", 20)];
+        const isTsumo = this.context.ctx.isTsumo;
+
+        if(isTsumo) baseFu.push(new FuDetail("ツモ", 2));
+        if(!isTsumo && this.context.hand.isMenzen()) baseFu.push(new FuDetail("面前ロン", 10));
+        
+        return baseFu;
+    }
+
+    private calcMachuFu(): FuDetail[]{
+        const machiFu: FuDetail[] = [];
+        const machiType = this.calcMachiType();
+        if(machiType.has(MachiType.TANKI)) machiFu.push(new FuDetail("単騎待ち", 2));
+        else if(machiType.has(MachiType.KANCHAN)) machiFu.push(new FuDetail("嵌張待ち", 2));
+        else if(machiType.has(MachiType.PENCHAN)) machiFu.push(new FuDetail("辺張待ち", 2));
+
+        return machiFu;
+    }
+
+    private calcJantoFu(analyzer: MentsuAnalyzer): FuDetail[]{
+        const JantoFu: FuDetail[] = [];
+        const pw = this.context.ctx.playerWind;
+        const rw = this.context.ctx.roundWind;
+        const hasYakuhaiJanto = analyzer.hasYakuhaiMentsu(m => m instanceof BlockHais && m.isJanto(), pw, rw);
+        
+        if(!hasYakuhaiJanto) return JantoFu;
+        
+        for(const m of analyzer.getAll()){
+            if(m.getType() === BlockType.JANTO){
+                JantoFu.push(new FuDetail("役牌雀頭", 2, m));
+            }
+        }
+
+        return JantoFu;
+    }
+
+    private calcMentsuFu(analyzer: MentsuAnalyzer): FuDetail[]{
+        const MentsuFu: FuDetail[] = [];
+
+        for(const m of analyzer.getAll()){
+            const table = MENTSU_FU_TABLE[m.getType()];
+            if(!table) continue;
+
+            const key = m.minHai.isYaochuHai() ? "yaochu" : "chuchan";
+            const spec = table[key];
+            
+            MentsuFu.push(new FuDetail(spec.name, spec.fu, m));
+        }
+
+        return MentsuFu;
+    }
+
+    calcFu(): FuDetail[]{
+        const special = this.calcSpecialFu();
+        if(special) return [special];
+
+        const analyzer = new MentsuAnalyzer(this.context.block.getBlockHais(), this.context.melds);
+
+        return [
+            ...this.calcBaseFu(),
+            ...this.calcMachuFu(),
+            ...this.calcJantoFu(analyzer),
+            ...this.calcMentsuFu(analyzer),
+        ];
+    }
+
+    private calcMachiType(): Set<MachiType>{
+        const agariHaiId = this.context.ctx.agariHai.getId();
+        return this.context.block.calcMachiType(agariHaiId);
+    }
+}

package/modules/tensuu/FuDetail.ts

@@ -0,0 +1,13 @@
+import { IMentsu } from "../IMentsu";
+
+export class FuDetail{
+    readonly name: string;
+    readonly fu: number;
+    readonly mentsu?: IMentsu;
+
+    constructor(name: string, fu: number, mentsu?: IMentsu){
+        this.name = name;
+        this.fu = fu;
+        this.mentsu = mentsu;
+    }
+}

package/modules/tensuu/ScoreResolver.ts

@@ -0,0 +1,35 @@
+import { YakuContext } from '../yaku/YakuContext';
+import { TensuuCalculator } from './TensuuCalculator';
+import { FuCalculator } from './FuCalculator';
+import { FuDetail } from './FuDetail';
+import { ScoreResult } from './ScoreResult';
+
+export class ScoreResolver{
+    private readonly context: YakuContext;
+    private readonly yaku: Map<string, number>;
+    constructor(context: YakuContext, yaku: Map<string, number>){
+        this.context = context;
+        this.yaku = yaku;
+    }
+
+    private calcHonsuu(): number{
+        return [...this.yaku.values()].reduce((sum, val) => sum + val, 0);
+    }
+
+    private countFusuu(detail: FuDetail[]): number{
+        return detail.reduce((sum, val) => sum + val.fu, 0);
+    }
+
+    private ceilFusuu(fu: number): number{
+        return fu === 25 ? 25 : Math.ceil(fu / 10) * 10;
+    }
+
+    resolve(){
+        const han = this.calcHonsuu();
+        const fuDetail = new FuCalculator(this.context, this.yaku).calcFu();
+        const fuBasic = this.countFusuu(fuDetail);
+        const fuCeiled = this.ceilFusuu(fuBasic);
+        const tensuu = TensuuCalculator.calcTensuu(han, fuCeiled);
+        return new ScoreResult(han, fuBasic, fuCeiled, tensuu, fuDetail);
+    }
+}

package/modules/tensuu/ScoreResult.ts

@@ -0,0 +1,24 @@
+import { FuDetail } from "./FuDetail";
+import { TensuuResult } from "./TensuuResult";
+
+export class ScoreResult{
+    public readonly han: number;
+    public readonly fuBasic: number;
+    public readonly fuCeiled: number;
+    public readonly tensuu: TensuuResult;
+    public readonly fuDetail: FuDetail[];
+
+    constructor(
+        han: number,
+        fuBasic: number,
+        fuCeiled: number,
+        tensuu: TensuuResult,
+        fuDetail: FuDetail[]
+    ){
+        this.han = han;
+        this.fuBasic = fuBasic;
+        this.fuCeiled = fuCeiled;
+        this.tensuu = tensuu;
+        this.fuDetail = fuDetail;
+    }
+}

package/modules/tensuu/TensuuCalculator.ts

@@ -0,0 +1,40 @@
+import { TensuuResult } from './TensuuResult';
+
+export class TensuuCalculator{
+    static readonly BASE_LIMITS = [
+        {han: 26, base: 16000 },
+        {han: 13, base: 8000 },
+        {han: 11, base: 6000 },
+        {han: 8,  base: 4000 },
+        {han: 6,  base: 3000 },
+        {han: 5,  base: 2000 },
+    ];
+
+    static calcBaseTensuu(han: number, fu: number): number{
+        return Math.min(fu * Math.pow(2, han + 2), 2000);
+    }
+
+    static calcRonTensuu(base: number, multi: number): number{
+        return Math.ceil(base * multi / 100) * 100;
+    }
+
+    static calcdividedTensuu(ronTensuu: number, divide: number){
+        return Math.ceil(Math.floor(ronTensuu / divide) / 100) * 100;
+    }
+
+    static calcTensuuFromBase(base: number): TensuuResult{
+        const ronOya = this.calcRonTensuu(base, 6);
+        const ronKo = this.calcRonTensuu(base, 4);
+        const tsumoOya = this.calcdividedTensuu(ronOya, 3);
+        const tsumoKo = {oya: this.calcdividedTensuu(ronKo, 2), ko: this.calcdividedTensuu(ronKo, 4)};
+
+        return new TensuuResult(base, ronOya, ronKo, tsumoOya, tsumoKo);
+    }
+
+    static calcTensuu(han: number, fu: number): TensuuResult{
+        for(const limit of this.BASE_LIMITS){
+            if(han >= limit.han) return this.calcTensuuFromBase(limit.base);
+        }
+        return this.calcTensuuFromBase(this.calcBaseTensuu(han, fu));
+    } 
+}