@hieuzest/koishi-plugin-riichi-city 0.3.1 → 0.4.1

package/lib/api.d.ts

@@ -79,9 +79,11 @@ export declare class RiichiCityApi {
         stageType?: number;
         matchType?: number;
         gamePlay?: number;
-        round?: number;
-        classifyID: string;
-    }): Promise<types.Game[]>;
+        round?: 1 | 2;
+        playerCount?: 3 | 4;
+        friend?: boolean;
+        classifyID?: string;
+    }): Promise<types.Room[]>;
     listPaipus(options: {
         startTime?: number;
         endTime?: number;
@@ -92,6 +94,8 @@ export declare class RiichiCityApi {
         limit?: number;
         skip?: number;
     }): Promise<types.Paipu[]>;
+    getRoomData(roomId: string): Promise<types.RoomData>;
+    getGameData(roomId: string, eventStartPos: number): Promise<types.GameData>;
 }
 export declare namespace RiichiCityApi {
     export interface Cookie {

package/lib/api.js

@@ -270,6 +270,8 @@ var RiichiCityApi = class _RiichiCityApi {
     const res = await this.post("/lobbys/getSelfManageInfo", { matchID });
     return res.data;
   }
+  // Lobby games: { classifyID }
+  // Rank games: { playerCount, round, stageType }
   async listGames(options) {
     const res = await this.post("/record/readOnlineRoom", options);
     return res.data;
@@ -279,6 +281,14 @@ var RiichiCityApi = class _RiichiCityApi {
     const res = await this.post("/record/readPaiPuList", { limit, skip, ...options });
     return res.data;
   }
+  async getRoomData(roomId) {
+    const res = await this.post("/record/getRoomData", { isObserve: true, keyValue: roomId });
+    return res.data;
+  }
+  async getGameData(roomId, eventStartPos) {
+    const res = await this.post("/record/getGameData", { roomId, eventStartPos });
+    return res.data;
+  }
 };
 ((RiichiCityApi2) => {
   function md5(data) {

package/lib/index.d.ts

@@ -1,20 +1,31 @@
-import { Context, Schema, Service } from 'koishi';
+import { Context, Dict, Schema, Service } from 'koishi';
 import { RiichiCityApi } from './api';
 import { RiichiCityDHS } from './dhs';
 declare module 'koishi' {
     interface Context {
         'riichi-city': RiichiCity;
     }
+    interface Tables {
+        'riichi-city.accounts': RiichiCityAccount;
+    }
+}
+export interface RiichiCityAccount {
+    userId: number;
+    nickname: string;
+    updatedAt?: number;
 }
 export declare class RiichiCity extends Service {
     ctx: Context;
     config: RiichiCity.Config;
     api: RiichiCityApi;
     constructor(ctx: Context, config: RiichiCity.Config);
+    getAccountsByNicknames(nicknames: string[], query?: boolean): Promise<Dict<RiichiCityAccount[]>>;
+    getAccounts(userIds: number[]): Promise<Dict<RiichiCityAccount | undefined>>;
+    setAccounts(accounts: RiichiCityAccount[]): Promise<void>;
 }
 export declare namespace RiichiCity {
+    const inject: string[];
     type Config = RiichiCityApi.Config & {
-        name?: string;
         dhs: RiichiCityDHS.Config;
     };
     const Config: Schema<Config>;

package/lib/index.js

@@ -188,7 +188,7 @@ ${config.extraHelp}`.trim();
         return "已关闭通知";
       } else {
         c.notifyIdle = 0;
-        c.notifyCache = /* @__PURE__ */ Object.create(null);
+        c.notifyCache = [];
         c.notify = ctx.setInterval(async () => {
           const send = /* @__PURE__ */ __name(async (roomID, retry = 0) => {
             const paipu = await c.listPaipus().then((l) => l.find((x) => x.roomID === roomID));
@@ -206,19 +206,19 @@ ${config.extraHelp}`.trim();
           }, "send");
           try {
             const games = await c.listGames();
-            if (c.notifyCache) {
+            if (c.notifyCache?.length) {
               for (const roomID of Object.keys(c.notifyCache)) {
                 if (!games.some((g) => g.roomID === roomID)) {
                   ctx.setTimeout(() => send(roomID), 1e3 * 5);
                 }
               }
             }
-            if (!games?.length && !Object.keys(c.notifyCache ?? {}).length) c.notifyIdle++;
+            if (!games?.length && !c.notifyCache?.length) c.notifyIdle++;
             if (c.notifyIdle > config.notifyIdle) {
               c.notify?.();
               return "自动关闭通知";
             }
-            c.notifyCache = Object.fromEntries(games.map((g) => [g.roomID, g]));
+            c.notifyCache = games.map((g) => g.roomID);
           } catch (e) {
             console.warn(e);
             c.notifyIdle++;
@@ -394,6 +394,7 @@ var Rcpt = class {
         const findFriend = await this.api.findFriend(pattern).catch(import_koishi2.noop);
         const friend = findFriend?.friendList?.find((f) => f.nickname === pattern);
         if (!friend) return session.text(".failed");
+        ctx["riichi-city"].setAccounts([{ userId: friend.userID, nickname: friend.nickname }]);
         userId = friend.userID;
       }
       try {
@@ -429,10 +430,17 @@ ${session.text(".recent-results")} [${ranks.three.lastRankList.reverse().join(""
 // src/index.ts
 var RiichiCity = class extends import_koishi3.Service {
   constructor(ctx, config) {
-    super(ctx, config.name || "riichi-city", true);
+    super(ctx, "riichi-city", true);
     this.ctx = ctx;
     this.config = config;
     ctx.i18n.define("zh-CN", require_zh_CN());
+    ctx.model.extend("riichi-city.accounts", {
+      userId: "unsigned",
+      nickname: "string",
+      updatedAt: "unsigned"
+    }, {
+      primary: "userId"
+    });
     this.api = new import_api2.RiichiCityApi(ctx, config);
     ctx.on("ready", async () => {
       await this.api.login().catch((e) => ctx.logger.warn(e));
@@ -444,12 +452,43 @@ var RiichiCity = class extends import_koishi3.Service {
     __name(this, "RiichiCity");
   }
   api;
+  async getAccountsByNicknames(nicknames, query = true) {
+    const curtime = Date.now() / 1e3;
+    const list = await this.ctx.database.select("riichi-city.accounts", { nickname: nicknames }).groupBy("nickname", {
+      accounts: /* @__PURE__ */ __name((row) => import_koishi3.$.array(import_koishi3.$.object(row)), "accounts")
+    }).execute();
+    const res = Object.fromEntries(list.map((l) => [l.nickname, l.accounts.sort((a, b) => b.updatedAt - a.updatedAt)]));
+    if (!query) return res;
+    const upsert = [];
+    await Promise.all(nicknames.filter((nickname) => !res[nickname]).map((nickname) => this.api.findFriend(nickname).catch(import_koishi3.noop))).then((friends) => {
+      friends.forEach((friend) => {
+        console.log(">", friend);
+        if (!friend?.friendList?.length) return;
+        for (const info of friend.friendList) {
+          (res[info.nickname] ??= []).push({ userId: info.userID, nickname: info.nickname, updatedAt: curtime });
+          upsert.push({ userId: info.userID, nickname: info.nickname, updatedAt: curtime });
+        }
+      });
+    });
+    if (upsert.length) this.setAccounts(upsert);
+    return res;
+  }
+  async getAccounts(userIds) {
+    const res = Object.fromEntries(userIds.map((userId) => [userId, void 0]));
+    Object.assign(Object.fromEntries(await this.ctx.database.get("riichi-city.accounts", { userId: userIds }).then((x) => x.map((x2) => [x2.userId, x2]))), res);
+    return res;
+  }
+  async setAccounts(accounts) {
+    const curtime = Date.now() / 1e3;
+    accounts = accounts.map((x) => ({ updatedAt: curtime, ...x }));
+    await this.ctx.database.upsert("riichi-city.accounts", accounts);
+  }
 };
 ((RiichiCity2) => {
+  RiichiCity2.inject = ["database"];
   RiichiCity2.Config = import_koishi3.Schema.intersect([
     import_api2.RiichiCityApi.Config,
     import_koishi3.Schema.object({
-      name: import_koishi3.Schema.string(),
       dhs: RiichiCityDHS.Config
     })
   ]);

package/lib/lobby.d.ts

@@ -1,4 +1,4 @@
-import { Dict, Disposable, SessionError } from 'koishi';
+import { Disposable, SessionError } from 'koishi';
 import { RiichiCityApi } from './api';
 import { LobbyDetails } from './types';
 export declare class DHSError extends SessionError {
@@ -55,7 +55,7 @@ export declare class RiichiCityLobby {
     details?: LobbyDetails;
     notify?: Disposable;
     notifyIdle: number;
-    notifyCache?: Dict<Game>;
+    notifyCache?: string[];
     constructor(api: RiichiCityApi, id: number);
     init(): Promise<void>;
     listAllowedPlayers(): Promise<RiichiCityApi.Identity[]>;

package/lib/types.d.ts

@@ -146,7 +146,7 @@ export interface LobbyUser {
     status: number;
     userID: number;
 }
-export interface GamePlayer {
+export interface RoomPlayer {
     headID: number;
     headTag: number;
     identity: number;
@@ -159,13 +159,13 @@ export interface GamePlayer {
     stageLevel: number;
     userId: number;
 }
-export interface Game {
+export interface Room {
     isEnd: boolean;
     isPause: boolean;
     matchStage: number;
     nowTime: number;
     playerCount: number;
-    players: GamePlayer[];
+    players: RoomPlayer[];
     roomId: string;
     stageNum: number;
     startTime: number;
@@ -196,4 +196,43 @@ export interface Paipu {
     startTime: number;
     players: PaipuPlayer[];
 }
+export interface GameEventRecord {
+    data: string;
+    eventPos: number;
+    eventType: number;
+    handId: string;
+    startTime: number;
+    userId: number;
+}
+export interface GameRecord {
+    benChangNum: number;
+    changCi: number;
+    handCardEncode: string;
+    handCardSHA256: string;
+    handEventRecord: GameEventRecord[];
+    handID: string;
+    handPos: number;
+    paiShan: string;
+    players: PaipuPlayer[];
+    quanFeng: number;
+}
+export interface RoomData {
+    fangFu: number;
+    gamePlay: number;
+    handRecord: GameRecord[];
+    initPoints: number;
+    keyValue: string;
+    nowTime: number;
+    matchStage: number;
+    matchType: number;
+    roomId: string;
+    playerCount: number;
+    round: number;
+    stageNum: number;
+    stageType: number;
+}
+export interface GameData {
+    handEventRecord: GameEventRecord[];
+    nowTime: number;
+}
 export declare const stages: string[];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hieuzest/koishi-plugin-riichi-city",
   "description": "",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [