@hieuzest/koishi-plugin-mahjongpub 0.1.22 → 0.2.1

package/lib/api.d.ts

@@ -1,8 +1,8 @@
 import { Context, Dict, Quester } from 'koishi';
 export interface Team {
     pw?: string;
-    tid: string;
-    cid?: string;
+    tid: number;
+    cid?: number;
     name: string;
     players: string[];
     qq?: string[];
@@ -12,8 +12,8 @@ export declare class TeamAdmin implements Team {
     options: {
         endpoint: string;
     };
-    tid: string;
-    cid: string;
+    tid: number;
+    cid: number;
     name: string;
     description: string;
     players: string[];
@@ -28,16 +28,16 @@ export declare class TeamAdmin implements Team {
 }
 declare namespace TeamAdmin {
     interface Payload {
-        tid: string;
+        tid: number;
         t_name: string;
         t_player?: string;
         t_sub?: string;
         t_pw: string;
         t_join_time?: string;
         t_join_ip?: string;
-        t_type?: string;
+        t_type?: number;
         t_ps?: string;
-        cid: string;
+        cid: number;
         qq?: string;
         ls_ip?: string;
         ls_time?: string;
@@ -45,19 +45,22 @@ declare namespace TeamAdmin {
     }
 }
 export declare class ContestAdmin {
-    cid: string;
+    cid: number;
     pw: string;
     options: {
         endpoint: string;
     };
     name: string;
     teams: Dict<Team>;
+    round: number;
     http: Quester;
     raw?: ContestAdmin.Payload;
-    constructor(ctx: Context, cid: string, pw: string, options: {
+    constructor(ctx: Context, cid: number, pw: string, options: {
         endpoint: string;
     });
     read(force?: boolean): Promise<void>;
+    getRounds(): Promise<Record<number, Record<number, Contest.Round>>>;
+    getRecords(round: number): Promise<Contest.Records>;
     getRoundRecord(round: number, cls: number): Promise<ContestAdmin.MatchRoundRecord>;
     updateRoundRecord(record: ContestAdmin.MatchRoundRecord): Promise<string>;
 }
@@ -67,13 +70,13 @@ declare namespace ContestAdmin {
             c_name: string;
             c_gonggao: string;
             c_pad: string;
-            c_round: string;
-            c_s_po: string;
-            c_sub_t: string;
-            cid: string;
-            r_type: string;
-            t_max: string;
-            t_sub: string;
+            c_round: number;
+            c_s_po: number;
+            c_sub_t: number;
+            cid: number;
+            r_type: number;
+            t_max: number;
+            t_sub: number;
             t_type: string;
         };
         c_team: TeamAdmin.Payload[];
@@ -88,10 +91,85 @@ declare namespace ContestAdmin {
         logurl: string;
     }
     interface MatchRoundRecord {
-        cid: string;
+        cid: number;
         cls: number;
         rnd: number;
         matches: MatchRecord[];
     }
+    interface RoundPayload {
+        clsmark: string;
+        code: string;
+        rid: number;
+        round: number;
+        t_class: number;
+        tid1: number;
+        tid2: number;
+        tid3: number;
+        tid4: number;
+    }
+    interface Round {
+        rid: number;
+        round: number;
+        cls: number;
+        code: string;
+        tids: number[];
+    }
+}
+declare namespace Contest {
+    interface RoundPayload {
+        clsmark: string;
+        code: string;
+        rid: number;
+        round: number;
+        t_class: number;
+        tid1: number;
+        tid2: number;
+        tid3: number;
+        tid4: number;
+    }
+    interface Round {
+        rid: number;
+        round: number;
+        cls: number;
+        code: string;
+        tids: number[];
+    }
+    interface MatchPayload {
+        inx: number;
+        cid: number;
+        rowi: number;
+        name1: string;
+        num1: number;
+        name2: string;
+        num2: number;
+        name3: string;
+        num3: number;
+        name4: string;
+        num4: number;
+        url: string;
+        pint1: number;
+        pint2: number;
+        pint3: number;
+        pint4: number;
+        rid: number;
+        round: number;
+        i_time: string;
+    }
+    interface Match {
+        inx: number;
+        cid: number;
+        rowi: number;
+        players: {
+            name: string;
+            num: number;
+            point: number;
+        }[];
+        url: string;
+        rid: number;
+        round: number;
+        time: string;
+    }
+    type RecordsPayload = Record<number, MatchPayload[]>;
+    type Records = Record<number, Match[]>;
 }
 export {};

package/lib/index.d.ts

@@ -1,6 +1,9 @@
-import { Context, Dict, Schema } from 'koishi';
+import { Context, Dict, Schema, Service } from 'koishi';
 import { ContestAdmin, TeamAdmin } from './api';
 declare module 'koishi' {
+    interface Context {
+        mahjongpub: MahjongPub;
+    }
     interface User {
         'mahjongpub/bind-team': string;
         'mahjongpub/bind-teams': Dict<string>;
@@ -17,9 +20,9 @@ declare module '@koishijs/cache' {
         teams: TeamAdmin;
     }
 }
-export declare class MahjongPub {
-    private ctx;
-    private config;
+export declare class MahjongPub extends Service {
+    protected ctx: Context;
+    config: MahjongPub.Config;
     teams: Dict<TeamAdmin>;
     contests: Dict<ContestAdmin>;
     constructor(ctx: Context, config: MahjongPub.Config);

package/lib/index.js

@@ -23,18 +23,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/locales/zh-CN.yml
 var require_zh_CN = __commonJS({
   "src/locales/zh-CN.yml"(exports2, module2) {
-    module2.exports = { commands: { "mahjongpub.team.bind": { description: "绑定队伍", messages: { failed: "绑定失败", success: "成功： [{cid}:{tid}] {name}" } }, "mahjongpub.team.unbind": { description: "解除绑定", messages: { notbind: "未绑定", success: "成功" } }, "mahjongpub.team.password": { description: "查看密码", messages: { notbind: "未绑定", output: "密码： {0}" } }, "mahjongpub.team.stats": { description: "查看队伍信息", messages: { notbind: "未绑定", failed: "失败", output: "- [{cid}:{tid}] {name}\n{players.map((p, i) => '' + (i+1) + ': ' + p).join('\\n')}\n" } }, "mahjongpub.team.desc": { description: "队伍简介", messages: { notbind: "未绑定", failed: "失败", output: "- [{cid}:{tid}] {name}\n{description}\n" } }, "mahjongpub.team.logo": { description: "队伍头像", messages: { notbind: "未绑定", failed: "失败" } }, "mahjongpub.team.add": { description: "添加队员", messages: { notbind: "未绑定", failed: "失败", success: "- [{cid}:{tid}] {name}\n{players.map((p, i) => '' + (i+1) + ': ' + p).join('\\n')}\n" } }, "mahjongpub.team.remove": { description: "删除队员", messages: { notbind: "未绑定", failed: "失败", success: "- [{cid}:{tid}] {name}\n{players.map((p, i) => '' + (i+1) + ': ' + p).join('\\n')}\n" } }, "mahjongpub.team.swap": { description: "交换队员", messages: { notbind: "未绑定", failed: "失败", invalid: "参数错误", "wide-range": "范围过大", success: "- [{cid}:{tid}] {name}\n{players.map((p, i) => '' + (i+1) + ': ' + p).join('\\n')}\n" } }, "mahjongpub.contest.bind": { description: "绑定比赛", messages: { failed: "绑定失败", success: "成功： [{cid}] {name}" } }, "mahjongpub.contest.record.get": { description: "查询比赛记录", messages: { failed: "查询失败" } }, "mahjongpub.contest.record.update": { description: "修改比赛记录", messages: { failed: "修改失败" } }, "mahjongpub.database.record.get": { description: "查询比赛记录", messages: { failed: "查询失败" } }, "mahjongpub.database.record.update": { description: "修改比赛记录", messages: { success: "修改成功", failed: "修改失败", unmodified: "未修改" } } } };
+    module2.exports = { commands: { "mahjongpub.team.bind": { description: "绑定队伍", messages: { failed: "绑定失败", success: "成功： [{cid}:{tid}] {name}" } }, "mahjongpub.team.unbind": { description: "解除绑定", messages: { notbind: "未绑定", success: "成功" } }, "mahjongpub.team.password": { description: "查看密码", messages: { notbind: "未绑定", output: "密码： {0}" } }, "mahjongpub.team.stats": { description: "查看队伍信息", messages: { notbind: "未绑定", failed: "失败", output: "- [{cid}:{tid}] {name}\n{players.map((p, i) => '' + (i+1) + ': ' + p).join('\\n')}\n" } }, "mahjongpub.team.desc": { description: "队伍简介", messages: { notbind: "未绑定", failed: "失败", output: "- [{cid}:{tid}] {name}\n{description}\n" } }, "mahjongpub.team.logo": { description: "队伍头像", messages: { notbind: "未绑定", failed: "失败" } }, "mahjongpub.team.add": { description: "添加队员", messages: { notbind: "未绑定", failed: "失败", success: "- [{cid}:{tid}] {name}\n{players.map((p, i) => '' + (i+1) + ': ' + p).join('\\n')}\n" } }, "mahjongpub.team.remove": { description: "删除队员", messages: { notbind: "未绑定", failed: "失败", success: "- [{cid}:{tid}] {name}\n{players.map((p, i) => '' + (i+1) + ': ' + p).join('\\n')}\n" } }, "mahjongpub.team.swap": { description: "交换队员", messages: { notbind: "未绑定", failed: "失败", invalid: "参数错误", "wide-range": "范围过大", success: "- [{cid}:{tid}] {name}\n{players.map((p, i) => '' + (i+1) + ': ' + p).join('\\n')}\n" } }, "mahjongpub.contest.bind": { description: "绑定比赛", messages: { failed: "绑定失败", success: "成功： [{cid}] {name}" } }, "mahjongpub.contest.password": { description: "查看密码", messages: { failed: "未绑定", success: "[{0}] {1}\n" } }, "mahjongpub.contest.record.get": { description: "查询比赛记录", messages: { failed: "查询失败" } }, "mahjongpub.contest.record.update": { description: "修改比赛记录", messages: { failed: "修改失败" } }, "mahjongpub.database.record.get": { description: "查询比赛记录", messages: { failed: "查询失败" } }, "mahjongpub.database.record.update": { description: "修改比赛记录", messages: { success: "修改成功", failed: "修改失败", unmodified: "未修改" } } } };
   }
 });
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  MahjongPub: () => MahjongPub,
-  default: () => src_default
+var index_exports = {};
+__export(index_exports, {
+  MahjongPub: () => MahjongPub2,
+  default: () => index_default
 });
-module.exports = __toCommonJS(src_exports);
-var import_koishi = require("koishi");
+module.exports = __toCommonJS(index_exports);
+var import_koishi3 = require("koishi");
 
 // src/api.ts
 var TeamAdmin = class {
@@ -79,7 +79,7 @@ var TeamAdmin = class {
       posttype: "update",
       t_pw: this.pw,
       t_ps: this.description,
-      cid: this.cid,
+      cid: String(this.cid),
       linkurl: this.img,
       team_type: this.ready ? "1" : "0",
       postdata: this.players.join("\n")
@@ -103,13 +103,14 @@ var ContestAdmin = class {
   }
   name;
   teams;
+  round;
   http;
   raw;
   async read(force = false) {
     if (this.teams && !force) return;
     const payload = {
       posttype: "login",
-      cid: this.cid,
+      cid: String(this.cid),
       c_pw: this.pw
     };
     const form = new FormData();
@@ -120,6 +121,7 @@ var ContestAdmin = class {
     if (!data?.c_admin?.cid) throw new Error("failed to read contest info");
     this.raw = data;
     this.name = data.c_admin.c_name;
+    this.round = data.c_admin.c_round;
     this.teams = Object.fromEntries(data.c_team.map((team) => [team.tid, {
       tid: team.tid,
       cid: this.cid,
@@ -129,10 +131,58 @@ var ContestAdmin = class {
       pw: team.t_pw
     }]));
   }
+  async getRounds() {
+    const data = await this.http.get("/api/data.php", {
+      params: {
+        t: "class",
+        cid: this.cid
+      }
+    });
+    const res = {};
+    data.forEach((round) => {
+      (res[round.round] ??= {})[round.t_class] = {
+        rid: round.rid,
+        round: round.round,
+        cls: round.t_class,
+        code: round.code,
+        tids: [round.tid1, round.tid2, round.tid3, round.tid4].filter(Boolean)
+      };
+    });
+    return res;
+  }
+  async getRecords(round) {
+    const data = await this.http.get("/api/data.php", {
+      params: {
+        t: "c_data",
+        cid: this.cid,
+        r: round
+      }
+    });
+    const res = {};
+    Object.entries(data).forEach(([rid, rs]) => {
+      if (!rs.length) return;
+      res[rid] = rs.map((x) => ({
+        inx: x.inx,
+        cid: x.cid,
+        rowi: x.rowi,
+        players: [
+          { name: x.name1, num: x.num1, point: x.pint1 },
+          { name: x.name2, num: x.num2, point: x.pint2 },
+          { name: x.name3, num: x.num3, point: x.pint3 },
+          { name: x.name4, num: x.num4, point: x.pint4 }
+        ],
+        url: x.url,
+        rid: x.rid,
+        round: x.round,
+        time: x.i_time
+      }));
+    });
+    return res;
+  }
   async getRoundRecord(round, cls) {
     const payload = {
       type: "login",
-      cid: this.cid,
+      cid: String(this.cid),
       cls: String(cls),
       rnd: String(round)
     };
@@ -166,7 +216,7 @@ var ContestAdmin = class {
   async updateRoundRecord(record) {
     const payload = {
       type: "update",
-      cid: this.cid,
+      cid: String(this.cid),
       cls: String(record.cls),
       rnd: String(record.rnd),
       pw: this.pw
@@ -189,6 +239,222 @@ var ContestAdmin = class {
   }
 };
 
+// src/manager.ts
+var import_koishi2 = require("koishi");
+var import_lobby = require("@hieuzest/koishi-plugin-riichi-city/lobby");
+
+// src/mahjongpub.ts
+var import_koishi = require("koishi");
+var import_cachetools = require("@hieuzest/cachetools");
+var MahjongPub = class _MahjongPub {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.http = ctx.http.extend({});
+  }
+  static {
+    __name(this, "MahjongPub");
+  }
+  serverUri = "https://cdn.r-mj.com";
+  http;
+  async getContest(cid) {
+    return await this.http.get(`${this.serverUri}/api/data.php`, {
+      params: {
+        t: "admin",
+        cid
+      }
+    });
+  }
+  async getTeams(cid) {
+    return this.http.get(`${this.serverUri}/api/data.php`, {
+      params: {
+        t: "team",
+        cid
+      }
+    }).then((teams) => (0, import_koishi.mapValues)(teams, (team) => ({
+      ...team,
+      players: [...team.t_player?.split(/\s+/) ?? [], ...team.t_sub?.split(/\s+/) ?? []]
+    })));
+  }
+  async getRounds(cid) {
+    return Object.fromEntries(await this.http.get(`${this.serverUri}/api/data.php`, {
+      params: {
+        t: "class",
+        cid
+      }
+    }).then((rounds) => rounds.map((round) => [round.rid, {
+      ...round,
+      tids: [round.tid1, round.tid2, round.tid3, round.tid4]
+    }])));
+  }
+  async getMatches(cid, round) {
+    return await this.http.get(`${this.serverUri}/api/data.php`, {
+      params: {
+        t: "c_data",
+        cid,
+        r: round
+      }
+    });
+  }
+  async getAllMatches(cid) {
+    const contest = await this.getContest(cid);
+    return await this.http.get(`${this.serverUri}/api/data.php`, {
+      params: {
+        t: "multi_log",
+        cid,
+        r: [...Array(contest.c_round).keys()].map((x) => x + 1).map((x) => x.toString()).join(",")
+      }
+    });
+  }
+  static cacheOptions = {
+    "getContest": {
+      maxAge: 120
+    },
+    "getRounds": {
+      maxAge: 60
+    },
+    "getTeams": {
+      maxAge: 30
+    },
+    "getMatches": {
+      maxAge: 120
+    },
+    "getAllMatches": {
+      maxAge: 300
+    }
+  };
+  static new(ctx) {
+    return (0, import_cachetools.ttlcachedClass)(new _MahjongPub(ctx), _MahjongPub.cacheOptions);
+  }
+};
+
+// src/manager.ts
+var ContestExtra = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.stopCls = /* @__PURE__ */ new Set();
+  }
+  static {
+    __name(this, "ContestExtra");
+  }
+  subscribers;
+  stopCls;
+  async broadcast(msg) {
+    this.subscribers.forEach((channel) => this.ctx.sendMessage(channel, msg).catch(import_koishi2.noop));
+  }
+};
+var ContestManager = class {
+  constructor(ctx, config) {
+    this.ctx = ctx;
+    this.config = config;
+    this.mahjongpub = MahjongPub.new(ctx);
+    ctx.command("contest.manager", { authority: 3 }).action(import_koishi2.noop);
+    ctx.command("contest.manager.init").channelFields(["mahjongpub/bind-contest"]).option("clear", "-c").action(async ({ session, options }) => {
+      const cid = +(session.channel["mahjongpub/bind-contest"] || 0);
+      if (!cid) return "Unauthorized.";
+      this.extra[cid] ??= new ContestExtra(ctx);
+      this.extra[cid].subscribers.add(session.cid);
+      if (options.clear) this.extra[cid].stopCls.clear();
+      return "Finished.";
+    });
+    ctx.command("contest.manager.start [cls:number]").channelFields(["mahjongpub/bind-contest"]).action(async ({ session }, cls) => {
+      const cid = +(session.channel["mahjongpub/bind-contest"] || 0);
+      if (!cid) return "Unauthorized.";
+      this.extra[cid] ??= new ContestExtra(ctx);
+      this.extra[cid].subscribers.add(session.cid);
+      if (cls) {
+        this.extra[cid].stopCls.delete(cls);
+        await this.startMatch(cid, cls);
+      } else {
+        this.extra[cid].stopCls.clear();
+        const contest = await this.mahjongpub.getContest(cid);
+        const rounds = await this.mahjongpub.getRounds(cid);
+        for (const r of Object.values(rounds)) {
+          if (r.round !== contest.c_round) continue;
+          await this.startMatch(cid, r.t_class);
+          await (0, import_koishi2.sleep)(1e3);
+        }
+      }
+    });
+    ctx.command("contest.manager.stop [cls:number]").channelFields(["mahjongpub/bind-contest"]).action(async ({ session }, cls) => {
+      const cid = +(session.channel["mahjongpub/bind-contest"] || 0);
+      if (!cid) return "Unauthorized/";
+      this.extra[cid] ??= new ContestExtra(ctx);
+      if (cls) {
+        this.extra[cid].stopCls.add(cls);
+      } else {
+        const contest = await this.mahjongpub.getContest(cid);
+        const rounds = await this.mahjongpub.getRounds(cid);
+        for (const r of Object.values(rounds)) {
+          if (r.round !== contest.c_round) continue;
+          this.extra[cid].stopCls.add(r.t_class);
+        }
+      }
+      return "Finished.";
+    });
+    ctx.server.post("/contest-manager/finished", async (kCtx) => {
+      if (config.token && kCtx.request.headers.authorization !== `Bearer ${config.token}`) {
+        kCtx.status = 403;
+        return true;
+      }
+      this.onMatchFinished(kCtx.request.body);
+      kCtx.status = 200;
+      return true;
+    });
+  }
+  static {
+    __name(this, "ContestManager");
+  }
+  static inject = ["server", "mahjong", "mahjong.database", "mahjongpub", "sendMessage"];
+  mahjongpub;
+  extra = /* @__PURE__ */ Object.create(null);
+  async startMatch(cid, cls, timeout, tag) {
+    tag ||= `${cls}组`;
+    if (this.extra[cid]?.stopCls.has(cls)) {
+      this.ctx.logger.info(`try starting match ${cid}-${cls}, but stopped`);
+      return;
+    }
+    this.ctx.logger.info(`try starting match ${cid}-${cls}, timeout ${timeout}`);
+    const contest = await this.mahjongpub.getContest(cid);
+    const rounds = await this.mahjongpub.getRounds(cid);
+    const teams = await this.mahjongpub.getTeams(cid);
+    const [lastRecord] = await this.ctx.mahjong.database.db("scoreboard").collection("matches").find({
+      cid: `${cid}`,
+      round: +contest.c_round,
+      cls
+    }).sort({ rowi: -1 }).limit(1).toArray();
+    if (lastRecord && !lastRecord._finished) {
+      this.extra[cid]?.broadcast(`[${tag}] 发现进行中的比赛，已忽略`);
+      return;
+    }
+    const rowi = lastRecord ? lastRecord.rowi + 1 : 0;
+    const round = Object.values(rounds).find((x) => x.round === contest.c_round && x.t_class === cls);
+    const players = round.tids.map((tid) => teams[tid].players[rowi]);
+    try {
+      await this.ctx["zx-dhs"].startMatch(+round.code, players.map((x, i) => import_lobby.Player.fromPattern(x, lastRecord ? lastRecord.results?.[i].num : 1e5)));
+      this.extra[cid]?.broadcast(`[${tag}] 成功：` + players.join("，"));
+    } catch (e) {
+      if (e instanceof import_lobby.PlayerNotFoundError) {
+        this.extra[cid]?.broadcast(`[${tag}] ` + e.message + ` <timeout=${timeout}>`);
+        if (timeout < 600) this.ctx.setTimeout(() => this.startMatch(cid, cls, timeout + 30), 30 * 1e3);
+      } else {
+        throw e;
+      }
+    }
+  }
+  async onMatchFinished(record) {
+    this.extra[record.cid]?.broadcast(`对局完成：
+` + record.results.map((x) => `${x.name} ${x.num}`).join("\n"));
+    await (0, import_koishi2.sleep)(2e3);
+    return this.startMatch(+record.cid, record.cls);
+  }
+};
+((ContestManager2) => {
+  ContestManager2.Config = import_koishi2.Schema.object({
+    token: import_koishi2.Schema.string()
+  });
+})(ContestManager || (ContestManager = {}));
+
 // src/index.ts
 function parsePlatform(target) {
   const index = target.startsWith("sandbox:") ? target.lastIndexOf(":") : target.indexOf(":");
@@ -197,10 +463,12 @@ function parsePlatform(target) {
   return [platform, id];
 }
 __name(parsePlatform, "parsePlatform");
-var MahjongPub = class {
+var MahjongPub2 = class extends import_koishi3.Service {
   constructor(ctx, config) {
+    super(ctx, "mahjongpub", true);
     this.ctx = ctx;
     this.config = config;
+    ctx.plugin(ContestManager);
     ctx.i18n.define("zh-CN", require_zh_CN());
     ctx.model.extend("user", {
       "mahjongpub/bind-team": "string",
@@ -277,7 +545,7 @@ var MahjongPub = class {
       const team = await this.getTeam(pw);
       try {
         await team.read();
-        if (!img) return import_koishi.h.image(team.img);
+        if (!img) return import_koishi3.h.image(team.img);
         const url = await ctx.assets.upload("https://koishi.chat/logo.png", `${session.id}-${session.timestamp}.png`);
         team.img = url;
         return await team.write();
@@ -376,7 +644,17 @@ var MahjongPub = class {
         return session.text(".failed");
       }
     });
-    ctx.command("mahjongpub.contest.bind <cid:string> <cpw:string>", { authority: 4 }).option("channel", "-c <channel:channel>").channelFields(["mahjongpub/bind-contest", "mahjongpub/bind-contestpw"]).action(async ({ session, options }, cid, cpw) => {
+    ctx.command("mahjongpub.contest.bind <cid:string> [cpw:string]", { authority: 4 }).option("channel", "-c <channel:channel>").option("only", "-o").channelFields(["mahjongpub/bind-contest", "mahjongpub/bind-contestpw"]).action(async ({ session, options }, cid, cpw) => {
+      if (options.only) {
+        if (options.channel) {
+          ctx.database.setChannel(...parsePlatform(options.channel), {
+            "mahjongpub/bind-contest": cid
+          });
+        } else {
+          session.channel["mahjongpub/bind-contest"] = cid;
+        }
+        return "Finished.";
+      }
       const contest = await this.getContest(cid, cpw);
       try {
         await contest.read();
@@ -395,12 +673,32 @@ var MahjongPub = class {
       }
       return session.text(".success", contest);
     });
+    ctx.command("mahjongpub.contest.password", { authority: 4 }).option("channel", "-c <channel:channel>").channelFields(["mahjongpub/bind-contest", "mahjongpub/bind-contestpw"]).action(async ({ session }) => {
+      const [cid, cpw] = [session.channel["mahjongpub/bind-contest"], session.channel["mahjongpub/bind-contestpw"]];
+      if (cid) return session.text(".success", [cid, cpw]);
+      else return session.text(".failed");
+    });
+    ctx.command("mahjongpub.contest.round [round:natural]", { authority: 3 }).channelFields(["mahjongpub/bind-contest", "mahjongpub/bind-contestpw"]).action(async ({ session }, round) => {
+      const [cid, cpw] = [session.channel["mahjongpub/bind-contest"], session.channel["mahjongpub/bind-contestpw"]];
+      const contest = await this.getContest(cid, cpw);
+      try {
+        const rounds = await contest.getRounds();
+        const clss = rounds[round || contest.round];
+        return Object.entries(clss).map(([i, r]) => [
+          `[${i}]`,
+          r.tids.map((tid) => `${contest.teams[tid].name}`).join(" / ")
+        ].join(" ")).join("\n");
+      } catch (e) {
+        ctx.logger.warn(e);
+        return session.text(".failed");
+      }
+    });
     ctx.command("mahjongpub.contest.record.get <round:natural> <cls:natural>", { authority: 3 }).option("rowi", "-i <rowi:integer>").channelFields(["mahjongpub/bind-contest", "mahjongpub/bind-contestpw"]).action(async ({ session, options }, round, cls) => {
       const [cid, cpw] = [session.channel["mahjongpub/bind-contest"], session.channel["mahjongpub/bind-contestpw"]];
       const contest = await this.getContest(cid, cpw);
       try {
         const record = await contest.getRoundRecord(round, cls);
-        if ((0, import_koishi.isNullable)(options.rowi)) {
+        if ((0, import_koishi3.isNullable)(options.rowi)) {
           return record.matches.map((match, i) => `[${i}] ` + match.players.map((x) => `${x.name} ${x.point}`).join(" / ")).join("\n");
         } else if (record.matches.at(options.rowi ?? -1)) {
           return [
@@ -523,29 +821,29 @@ var MahjongPub = class {
     if (this.ctx.get("cache")) {
       let res2 = await this.ctx.cache.get("contests", cid);
       if (res2) return res2;
-      res2 = new ContestAdmin(this.ctx, cid, pw, this.config);
+      res2 = new ContestAdmin(this.ctx, +cid, pw, this.config);
       await res2.read();
       await this.ctx.cache.set("contests", cid, res2, 1e3 * 600);
       return res2;
     }
-    const res = new ContestAdmin(this.ctx, cid, pw, this.config);
+    const res = new ContestAdmin(this.ctx, +cid, pw, this.config);
     await res.read();
     return res;
   }
 };
-((MahjongPub2) => {
-  MahjongPub2.inject = {
+((MahjongPub3) => {
+  MahjongPub3.inject = {
     required: ["database"],
     optional: ["assets", "cache", "mahjong", "mahjong.database"]
   };
-  MahjongPub2.Config = import_koishi.Schema.object({
-    informNotbind: import_koishi.Schema.boolean().default(false),
-    endpoint: import_koishi.Schema.string().default("https://cdn.r-mj.com/"),
-    batchInterval: import_koishi.Schema.natural().default(300),
-    batchCount: import_koishi.Schema.natural().default(10)
+  MahjongPub3.Config = import_koishi3.Schema.object({
+    informNotbind: import_koishi3.Schema.boolean().default(false),
+    endpoint: import_koishi3.Schema.string().default("https://cdn.r-mj.com/"),
+    batchInterval: import_koishi3.Schema.natural().default(300),
+    batchCount: import_koishi3.Schema.natural().default(10)
   });
-})(MahjongPub || (MahjongPub = {}));
-var src_default = MahjongPub;
+})(MahjongPub2 || (MahjongPub2 = {}));
+var index_default = MahjongPub2;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MahjongPub

package/lib/mahjongpub.d.ts

@@ -0,0 +1,87 @@
+import { Context, Dict } from 'koishi';
+export declare class MahjongPub {
+    ctx: Context;
+    private serverUri;
+    private http;
+    constructor(ctx: Context);
+    getContest(cid: number): Promise<MahjongPub.Contest>;
+    getTeams(cid: number): Promise<Dict<MahjongPub.Team>>;
+    getRounds(cid: number): Promise<Dict<MahjongPub.Round>>;
+    getMatches(cid: number, round: number): Promise<Dict<MahjongPub.Match[]>>;
+    getAllMatches(cid: number): Promise<Dict<MahjongPub.Match[]>>;
+    static cacheOptions: {
+        readonly getContest: {
+            readonly maxAge: 120;
+        };
+        readonly getRounds: {
+            readonly maxAge: 60;
+        };
+        readonly getTeams: {
+            readonly maxAge: 30;
+        };
+        readonly getMatches: {
+            readonly maxAge: 120;
+        };
+        readonly getAllMatches: {
+            readonly maxAge: 300;
+        };
+    };
+    static new(ctx: Context): import("@hieuzest/cachetools").CachedClass<MahjongPub, "getContest" | "getRounds" | "getTeams" | "getMatches" | "getAllMatches", "_">;
+}
+export declare namespace MahjongPub {
+    export interface Team {
+        tid: number;
+        cid: string;
+        t_name: string;
+        t_ps: string;
+        t_player?: string;
+        t_sub?: string;
+        img: string;
+        t_type: number;
+        players: string[];
+    }
+    export interface Contest {
+        cid: number;
+        c_name: string;
+        c_round: number;
+        c_gonggao: string;
+        c_pad: string;
+        t_type: string;
+    }
+    export interface Round {
+        rid: number;
+        round: number;
+        t_class: number;
+        code: string;
+        tid1: number;
+        tid2: number;
+        tid3: number;
+        tid4: number;
+        tids: number[];
+    }
+    export interface MatchBrief {
+        inx: number;
+        cid: number;
+        rid: number;
+        round: number;
+        rowi: number;
+        i_time: string;
+        url: string;
+    }
+    type Stringiable = string | number;
+    type Suffixed<K, P extends Stringiable> = K extends string ? `${K}${P}` : never;
+    type SuffixRemoved<PK, P extends Stringiable> = PK extends Suffixed<infer K, P> ? K : '';
+    type SuffixedValue<T extends object, PK extends string, P extends Stringiable> = T extends {
+        [K in SuffixRemoved<PK, P>]: infer TValue;
+    } ? TValue : never;
+    type SuffixedObject<T extends object, P extends Stringiable> = {
+        [K in Suffixed<keyof T, P>]: SuffixedValue<T, K, P>;
+    };
+    interface MatchPlayerTemplate {
+        name: string;
+        num: number;
+    }
+    type MatchPlayer<P extends Stringiable> = SuffixedObject<MatchPlayerTemplate, P>;
+    export type Match = MatchBrief & MatchPlayer<1> & MatchPlayer<2> & MatchPlayer<3> & MatchPlayer<4>;
+    export {};
+}

package/lib/manager.d.ts

@@ -0,0 +1,47 @@
+import { Context, Dict, Schema } from 'koishi';
+import { MahjongPub } from './mahjongpub';
+interface PlayerResult {
+    name: string;
+    num: number;
+    pint: number;
+}
+interface MatchRecord {
+    _id: string;
+    inx?: string;
+    cid: string;
+    rid: string;
+    round: number;
+    rowi: number;
+    time?: string;
+    url?: string;
+    cls: number;
+    tids: number[];
+    players: string[];
+    ver?: number;
+    _finished?: boolean;
+    results?: PlayerResult[];
+}
+declare class ContestExtra {
+    ctx: Context;
+    subscribers: Set<string>;
+    stopCls: Set<number>;
+    constructor(ctx: Context);
+    broadcast(msg: string): Promise<void>;
+}
+export declare class ContestManager {
+    protected ctx: Context;
+    config: ContestManager.Config;
+    static inject: string[];
+    mahjongpub: MahjongPub;
+    extra: Dict<ContestExtra>;
+    constructor(ctx: Context, config: ContestManager.Config);
+    startMatch(cid: number, cls: number, timeout?: number, tag?: string): Promise<void>;
+    onMatchFinished(record: MatchRecord): Promise<void>;
+}
+export declare namespace ContestManager {
+    interface Config {
+        token?: string;
+    }
+    const Config: Schema<Config>;
+}
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hieuzest/koishi-plugin-mahjongpub",
   "description": "Mahjong.pub API",
-  "version": "0.1.22",
+  "version": "0.2.1",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -15,6 +15,10 @@
     "plugin"
   ],
   "peerDependencies": {
-    "koishi": "^4.17.1"
+    "koishi": "^4.17.1",
+    "@hieuzest/koishi-plugin-riichi-city": "^0.5.2"
+  },
+  "dependencies": {
+    "@hieuzest/cachetools": "^0.1.5"
   }
 }