@hieuzest/koishi-plugin-mahjongpub 0.2.12 → 0.2.14

package/lib/index.d.ts

@@ -1,6 +1,7 @@
 import { Context, Dict, Schema, Service } from 'koishi';
 import { ContestAdmin, TeamAdmin } from './api';
 import { ContestManager } from './manager';
+import { MahjongPub as Contest } from './mahjongpub';
 declare module 'koishi' {
     interface Context {
         mahjongpub: MahjongPub;
@@ -26,6 +27,7 @@ export declare class MahjongPub extends Service {
     config: MahjongPub.Config;
     teams: Dict<TeamAdmin>;
     contests: Dict<ContestAdmin>;
+    contest: Contest;
     constructor(ctx: Context, config: MahjongPub.Config);
     getTeam(pw: string): Promise<TeamAdmin>;
     getContest(cid: string, pw: string): Promise<ContestAdmin>;

package/lib/index.js

@@ -336,6 +336,105 @@ var MahjongPub = class _MahjongPub {
   }
 };
 
+// src/lark.tsx
+var import_jsx_runtime = require("@satorijs/element/jsx-runtime");
+var LarkExtension = class {
+  constructor(ctx, manager) {
+    this.ctx = ctx;
+    this.manager = manager;
+    ctx.command("mahjongpub.manager.manage").channelFields(["mahjongpub/bind-contest"]).action(async ({ session }) => {
+      const cid = +(session.channel["mahjongpub/bind-contest"] || 0);
+      if (!cid) return "Unauthorized.";
+      const cextra = this.manager.extra[cid] ??= new ContestExtra(ctx);
+      const contest = await this.manager.mahjongpub.getContest(cid);
+      const rounds = await this.manager.mahjongpub.getRounds(cid);
+      const classes = [];
+      for (const r of Object.values(rounds)) {
+        if (r.round !== (cextra.round ?? contest.c_round)) continue;
+        classes.push([r.t_class, await this.manager.getClsStatus(cid, r.t_class)]);
+      }
+      this.ctx.logger.info("Contest management statuses:", classes);
+      const stringifyStatus = /* @__PURE__ */ __name((status) => {
+        switch (status.status) {
+          case "pending":
+            return `<text_tag color='gray'>等待中</text_tag>`;
+          case "running":
+            return `<text_tag color='green'>进行中</text_tag>`;
+          case "finished":
+            return `<text_tag color='blue'>已结束</text_tag>`;
+          case "suspended":
+            return `<text_tag color='orange'>已停止</text_tag>`;
+          case "error":
+            return `<text_tag color='red'>错误</text_tag>`;
+        }
+      }, "stringifyStatus");
+      const renderCls = /* @__PURE__ */ __name((cls, status) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("lark:column-set", { backgroundStyle: "blue-50", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("lark:column", { weight: 3, width: "weighted", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [
+            " 组",
+            cls + 1,
+            "-",
+            status.rowi,
+            " ",
+            stringifyStatus(status)
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("lark:column-set", { children: Array(4).fill(0).map((_, i) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("lark:column", { weight: 1, width: "weighted", backgroundStyle: "bg-white", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { align: "center", children: [
+              " ",
+              status.next?.[i]?.player ?? status.last?.[i]?.player,
+              " "
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { align: "center", children: [
+              " ",
+              status.next?.[i]?.point ?? status.last?.[i]?.point,
+              " "
+            ] })
+          ] })) })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("lark:column", { weight: 1, width: "weighted", children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("lark:column-set", { children: [
+          status.status === "pending" || status.status === "suspended" ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("lark:column", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "submit", text: `mahjongpub.manager.callback -a 1 -c ${cls}`, children: "开赛" }) }) : null,
+          status.status === "pending" || status.status === "running" ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("lark:column", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "submit", text: `mahjongpub.manager.callback -a 2 -c ${cls}`, children: "停止" }) }) : null
+        ] }) })
+      ] }), "renderCls");
+      const msg = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("lark:card", { width: "fill", title: "比赛管理", color: "blue", children: [
+        classes.map(([i, status]) => renderCls(i, status)),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("lark:column-set", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("lark:column", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "submit", text: `mahjongpub.manager.callback -a 1 -A`, children: "全部开赛" }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("lark:column", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "submit", text: `mahjongpub.manager.callback -a 2 -A`, children: "全部停止" }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("lark:column", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "submit", text: `mahjongpub.manager.manage`, children: "刷新" }) })
+        ] })
+      ] }) });
+      if (session.type === "interaction/command") {
+        await session.bot.editMessage(session.channelId, session.referrer.event.context.open_message_id, msg);
+      } else {
+        await session.send(msg);
+      }
+    });
+    ctx.command("mahjongpub.manager.callback").option("action", "-a <action:number>").option("cls", "-c <cls:number>").option("all", "-A").action(async ({ session, options }) => {
+      this.ctx.logger.info("Contest management callback:", session.userId, options);
+      switch (options.action) {
+        case 1:
+          await session.execute({
+            name: `mahjongpub.manager.start`,
+            args: options.all ? [] : [options.cls]
+          });
+          return `Callback executed: start class ${options.all ? "all" : options.cls}.`;
+        case 2:
+          await session.execute({
+            name: `mahjongpub.manager.stop`,
+            args: options.all ? [] : [options.cls]
+          });
+          return `Callback executed: stop class ${options.all ? "all" : options.cls}.`;
+        default:
+          return "Unknown action.";
+      }
+    });
+  }
+  static {
+    __name(this, "LarkExtension");
+  }
+};
+
 // src/manager.ts
 var ContestExtra = class {
   constructor(ctx) {
@@ -351,25 +450,29 @@ var ContestExtra = class {
   type;
   round;
   lobby;
+  playerIndex;
   ver = 0;
+  maxRow;
   async broadcast(msg) {
     this.subscribers.forEach((channel) => this.ctx.sendMessage(channel, msg).catch((e) => this.ctx.logger.debug(e)));
   }
 };
-function getRowPlayer(contest, team, rowi) {
-  const roleList = contest.t_type.split(/\s+/);
-  const roleSet = [...new Set(roleList).values()];
-  const index = roleSet.indexOf(roleList[rowi]);
+function getRowPlayer(contest, team, rowi, index) {
+  if ((0, import_koishi2.isNullable)(index)) {
+    const roleList = contest.t_type.split(/\s+/);
+    const roleSet = [...new Set(roleList).values()];
+    index = roleSet.indexOf(roleList[rowi]);
+  }
   return team.players[index]?.split("##", 1)[0];
 }
 __name(getRowPlayer, "getRowPlayer");
-var ContestManager = class {
+var ContestManager2 = class {
   constructor(ctx, config) {
     this.ctx = ctx;
     this.config = config;
     this.mahjongpub = MahjongPub.new(ctx);
     ctx.command("mahjongpub.manager", { authority: 3 }).action(import_koishi2.noop);
-    ctx.command("mahjongpub.manager.init").channelFields(["mahjongpub/bind-contest"]).option("clear", "-c").option("type", "-t [type:string]").option("ver", "-v [ver:number]").option("round", "-r [round:number]").option("lobby", "-l [lobby:string]").action(async ({ session, options }) => {
+    ctx.command("mahjongpub.manager.init").channelFields(["mahjongpub/bind-contest"]).option("clear", "-c").option("type", "-t [type:string]").option("ver", "-v [ver:number]").option("round", "-r [round:number]").option("lobby", "-l [lobby:string]").option("index", "-i [index:number]").option("maxRow", "-m [maxRow:number]").action(async ({ session, options }) => {
       const cid = +(session.channel["mahjongpub/bind-contest"] || 0);
       if (!cid) return "Unauthorized.";
       this.extra[cid] ??= new ContestExtra(ctx);
@@ -379,6 +482,8 @@ var ContestManager = class {
       if (!(0, import_koishi2.isNullable)(options.ver)) this.extra[cid].ver = options.ver;
       if (!(0, import_koishi2.isNullable)(options.round)) this.extra[cid].round = options.round;
       if (!(0, import_koishi2.isNullable)(options.lobby)) this.extra[cid].lobby = options.lobby;
+      if (!(0, import_koishi2.isNullable)(options.index)) this.extra[cid].playerIndex = options.index;
+      if (!(0, import_koishi2.isNullable)(options.maxRow)) this.extra[cid].maxRow = options.maxRow;
       return "Finished.";
     });
     ctx.command("mahjongpub.manager.deinit").channelFields(["mahjongpub/bind-contest"]).option("clear", "-c").action(async ({ session, options }) => {
@@ -436,6 +541,7 @@ var ContestManager = class {
       kCtx.status = 200;
       return true;
     });
+    ctx.plugin(LarkExtension, this);
   }
   static {
     __name(this, "ContestManager");
@@ -443,6 +549,101 @@ var ContestManager = class {
   static inject = ["server", "mahjong", "mahjong.database", "mahjongpub", "sendMessage", "zx-dhs", "majsoul-dhs"];
   mahjongpub;
   extra = /* @__PURE__ */ Object.create(null);
+  async getClsStatus(cid, cls) {
+    const cextra = this.extra[cid];
+    if (!cextra) {
+      return {
+        status: "error",
+        rowi: -1,
+        msg: "比赛未初始化"
+      };
+    }
+    const contest = await this.mahjongpub.getContest(cid);
+    const rounds = await this.mahjongpub.getRounds(cid);
+    const teams = await this.mahjongpub.getTeams(cid);
+    const [lastRecord, secondRecord] = await this.ctx.mahjong.database.db("scoreboard").collection("matches").find({
+      cid: `${cid}`,
+      round: cextra.round ?? +contest.c_round,
+      cls,
+      ver: cextra.ver
+    }).sort({ rowi: -1 }).limit(2).toArray();
+    if (lastRecord && !lastRecord._finished) {
+      return {
+        status: "running",
+        rowi: lastRecord.rowi,
+        last: secondRecord?.results.map((x) => ({
+          player: x.name,
+          point: x.num
+        })) || lastRecord.players.map((x) => ({
+          player: x,
+          point: 0
+        }))
+      };
+    }
+    if (cextra.type === "ti" && lastRecord && lastRecord.results?.some((x) => x.num < 0) && !this.config.allowNegativeScore) {
+      return {
+        status: "finished",
+        rowi: lastRecord.rowi,
+        last: lastRecord.results.map((x) => ({
+          player: x.name,
+          point: x.num
+        }))
+      };
+    }
+    const rowi = lastRecord ? lastRecord.rowi + 1 : 0;
+    if (rowi >= (cextra.maxRow ?? contest.t_type.split(/\s+/).filter((x) => x).length)) {
+      return {
+        status: "finished",
+        rowi: lastRecord.rowi,
+        last: lastRecord.results.map((x) => ({
+          player: x.name,
+          point: x.num
+        }))
+      };
+    }
+    const round = Object.values(rounds).find((x) => x.round === (cextra.round ?? contest.c_round) && x.t_class === cls);
+    const players = round.tids.map((tid) => getRowPlayer(contest, teams[tid], rowi, cextra.playerIndex));
+    if (!players.every((x) => x)) {
+      return {
+        status: "error",
+        rowi,
+        msg: "名单未填写"
+      };
+    }
+    try {
+      if (cextra.type === "ti") {
+        return {
+          status: cextra.stopCls.has(cls) ? "suspended" : "pending",
+          rowi,
+          next: players.map((x, i) => ({
+            player: x,
+            point: lastRecord ? lastRecord.results?.[i].num : 1e5
+          }))
+        };
+      } else if (cextra.type === "ssb") {
+        return {
+          status: cextra.stopCls.has(cls) ? "suspended" : "pending",
+          rowi,
+          next: players.map((x) => ({
+            player: x,
+            point: 25e3
+          }))
+        };
+      } else {
+        return {
+          status: "error",
+          rowi,
+          msg: `未知的比赛类型：${cextra.type}`
+        };
+      }
+    } catch (e) {
+      return {
+        status: "error",
+        rowi,
+        msg: `未知错误：${e}`
+      };
+    }
+  }
   async _startMatch(cid, cls, timeout = 0, force = false) {
     const cextra = this.extra[cid];
     const tag = `${cls}组`;
@@ -473,12 +674,12 @@ var ContestManager = class {
       return;
     }
     const rowi = lastRecord ? lastRecord.rowi + 1 : 0;
-    if (rowi >= contest.t_type.split(/\s+/).filter((x) => x).length) {
+    if (rowi >= (cextra.maxRow ?? contest.t_type.split(/\s+/).filter((x) => x).length)) {
       cextra.broadcast(`[${tag}] 已经全部完成`);
       return;
     }
     const round = Object.values(rounds).find((x) => x.round === (cextra.round ?? contest.c_round) && x.t_class === cls);
-    const players = round.tids.map((tid) => getRowPlayer(contest, teams[tid], rowi));
+    const players = round.tids.map((tid) => getRowPlayer(contest, teams[tid], rowi, cextra.playerIndex));
     if (!players.every((x) => x)) {
       cextra.broadcast(`[${tag}] 失败： 名单未填写`);
       return;
@@ -537,8 +738,8 @@ var ContestManager = class {
     return this.startMatch(+record.cid, record.cls);
   }
 };
-((ContestManager2) => {
-  ContestManager2.Config = import_koishi2.Schema.object({
+((ContestManager3) => {
+  ContestManager3.Config = import_koishi2.Schema.object({
     token: import_koishi2.Schema.string(),
     startInterval: import_koishi2.Schema.number().default(import_koishi2.Time.second).description("比赛开始间隔"),
     startTimeoutInterval: import_koishi2.Schema.number().default(import_koishi2.Time.second * 30).description("比赛开始重试间隔"),
@@ -546,7 +747,7 @@ var ContestManager = class {
     finishInterval: import_koishi2.Schema.number().default(import_koishi2.Time.second * 10).description("比赛结束间隔"),
     allowNegativeScore: import_koishi2.Schema.boolean().default(false).description("允许负分")
   });
-})(ContestManager || (ContestManager = {}));
+})(ContestManager2 || (ContestManager2 = {}));
 
 // src/index.ts
 function parsePlatform(target) {
@@ -561,8 +762,9 @@ var MahjongPub2 = class extends import_koishi3.Service {
     super(ctx, "mahjongpub", true);
     this.ctx = ctx;
     this.config = config;
-    ctx.plugin(ContestManager, config.manager);
+    ctx.plugin(ContestManager2, config.manager);
     ctx.i18n.define("zh-CN", require_zh_CN());
+    this.contest = MahjongPub.new(ctx);
     ctx.model.extend("user", {
       "mahjongpub/bind-team": "string",
       "mahjongpub/bind-teams": "json"
@@ -826,6 +1028,7 @@ var MahjongPub2 = class extends import_koishi3.Service {
       ctx.command("mahjongpub.database.record.last <round:natural>", { authority: 3 }).option("rowi", "-i <rowi:integer>", { fallback: -1 }).option("ver", "-v <ver:integer>", { fallback: 0 }).channelFields(["mahjongpub/bind-contest"]).action(async ({ session, options }, round, cls) => {
         const [cid] = [session.channel["mahjongpub/bind-contest"]];
         try {
+          const cteams = await this.contest.getTeams(+cid);
           const record = await ctx.mahjong.database.db("scoreboard").collection("matches").find({
             cid,
             round,
@@ -841,7 +1044,7 @@ var MahjongPub2 = class extends import_koishi3.Service {
               seenCls.add(r.cls);
             }
           });
-          return filtered.map((r) => `[${r.cls}组] ` + r.results.map((x) => `${x.name} ${x.num}`).join(" / ")).join("\n");
+          return filtered.map((r) => `[${r.cls}-${r.rowi + 1}] ` + r.results.map((x, i) => `${cteams[r.tids[i]].t_name} ${x.num}`).join(" / ")).join("\n");
         } catch (e) {
           ctx.logger.warn(e);
           return session.text(".failed");
@@ -931,6 +1134,7 @@ var MahjongPub2 = class extends import_koishi3.Service {
   }
   teams = {};
   contests = {};
+  contest;
   async getTeam(pw) {
     return new TeamAdmin(this.ctx, pw, this.config);
   }
@@ -958,7 +1162,7 @@ var MahjongPub2 = class extends import_koishi3.Service {
     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),
-    manager: ContestManager.Config
+    manager: ContestManager2.Config
   });
 })(MahjongPub2 || (MahjongPub2 = {}));
 var index_default = MahjongPub2;

package/lib/lark.d.ts

@@ -0,0 +1,7 @@
+import { Context } from 'koishi';
+import { ContestManager } from './manager';
+export declare class LarkExtension {
+    protected ctx: Context;
+    protected manager: ContestManager;
+    constructor(ctx: Context, manager: ContestManager);
+}

package/lib/manager.d.ts

@@ -21,14 +21,29 @@ interface MatchRecord {
     _finished?: boolean;
     results?: PlayerResult[];
 }
-declare class ContestExtra {
+export interface ClsStatus {
+    status: 'pending' | 'running' | 'finished' | 'suspended' | 'error';
+    rowi: number;
+    msg?: string;
+    last?: {
+        player: string;
+        point: number;
+    }[];
+    next?: {
+        player: string;
+        point: number;
+    }[];
+}
+export declare class ContestExtra {
     ctx: Context;
     subscribers: Set<string>;
     stopCls: Set<number>;
     type: 'ti' | 'ssb';
     round?: number;
     lobby?: string;
+    playerIndex?: number;
     ver: number;
+    maxRow?: number;
     constructor(ctx: Context);
     broadcast(msg: string): Promise<void>;
 }
@@ -39,6 +54,7 @@ export declare class ContestManager {
     mahjongpub: MahjongPub;
     extra: Dict<ContestExtra>;
     constructor(ctx: Context, config: ContestManager.Config);
+    getClsStatus(cid: number, cls: number): Promise<ClsStatus>;
     _startMatch(cid: number, cls: number, timeout?: number, force?: boolean): Promise<void>;
     startMatch(cid: number, cls: number, timeout?: number, force?: boolean): Promise<void>;
     onMatchFinished(record: MatchRecord): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hieuzest/koishi-plugin-mahjongpub",
   "description": "Mahjong.pub API",
-  "version": "0.2.12",
+  "version": "0.2.14",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -20,6 +20,18 @@
     "koishi": "^4.17.1"
   },
   "dependencies": {
-    "@hieuzest/cachetools": "^0.1.5"
+    "@hieuzest/cachetools": "^0.1.5",
+    "@satorijs/element": "^3.1.8"
+  },
+  "devDependencies": {
+    "@hieuzest/koishi-buildtools": "^1.0.2",
+    "@hieuzest/koishi-plugin-mahjong": "^3.0.0",
+    "@hieuzest/koishi-plugin-majsoul-dhs": "^2.5.0",
+    "@hieuzest/koishi-plugin-riichi-city": "^0.5.2",
+    "@hieuzest/koishi-plugin-send": "^1.3.7",
+    "@koishijs/assets": "^1.1.2",
+    "@koishijs/cache": "^2.1.0",
+    "@koishijs/plugin-server": "^3.2.7",
+    "koishi": "^4.18.9"
   }
 }