@kobalab/mjai-test-server 0.1.1

package/ChangeLog.md

@@ -0,0 +1,7 @@
+### v0.1.1 / 2026-09-23
+
+  - npm に登録
+
+## v0.1.0 / 2026-09-23
+
+  - 初版リリース

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Satoshi Kobayashi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# mjai-test-server
+
+Mjaiボット対戦サーバー
+
+評価のために [Mjai](https://gimite.net/pukiwiki/index.php?Mjai%20麻雀AI対戦サーバ) ボットを対戦させるサーバー。
+対戦方法には [デュプリケート対局](https://blog.kobalab.net/entry/2020/12/19/075529) を選択できる。
+対戦結果は [牌譜](https://github.com/kobalab/majiang-core/wiki/牌譜) に保存される。
+
+## インストール
+```bash
+$ npm i -g @kobalab/mjai-test-server
+```
+
+## 使用方法
+
+### mjai-test-server [ *options...* ] *mjai-bot1* *mjai-bot2*
+
+**bjai-bot1** で指定した3体のボットと **mjai-bot2** で指定したボットと対戦させます。
+
+#### --input, -i
+デュプリケート対局用の牌山を指定します。省略した場合はランダムな牌山で自動対局します。
+
+#### --output, -o
+指定されたファイルに牌譜を出力します。
+
+#### --times, -t
+対局数を指定します。省略時は指定された牌山内の対局数にしたがいます。牌山も指定がない場合は1戦だけ対局します。
+
+#### --skip, -s
+指定された数分牌山をスキップします。特定の牌山でだけ対局させたいときに便利です。
+
+#### --rule, -r
+JSONファイルもしくはJSON形式の文字列で [ルール](https://github.com/kobalab/majiang-core/wiki/ルール) を変更します。
+**--input** で牌山を指定した場合、赤牌の枚数は牌山にしたがいます。
+
+#### --verbose, -v
+Mjaiプロトコルの通信を表示します。
+
+## ライセンス
+[MIT](https://github.com/kobalab/mjai-test-server/blob/master/LICENSE)
+
+## 作者
+[Satoshi Kobayashi](https://github.com/kobalab)

package/bin/server.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const Majiang = require('@kobalab/majiang-core');
+
+const fs   = require('fs');
+const net  = require('net');
+const zlib = require('zlib');
+const { execFile } = require('child_process');
+
+const Game   = require('../lib/game');
+const Player = require('../lib/player');
+
+function get_shan(filename) {
+    if (! filename) return;
+    return JSON.parse(zlib.gunzipSync(fs.readFileSync(filename)).toString());
+}
+
+function get_rule(filename = '{}') {
+    if (filename.match(/\{.*\}/)) {
+        return Majiang.rule(JSON.parse(filename));
+    }
+    return Majiang.rule(JSON.parse(fs.readFileSync(filename)));
+}
+
+function make_player(bot, callback) {
+    const server = net.createServer((sock)=>{
+        server.close();
+        callback(sock);
+    }).listen(()=>{
+        const port = server.address().port;
+        execFile(bot, [`mjsonp://127.0.0.1:${port}/default`])
+            .on('error', (err)=>{ throw err });
+    });
+}
+
+function player_name(base, name) {
+    for (let id = 0; id < 4; id++) {
+        if (base[id]) base[id] += ` [${name[id]}]`;
+        else          base[id] = name[id];
+        base[id] = base[id].replace(/mjai\-/,'');
+    }
+    return base;
+}
+
+const argv = require('yargs')
+    .usage('Usage: $0 mjai-bot mjai-bot')
+    .option('times',    { alias: 't', description: '試行回数' } )
+    .option('input',    { alias: 'i', description: '入力ファイル(牌山)' } )
+    .option('output',   { alias: 'o', description: '出力ファイル(牌譜)' } )
+    .option('skip',     { alias: 's', description: '指定した数の牌山をスキップ' } )
+    .option('rule',     { alias: 'r', description: 'ルール' })
+    .option('verbose',  { alias: 'v', boolean: true })
+    .demandCommand(2)
+    .argv;
+
+const script = get_shan(argv.input) || [];
+for (let i = 0; i < (argv.skip || 0); i++) script.shift()
+
+const rule = get_rule(argv.rule);
+
+let times = argv.times || script && script.length || 1;
+
+const bots = [ argv._[1], argv._[0], argv._[0], argv._[0] ];
+let players = [];
+
+const logs = [];
+
+console.log(`[${times}]`, new Date().toLocaleTimeString());
+
+function start_game() {
+    players = [];
+    let s = script.shift();
+    for (let id = 0; id < 4; id++) {
+        make_player(bots[id], (sock)=>{
+            players[id] = new Player(sock);
+            if (players.filter(s => s).length == 4) {
+                players[0].debug = argv.verbose;
+                const game = s ? new Game(players, end_game, rule).script(s)
+                               : new Majiang.Game(players, end_game, rule);
+                game.model.player = player_name(game.model.player, bots);
+                game.model.title += ` #${logs.length + (argv.skip || 0)}`;
+                game.speed = 0;
+                game.kaiju();
+            }
+        });
+    }
+}
+
+function end_game(paipu) {
+    for (let player of players) {
+        player._sock.destroy();
+    }
+    console.log(`[${--times}]`, new Date().toLocaleTimeString(),
+                paipu.rank[0], paipu.point[0]);
+    if (argv.output) {
+        logs.push(paipu);
+        fs.writeFileSync(argv.output, JSON.stringify(logs), 'utf-8');
+    }
+    if (times > 0) start_game();
+}
+
+start_game();

package/lib/game.js

@@ -0,0 +1,38 @@
+/*
+ *  デュプリケート対戦
+ */
+"use strict";
+
+const Majiang = require('@kobalab/majiang-core');
+const Shan    = require('./shan');
+
+module.exports = class Game extends Majiang.Game {
+
+    script(script) {
+        this._qijia = script.qijia;
+        this._shan = [];
+        for (let i = 0; i < script.shan.length; i++) {
+            let j = i % 4;
+            if (! this._shan[j]) this._shan[j] = [];
+            this._shan[j].push(script.shan[i]);
+        }
+        return this;
+    }
+    kaiju() {
+        super.kaiju(this._qijia);
+    }
+    qipai() {
+        let pai;
+        if (this._model.zhuangfeng % 2 == 0)
+                pai = this._shan[this._model.jushu].shift();
+        else    pai = this._shan[this._model.jushu].pop();
+        if (! pai) console.log('***',
+                               this._model.zhuangfeng, this._model.jushu);
+        super.qipai(pai && new Shan(pai, this._rule));
+    }
+    zimo() {
+        if (this._model.shan.lunban)
+                        this._model.shan.lunban(this._model.lunban);
+        super.zimo();
+    }
+}

package/lib/player.js

@@ -0,0 +1,307 @@
+/*
+ *  game
+ */
+"use strict";
+
+const Majiang = require('@kobalab/majiang-core');
+
+const readline = require('readline');
+const util     = require('util');
+
+function hai(s, n) {
+    return s == 'z'? ['','E','S','W','N','P','F','C'][+n]
+                   : (+n||5) + s + (+n ? '' : 'r');
+}
+
+function tehai(paistr) {
+    paistr = paistr.replace(/,.*$/,'');
+    let bingpai = [];
+    for (let suitstr of paistr.match(/[mpsz]\d+/g)) {
+        let s = suitstr[0];
+        for (let n of suitstr.match(/\d/g)) {
+            bingpai.push(hai(s, n));
+        }
+    }
+    return bingpai;
+}
+
+function pai(p) {
+    if (p == '?') return '';
+    if (p.length == 1) return 'z' + { E:1, S:2, W:3, N:4, P:5, F:6, C:7 }[p];
+    let n = + p[0], s = p[1];
+    return s + (p[2] == 'r' ? 0 : n);
+}
+
+function mianzi(l, t, ...p) {
+    let d = ['','+','=','-'][(4 + t - l) % 4];
+    return Majiang.Shoupai.valid_mianzi(
+                p.map(p => pai(p)).join('').replace(/(?<=\d)[mpsz]/g,'') + d);
+}
+
+
+module.exports = class Player {
+
+    constructor(sock) {
+        this._sock = sock;
+        this._line = readline.createInterface(sock);
+        this._board = new Majiang.Board();
+    };
+
+    send(req) {
+        if (this.debug) console.log('<-', util.inspect(req,
+                                        { depth: null,
+                                          colors: process.stdout.isTTY }));
+        this._sock.write(JSON.stringify(req) + '\n');
+    }
+
+    recv() {
+        return new Promise(resolve =>{
+            this._line.once('line', (data)=>{
+                let res = JSON.parse(data);
+                if (this.debug) console.log('->', util.inspect(res,
+                                            { depth: null,
+                                              colors: process.stdout.isTTY }));
+                resolve(res);
+            });
+        });
+    }
+
+    async action(msg, callback) {
+
+        const board = this._board;
+
+        if (msg.kaiju) {
+            this._id = msg.kaiju.id;
+        }
+
+        if (msg.dapai && msg.dapai.p.slice(-1) == '*' && this._lizhi == null) {
+            this._lizhi = board.player_id[msg.dapai.l];
+            this.send({ type: 'reach', actor: this._lizhi });
+            await this.recv();
+        }
+        else if (this._lizhi != null && (msg.zimo || msg.fulou)) {
+            let deltas = [], scores = [];
+            for (let id = 0; id < 4; id++) {
+                deltas[id] = id == this._lizhi ? -1000 : 0;
+                scores[id] = board.defen[id];
+            }
+            this.send({ type: 'reach_accepted', actor: this._lizhi,
+                        deltas: deltas, scores: scores });
+            await this.recv();
+            this._lizhi = null;
+        }
+
+        let req;
+        if (msg.kaiju) {
+            board.kaiju(msg.kaiju);
+            req = { type:'hello', protocol:'mjsonp', protocol_version: 3 };
+            this.send(req);
+            await this.recv();
+            req = {
+                type:  'start_game',
+                id:    msg.kaiju.id,
+                names: msg.kaiju.player
+            };
+        }
+        else if (msg.qipai) {
+            board.qipai(msg.qipai);
+            let { zhuangfeng, jushu, changbang, lizhibang,
+                                            baopai, shoupai } = msg.qipai;
+            req = {
+                type:        'start_kyoku',
+                bakaze:      ['E','S','W','N'][zhuangfeng],
+                kyoku:       jushu + 1,
+                honba:       changbang,
+                kyotaku:     lizhibang,
+                oya:         (board.qijia + jushu) % 4,
+                dora_marker: hai(...baopai),
+                tehais:      []
+            };
+            for (let l = 0; l < 4; l++) {
+                let id = board.player_id[l];
+                req.tehais[id] = shoupai[l] ? tehai(shoupai[l])
+                                            : Array(13).fill('?')
+            }
+            this._lizhi = null;
+            this._peng  = [];
+        }
+        else if (msg.zimo) {
+            board.zimo(msg.zimo);
+            let { l, p } = msg.zimo;
+            req = {
+                type:  'tsumo',
+                actor: board.player_id[l],
+                pai:   p ? hai(...p) : '?'
+            };
+        }
+        else if (msg.dapai) {
+            board.dapai(msg.dapai);
+            let { l, p } = msg.dapai;
+            req = {
+                type:      'dahai',
+                actor:     board.player_id[l],
+                pai:       p ? hai(...p) : '?',
+                tsumogiri: p[2] == '_'
+            };
+        }
+        else if (msg.fulou) {
+            board.fulou(msg.fulou);
+            let { l, m } = msg.fulou;
+            let s = m[0];
+            let d = { '+': 1, '=': 2, '-': 3 }[m.match(/[\+\=\-]/)];
+            req = {
+                type:     (  m.match(/\d{4}/)                   ? 'daiminkan'
+                           : m.replace(/0/,'5').match(/(\d)\1/) ? 'pon'
+                           :                                      'chi' ),
+                actor:    board.player_id[l],
+                target:   board.player_id[(l + d) % 4],
+                pai:      hai(s, m.match(/\d(?=[\+\=\-])/)),
+                consumed: m.match(/\d(?![\+\=\-])/g).map(n => hai(s, n))
+            };
+        }
+        else if (msg.gang) {
+            board.gang(msg.gang);
+            let { l, m } = msg.gang;
+            let s = m[0];
+            if (m.match(/\d{4}/)) {
+                req = {
+                    type:   'ankan',
+                    actor:  board.player_id[l],
+                    consumed: m.match(/\d(?![\+\=\-])/g).map(n => hai(s, n))
+                };
+            }
+            else {
+                let d = { '+': 1, '=': 2, '-': 3 }[m.match(/[\+\=\-]/)];
+                req = {
+                    type:   'kakan',
+                    actor:  board.player_id[l],
+                    pai:      hai(s, m.match(/(?<=[\+\=\-])\d/)),
+                    consumed: m.match(/(?<![\+\=\-])\d/g).map(n => hai(s, n))
+                };
+            }
+        }
+        else if (msg.gangzimo) {
+            board.zimo(msg.gangzimo);
+            let { l, p } = msg.gangzimo;
+            req = {
+                type:  'tsumo',
+                actor: board.player_id[l],
+                pai:   p ? hai(...p) : '?'
+            };
+        }
+        else if (msg.kaigang) {
+            board.kaigang(msg.kaigang);
+            let { baopai } = msg.kaigang;
+            req = {
+                type:  'dora',
+                dora_marker: hai(...baopai)
+            };
+        }
+        else if (msg.hule) {
+            board.hule(msg.hule);
+            let { l, shoupai, baojia, fubaopai, fu, fanshu,
+                    damanguan, defen, hupai, fenpei } = msg.hule;
+            let hora_tehais = tehai(shoupai);
+            let hulepai = hora_tehais.pop();
+            if (baojia == null) hora_tehais.push(hulepai);
+            req = {
+                type:   'hora',
+                actor:  board.player_id[l],
+                target: board.player_id[baojia == null ? l : baojia],
+                pai:    hulepai,
+                uradora_markers: (fubaopai || []).map(p => hai(...p)),
+                hora_tehais: hora_tehais,
+                yakus:  hupai.map(h => [ h.name,
+                                         `${h.fanshu}`[0] == '*'
+                                            ? 13 : h.fanshu ]),
+                fu:     damanguan ? 20 : fu,
+                fan:    damanguan ? 13 : fanshu,
+                hora_points: defen,
+                deltas: [],
+                scores: []
+            };
+            for (let l = 0; l < 4; l++) {
+                let id = board.player_id[l];
+                req.deltas[id] = fenpei[l];
+                req.scores[id] = board.defen[id] + fenpei[l];
+            }
+        }
+        else if (msg.pingju) {
+            board.pingju(msg.pingju);
+            let { name, shoupai, fenpei } = msg.pingju;
+            req = {
+                type:   'ryukyoku',
+                reason: name,
+                tehais: [],
+                tenpais: [],
+                deltas: [],
+                scores: []
+            };
+            for (let l = 0; l < 4; l++) {
+                let id = board.player_id[l];
+                let n_fulou = board.shoupai[l]._fulou.length;
+                req.tehais[id] = shoupai[l] ? tehai(shoupai[l])
+                                            : Array(13 - n_fulou * 3).fill('?');
+                req.tenpais[id] = name == '荒牌平局' && shoupai[l] != '';
+                req.deltas[id] = fenpei[l];
+                req.scores[id] = board.defen[id] + fenpei[l];
+            }
+        }
+        else if (msg.jieju) {
+            let { defen } = msg.jieju;
+            req = {
+                type:   'end_game',
+                scores: defen
+            };
+            this.send(req);
+            if (callback) callback({});
+            return;
+        }
+
+        this.send(req);
+
+        let res = await this.recv();
+
+        let reply;
+        if (res.type == 'reach') {
+            this._lizhi = this._id;
+            this.send(res);
+            res = await this.recv();
+        }
+        if (res.type == 'dahai') {
+            reply = { dapai: pai(res.pai) + (res.tsumogiri       ? '_' : '')
+                                          + (this._lizhi != null ? '*' : '')};
+        }
+        else if (res.type == 'chi' || res.type == 'pon' ||
+                 res.type ==  'daiminkan')
+        {
+            let m = mianzi(res.actor, res.target, ...res.consumed, res.pai);
+            if (res.type == 'pon') this._peng.push(m);
+            reply = { fulou: m };
+        }
+        else if (res.type == 'ankan') {
+            reply = { gang: mianzi(res.actor, res.actor, ...res.consumed) }
+        }
+        else if (res.type == 'kakan') {
+            let i = this._peng.map(m => m.slice(0,2).replace(/0/,'5'))
+                                    .indexOf(pai(res.pai).replace(/0/,'5'));
+            reply = { gang: this._peng[i] + pai(res.pai)[1] };
+        }
+        else if (res.type == 'hora') {
+            reply = { hule: '-' };
+        }
+        else if (res.type == 'ryukyoku') {
+            reply = { daopai: '-' };
+        }
+        else if (res.type == 'none') {
+            reply = {};
+        }
+
+        if (callback) callback(reply);
+
+        if (msg.hule || msg.pingju) {
+            this.send({ type: 'end_kyoku' });
+            await this.recv();
+        }
+    };
+}

package/lib/shan.js

@@ -0,0 +1,56 @@
+/*
+ *  デュプリケート対戦用牌山操作
+ */
+"use strict";
+
+const Majiang = require('@kobalab/majiang-core');
+
+module.exports = class Shan {
+
+    constructor(pai, rule = Majiang.rule()) {
+        this._rule = rule;
+        this._wangpai = pai.splice(0, 14);
+        this._qipai   = pai.splice(0, 13 * 4);
+        this._zimo    = [[],[],[],[]];
+        let l = 0;
+        while (pai.length) {
+            this._zimo[l].push(pai.shift());
+            l = (l + 1) % 4;
+        }
+        this._lunban = -1;
+        this._paishu = 136 - 14;
+
+        this._baopai   = [];
+        this._fubaopai = [];
+        this.kaigang();
+    }
+    static zhenbaopai(p) { return Majiang.Shan.zhenbaopai(p) }
+    lunban(l) { this._lunban = (l + 1) % 4 }
+    zimo() {
+        this._paishu--;
+        if (this._lunban < 0) return this._qipai.shift();
+        if (this._zimo[this._lunban].length)
+                            return this._zimo[this._lunban].shift();
+        let l = [0,1,2,3].reduce((x,y)=>
+                        this._zimo[x].length > this._zimo[y].length ? x : y);
+        return this._zimo[l].pop();
+    }
+    gangzimo() { return this.zimo() }
+    kaigang() {
+        this._baopai.push(this._wangpai.shift());
+        this._fubaopai.push(this._wangpai.shift());
+        return this;
+    }
+    close()      { return this }
+    get paishu() { return this._paishu }
+    get baopai() {
+        if (this._rule['カンドラあり'])   return this._baopai.concat();
+        else                            return [ this._baopai[0] ];
+    }
+    get fubaopai() {
+        if (! this._rule['裏ドラあり']) return;
+        if (this._rule['カンドラあり'] && this._rule['カン裏あり'])
+                                        return this._fubaopai.concat();
+        else                            return [ this._fubaopai[0] ]
+    }
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@kobalab/mjai-test-server",
+  "version": "0.1.1",
+  "description": "Mjaiボット対戦サーバー",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "mjai-test-server": "bin/server.js"
+  },
+  "scripts": {
+    "start": "node bin/server.js"
+  },
+  "keywords": [
+    "麻雀",
+    "Mjai",
+    "電脳麻将"
+  ],
+  "author": "Satoshi Kobayashi",
+  "license": "MIT",
+  "type": "commonjs",
+  "dependencies": {
+    "@kobalab/majiang-core": "^1.4.1",
+    "yargs": "^17.7.3"
+  }
+}