koishi-plugin-prism 0.1.6 → 0.1.7

package/README.md

@@ -8,7 +8,7 @@
 
 * 🎮 **玩家入场与结算**：通过 `/login` 和 `/logout` 指令开启或结算计费场次，支持 `/入场` 别名。
 * 💳 **账户钱包与资产管理**：支持查询钱包余额（`/wallet`）和持有的道具资产（`/items`）。
-* 🀄 **麻将桌位集成**：包含 `/mahjong <tableId>` 以及便捷的 `/上桌` / `/下桌` 控制。
+* 🀄 **麻将桌位集成**：包含 `/mahjong <tableId>` 以及便捷的 `/上桌` / `/下桌` 控制。`上桌` 仅允许已通过 `login`/`入场` 开启默认入场会话的玩家使用。`list` 会按音乐游戏和麻将桌分组，并对同一玩家的多个计时会话去重；麻将桌显示当前人数和容量。未满桌候座由机器人进程暂存，机器人重启后不会保留。
 * 🔌 **硬件设备状态与电源管理**：可直接在聊天中查看设备状态（`/show`）、远程开启/关闭电源（`/on`、`/off`）、远程投币（`/coin`）和模拟刷卡（`/scan`）。
 * 🎟️ **礼物兑换码**：使用 `/redeem <code>` 兑换系统发放的福利礼包。
 * 🛠️ **管理员高级指令**：允许管理员在聊天中查看玩家（`/admin.players`）、创建新玩家账户（`/admin.create-player`）、充值余额（`/admin.grant-balance`）、手动结账（`/admin.checkout`）以及制作礼包兑换码（`/admin.redeem-code`）。
@@ -41,7 +41,7 @@
 * `billing` - 预览当前玩家本场计费的消费费用。
 * `wallet` - 查看当前玩家的钱包余额。
 * `items` - 查看当前玩家持有的道具或资产。
-* `list` - 查看当前在线/在店游玩玩家的列表。
+* `list` - 查看当前在线/在店游玩玩家的列表，按音乐游戏和麻将桌分组并对同一玩家的多个计时会话去重；麻将桌显示当前人数和容量。未满桌候座由机器人进程暂存，机器人重启后不会保留。
 * `show [deviceId]` - 查看设备电源与连接状态。
 * `history` - 查看自己的历史游玩记录。
 * `lock` - 发送开门指令。
@@ -50,7 +50,7 @@
 * `coin <deviceId> [count]` - 请求向指定设备投币指定枚数。
 * `scan <deviceId> <subject>` - 请求向设备发送模拟刷卡。
 * `redeem <code>` - 兑换礼物码。
-* `mahjong <tableId>` / `上桌 <tableId>` - 加入指定麻将桌。
+* `mahjong <tableId>` / `上桌 <tableId>` - 加入指定麻将桌；仅允许已通过 `login`/`入场` 开启默认入场会话的玩家使用。
 * `下桌 <tableId>` - 离开指定麻将桌。
 
 ### 管理员指令 (需在白名单内并开启)

package/lib/index.js

@@ -389,6 +389,11 @@ class PrismKoishiService {
         const tableSubject = tableConfig.displayName || `${tableKey} 桌`;
         const player = await this.resolvePlayer(sender);
         const playerId = String(player.id ?? "");
+        const activeResult = (await this.client.listActiveSessions());
+        const activeSessions = (activeResult.sessions ?? []);
+        if (!this.hasEntrySession(playerId, activeSessions)) {
+            return "请先入场后再上桌。";
+        }
         const existing = this.mahjongTableForPlayer(playerId);
         if (existing)
             return `你已经在 ${existing} 桌了。`;
@@ -552,28 +557,14 @@ class PrismKoishiService {
     async listActiveSessions(sender) {
         const result = (await this.client.listActiveSessions());
         const sessions = (result?.sessions ?? []);
-        if (sessions.length === 0)
-            return "🫥 窝里目前没有玩家呢";
-        const lines = [`👥 窝里目前共有 ${sessions.length} 人`];
-        for (const session of sessions) {
-            const identitySubject = findSubjectForSession(session, this.config.provider);
-            let display;
-            if (identitySubject) {
-                const platformName = await this.resolvePlatformName(identitySubject);
-                if (platformName) {
-                    display = `${platformName} ( ${identitySubject} )`;
-                }
-                else {
-                    display = `${session.playerDisplayName || identitySubject} ( ${identitySubject} )`;
-                }
-            }
-            else {
-                display = session.playerDisplayName || session.playerId || "未知玩家";
-            }
-            const timeStr = formatDateTime(session.startedAt);
-            lines.push(`玩家: ${display}\n入场时间: ${timeStr}`);
-        }
-        return lines.join("\n\n");
+        const tableByLabel = new Map(uniqueMahjongConfigs(this.mahjongTableConfigs()).map((table) => [
+            mahjongSessionLabel(table, this.config.mahjongLabelPrefix ?? "麻将桌"),
+            table,
+        ]));
+        const players = groupSessionsByPlayer(sessions);
+        const groups = await this.buildPlayerGroups(players, tableByLabel);
+        this.mergeWaitingSeats(groups);
+        return formatPlayerGroups(groups, this.config.mahjongTableSize ?? 4, this.config.mahjongLabelPrefix ?? "麻将桌");
     }
     async listDeviceStates(rawAlias) {
         const alias = cleanText(rawAlias);
@@ -712,6 +703,64 @@ class PrismKoishiService {
             return null;
         }
     }
+    async displayNameForPlayer(player) {
+        let identitySubject;
+        for (const session of player.sessions) {
+            const subject = findSubjectForSession(session, this.config.provider);
+            if (!subject)
+                continue;
+            identitySubject ??= subject;
+            const platformName = await this.resolvePlatformName(subject);
+            if (platformName)
+                return platformName;
+        }
+        return player.sessions.find((session) => session.playerDisplayName)?.playerDisplayName
+            || identitySubject
+            || player.displayName
+            || player.playerId
+            || "未知玩家";
+    }
+    async buildPlayerGroups(players, tableByLabel) {
+        const groups = {
+            music: [],
+            mahjong: uniqueMahjongConfigs(this.mahjongTableConfigs()).map((table) => ({ table, players: [] })),
+        };
+        const groupForTable = new Map(groups.mahjong.map((group) => [group.table.tableId, group]));
+        for (const player of players.values()) {
+            player.displayName = await this.displayNameForPlayer(player);
+            const table = player.sessions
+                .map((session) => tableByLabel.get(session.label ?? ""))
+                .find((value) => Boolean(value));
+            if (table) {
+                groupForTable.get(table.tableId)?.players.push(player);
+            }
+            else {
+                groups.music.push(player);
+            }
+        }
+        return groups;
+    }
+    mergeWaitingSeats(groups) {
+        for (const [tableId, state] of this.mahjongTables) {
+            const group = groups.mahjong.find((candidate) => candidate.table.tableId === tableId);
+            if (!group)
+                continue;
+            for (const seat of state.waiting) {
+                if (group.players.some((player) => player.playerId === seat.playerId))
+                    continue;
+                const existing = [groups.music, ...groups.mahjong.map((candidate) => candidate.players)]
+                    .flat()
+                    .find((player) => player.playerId === seat.playerId);
+                groups.music = groups.music.filter((player) => player.playerId !== seat.playerId);
+                for (const candidate of groups.mahjong) {
+                    if (candidate !== group) {
+                        candidate.players = candidate.players.filter((player) => player.playerId !== seat.playerId);
+                    }
+                }
+                group.players.push(existing ?? { playerId: seat.playerId, sessions: [], displayName: seat.displayName });
+            }
+        }
+    }
     async resolvePlayerDisplay(sender, playerId) {
         if (!sender)
             return playerId || "未知玩家";
@@ -736,6 +785,10 @@ class PrismKoishiService {
     async resolvePlayer(sender) {
         return (await this.client.resolveOrRegisterIdentity(this.identity(sender)));
     }
+    hasEntrySession(playerId, sessions) {
+        const label = this.config.loginSessionLabel?.trim();
+        return sessions.some((session) => session.playerId === playerId && (label ? session.label === label : true));
+    }
     identity(sender) {
         return {
             provider: this.config.provider,
@@ -924,6 +977,45 @@ function parseMahjongTables(value, labelPrefix) {
     }
     return tables;
 }
+function uniqueMahjongConfigs(tables) {
+    return [...new Map([...tables.values()].map((table) => [table.tableId, table])).values()];
+}
+function mahjongSessionLabel(table, labelPrefix) {
+    return table.displayName || `${labelPrefix} ${table.tableId}`;
+}
+function groupSessionsByPlayer(sessions) {
+    const players = new Map();
+    for (const session of sessions) {
+        const playerId = session.playerId || findSubjectForSession(session, "") || "";
+        if (!playerId)
+            continue;
+        const player = players.get(playerId) ?? { playerId, sessions: [] };
+        player.sessions.push(session);
+        players.set(playerId, player);
+    }
+    return players;
+}
+function formatPlayerGroups(groups, tableSize, mahjongLabelPrefix) {
+    const populatedMahjongGroups = groups.mahjong.filter((group) => group.players.length > 0);
+    const total = groups.music.length + populatedMahjongGroups.reduce((sum, group) => sum + group.players.length, 0);
+    if (total === 0)
+        return "🫥 窝里目前没有玩家呢";
+    const lines = [`[总计 ${total} 人]`];
+    if (groups.music.length > 0) {
+        lines.push(`🎵 音乐游戏 ( ${groups.music.length}人 )：\n${formatPlayerNames(groups.music)}`);
+    }
+    for (const group of populatedMahjongGroups) {
+        lines.push(`${formatMahjongTableLabel(group.table, mahjongLabelPrefix)} ( ${group.players.length}/${tableSize} )：\n${formatPlayerNames(group.players)}`);
+    }
+    return lines.join("\n");
+}
+function formatMahjongTableLabel(table, labelPrefix) {
+    const label = mahjongSessionLabel(table, labelPrefix);
+    return table.displayName ? label : `🀄️ ${label}`;
+}
+function formatPlayerNames(players) {
+    return players.map((player) => `- ${player.displayName || player.playerId || "未知玩家"}`).join(", ");
+}
 function splitOnce(text, sep) {
     const idx = text.indexOf(sep);
     if (idx === -1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-prism",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "PRiSM Next 计费与设备管理系统的 Koishi 机器人集成插件",
   "main": "./lib/index.js",
   "exports": {
@@ -48,4 +48,4 @@
     "test": "bun test test",
     "typecheck": "tsc -p tsconfig.json"
   }
-}
+}