koishi-plugin-prism 0.1.13 → 0.1.15

package/README.md

@@ -8,7 +8,7 @@
 
 * 🎮 **玩家入场与结算**：通过 `/login` 和 `/logout` 指令开启或结算计费场次，支持 `/入场` 别名；命令回复会引用触发消息，结账账单可私聊通知管理员与指定用户。
 * 💳 **账户钱包与资产管理**：支持查询钱包余额（`/wallet`）和持有的道具资产（`/items`）。
-* 🀄 **麻将桌位集成**：包含 `/mahjong <tableId>` 以及便捷的 `/上桌` / `/下桌` 控制。`上桌` 仅允许已通过 `login`/`入场` 开启默认入场会话的玩家使用。`list` 会按音乐游戏和麻将桌分组，并对同一玩家的多个计时会话去重；麻将桌显示当前人数和容量。未满桌候座由机器人进程暂存，机器人重启后不会保留。
+* 🀄 **麻将桌位集成**：包含 `/mahjong <tableId>` 以及便捷的 `/上桌` / `/下桌` 控制。`上桌` 仅允许已通过 `login`/`入场` 开启默认入场会话的玩家使用。`list` 按 session 标签分组：有非音乐游戏 session 的玩家归入最新的非音乐标签，纯音乐玩家归入音乐标签；麻将桌额外显示当前人数和容量。已开局桌位会从后端活跃 session 自动恢复，未满桌候座仍由机器人进程暂存，重启后不会保留。
 * 🔌 **硬件设备状态与电源管理**：可直接在聊天中查看设备状态（`/show`）、远程开启/关闭电源（`/on`、`/off`）、远程投币（`/coin`）和模拟刷卡（`/scan`）。
 * 🎟️ **礼物兑换码**：使用 `/redeem <code>` 兑换系统发放的福利礼包。
 * 🛠️ **管理员快捷指令**：允许管理员为指定平台用户增加或扣除余额，并覆盖结账金额后立即结账。
@@ -46,7 +46,7 @@
 * `billing` - 预览当前玩家本场计费的消费费用。
 * `wallet` - 查看当前玩家的钱包余额。
 * `items` - 查看当前玩家持有的道具或资产。
-* `list` - 查看当前在线/在店游玩玩家的列表，按音乐游戏和麻将桌分组并对同一玩家的多个计时会话去重；麻将桌显示当前人数和容量。未满桌候座由机器人进程暂存，机器人重启后不会保留。
+* `list` - 查看当前在线/在店游玩玩家的列表，按 session 标签分组并对同一玩家去重；存在非音乐游戏 session 时取最新的非音乐标签，麻将桌显示当前人数和容量。已开局桌位由后端 session 恢复；未满桌候座由机器人进程暂存，机器人重启后不会保留。
 * `show [deviceId]` - 查看设备电源与连接状态。
 * `history` - 查看自己的历史游玩记录。
 * `lock` - 发送开门指令。

package/lib/index.js

@@ -396,6 +396,7 @@ class PrismKoishiService {
         const playerId = String(player.id ?? "");
         const activeResult = (await this.client.listActiveSessions());
         const activeSessions = (activeResult.sessions ?? []);
+        this.syncMahjongTableStates(activeSessions);
         if (!this.hasEntrySession(playerId, activeSessions)) {
             return "请先入场后再上桌。";
         }
@@ -439,6 +440,8 @@ class PrismKoishiService {
         const tableConfig = this.mahjongTableConfigs().get(tableId);
         const tableKey = tableConfig?.tableId ?? tableId;
         const tableSubject = tableConfig?.displayName || `${tableId} 桌`;
+        const activeResult = (await this.client.listActiveSessions());
+        this.syncMahjongTableStates((activeResult.sessions ?? []));
         const state = this.mahjongTables.get(tableKey);
         if (!state)
             return `你不在 ${tableSubject}。`;
@@ -567,6 +570,7 @@ class PrismKoishiService {
     async listActiveSessions(sender) {
         const result = (await this.client.listActiveSessions());
         const sessions = (result?.sessions ?? []);
+        this.syncMahjongTableStates(sessions);
         const tableByLabel = new Map(uniqueMahjongConfigs(this.mahjongTableConfigs()).map((table) => [
             mahjongSessionLabel(table, this.config.mahjongLabelPrefix ?? "麻将桌"),
             table,
@@ -650,41 +654,44 @@ class PrismKoishiService {
             || "未知玩家";
     }
     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]));
+        const groups = { groups: [] };
+        const groupByLabel = new Map();
+        const musicLabel = this.config.loginSessionLabel?.trim() || "音游区间";
         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);
+            const nonMusic = player.sessions.filter((session) => Boolean(session.label) && session.label !== musicLabel);
+            const source = nonMusic.length > 0 ? nonMusic : player.sessions;
+            const selected = source.reduce((latest, session) => !latest || sessionStartedAt(session) > sessionStartedAt(latest) ? session : latest, undefined);
+            const label = selected?.label || musicLabel;
+            let group = groupByLabel.get(label);
+            if (!group) {
+                group = { label, table: tableByLabel.get(label), players: [] };
+                groupByLabel.set(label, group);
+                groups.groups.push(group);
             }
+            group.players.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)
+            const table = this.mahjongTableConfigs().get(tableId);
+            if (!table)
                 continue;
+            const label = mahjongSessionLabel(table, this.config.mahjongLabelPrefix ?? "麻将桌");
+            let group = groups.groups.find((candidate) => candidate.label === label);
+            if (!group) {
+                group = { label, table, players: [] };
+                groups.groups.push(group);
+            }
             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()
+                const existing = groups.groups.flatMap((candidate) => candidate.players)
                     .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) {
+                for (const candidate of groups.groups) {
+                    if (candidate !== group)
                         candidate.players = candidate.players.filter((player) => player.playerId !== seat.playerId);
-                    }
                 }
                 group.players.push(existing ?? { playerId: seat.playerId, sessions: [], displayName: seat.displayName });
             }
@@ -711,6 +718,32 @@ class PrismKoishiService {
     mahjongTableConfigs() {
         return parseMahjongTables(this.config.mahjongTables ?? "", this.config.mahjongLabelPrefix ?? "麻将桌");
     }
+    syncMahjongTableStates(sessions) {
+        const tables = uniqueMahjongConfigs(this.mahjongTableConfigs());
+        const tableByLabel = new Map(tables.map((table) => [
+            mahjongSessionLabel(table, this.config.mahjongLabelPrefix ?? "麻将桌"),
+            table,
+        ]));
+        const activeByTable = new Map();
+        for (const session of sessions) {
+            const table = tableByLabel.get(session.label ?? "");
+            const playerId = String(session.playerId ?? "");
+            const sessionId = String(session.id ?? "");
+            if (!table || !playerId || !sessionId)
+                continue;
+            const active = activeByTable.get(table.tableId) ?? {};
+            active[playerId] = sessionId;
+            activeByTable.set(table.tableId, active);
+        }
+        for (const table of tables) {
+            const state = this.mahjongTables.get(table.tableId) ?? { waiting: [], activeSessions: {} };
+            state.activeSessions = activeByTable.get(table.tableId) ?? {};
+            state.waiting = state.waiting.filter((seat) => !state.activeSessions[seat.playerId]);
+            if (state.waiting.length > 0 || Object.keys(state.activeSessions).length > 0 || this.mahjongTables.has(table.tableId)) {
+                this.mahjongTables.set(table.tableId, state);
+            }
+        }
+    }
     async resolvePlayer(sender) {
         return (await this.client.resolveOrRegisterIdentity(this.identity(sender)));
     }
@@ -954,17 +987,21 @@ function groupSessionsByPlayer(sessions) {
     }
     return players;
 }
+function sessionStartedAt(session) {
+    const value = Date.parse(session.startedAt ?? "");
+    return Number.isFinite(value) ? value : 0;
+}
 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);
+    const populatedGroups = groups.groups.filter((group) => group.players.length > 0);
+    const total = new Set(populatedGroups.flatMap((group) => group.players.map((player) => player.playerId))).size;
     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)}`);
+    for (const group of populatedGroups) {
+        const heading = group.table
+            ? `${formatMahjongTableLabel(group.table, mahjongLabelPrefix)} ( ${group.players.length}/${tableSize} )`
+            : `${group.label} ( ${group.players.length}人 )`;
+        lines.push(`${heading}：\n${formatPlayerNames(group.players)}`);
     }
     return lines.join("\n");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-prism",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "PRiSM Next 计费与设备管理系统的 Koishi 机器人集成插件",
   "main": "./lib/index.js",
   "exports": {