historial de acciones persistente en el jugador y visible desde playerstats

server/src/rooms/GameRoom.ts

@@ -65,6 +65,29 @@ export class GameRoom extends Room<GameState> {
     setTimeout(() => {
       broadcastDashboardUpdate();
     }, 50);
+
+    // Persist as "seen" for currently connected players by UUID
+    try {
+      this.state.players.forEach((player, sessionId) => {
+        if (!player?.connected) return;
+        const uuid = this.sessionToUuid.get(sessionId) || (player as any)?.uuid;
+        if (!uuid) return;
+        try {
+          NameManager.getInstance().appendSystemMessage(uuid, {
+            timestamp,
+            kind,
+            text,
+            roomId: this.roomId,
+            variant: this.state.currentVariant,
+            round: this.state.currentRound,
+            role: (player as any)?.role || '',
+            pavoTokens: (player as any)?.pavoTokens || 0,
+            eloteTokens: (player as any)?.eloteTokens || 0,
+            shameTokens: (player as any)?.shameTokens || 0,
+          });
+        } catch {}
+      });
+    } catch {}
   }
 
   onCreate(options: any) {
@@ -262,6 +285,20 @@ export class GameRoom extends Room<GameState> {
       this.broadcast("chat", { id, text, from, fromId: client.sessionId, ts, color });
     });
 
+    // Provide per-player system history (as seen) to clients
+    this.onMessage("getSystemHistory", (client, targetSessionId: string) => {
+      try {
+        const target = this.state.players.get((targetSessionId || '').toString());
+        if (!target) return;
+        const uuid = this.sessionToUuid.get(target.sessionId) || (target as any)?.uuid;
+        if (!uuid) return;
+        const history = NameManager.getInstance().getSystemHistory(uuid) || [];
+        client.send("systemHistory", { for: target.sessionId, history });
+      } catch (e) {
+        // ignore
+      }
+    });
+
     // G3 shame token after snatch
     this.onMessage("assignShame", (client, assign: boolean) => {
       const player = this.state.players.get(client.sessionId);

server/src/utils/nameManager.ts

@@ -3,6 +3,18 @@ export class NameManager {
   private uuidToName: Map<string, string> = new Map();
   private uuidToColor: Map<string, string> = new Map();
   private uuidToShame: Map<string, number> = new Map();
+  private uuidToSystemHistory: Map<string, {
+    timestamp: number;
+    kind: string;
+    text: string;
+    roomId?: string;
+    variant?: string;
+    round?: number;
+    role?: 'P1' | 'P2' | '';
+    pavoTokens?: number;
+    eloteTokens?: number;
+    shameTokens?: number;
+  }[]> = new Map();
   
   // For shuffle functionality
   private roomAssignments: Map<string, { roomId: string; role: 'P1' | 'P2' }> = new Map();
@@ -77,6 +89,7 @@ export class NameManager {
     this.uuidToName.forEach((_, k) => set.add(k));
     this.uuidToColor.forEach((_, k) => set.add(k));
     this.uuidToShame.forEach((_, k) => set.add(k));
+    this.uuidToSystemHistory.forEach((_, k) => set.add(k));
     return Array.from(set.values());
   }
 
@@ -96,6 +109,7 @@ export class NameManager {
     this.uuidToName.delete(uuid);
     this.uuidToColor.delete(uuid);
     this.uuidToShame.set(uuid, 0);
+    this.uuidToSystemHistory.delete(uuid);
   }
 
   // Current game room assignment (for reconnection by UUID)
@@ -156,4 +170,40 @@ export class NameManager {
   getAllRoomAssignments(): Map<string, { roomId: string; role: 'P1' | 'P2' }> {
     return new Map(this.roomAssignments);
   }
+
+  // Per-UUID system message history (as seen while connected)
+  appendSystemMessage(uuid: string, entry: {
+    timestamp: number; kind: string; text: string;
+    roomId?: string; variant?: string; round?: number;
+    role?: 'P1'|'P2'|''; pavoTokens?: number; eloteTokens?: number; shameTokens?: number;
+  }): void {
+    if (!uuid) return;
+    const list = this.uuidToSystemHistory.get(uuid) || [];
+    list.push({
+      timestamp: Number(entry.timestamp) || Date.now(),
+      kind: (entry.kind || '').toString(),
+      text: (entry.text || '').toString(),
+      roomId: entry.roomId,
+      variant: entry.variant,
+      round: entry.round,
+      role: entry.role || '',
+      pavoTokens: Number(entry.pavoTokens ?? 0),
+      eloteTokens: Number(entry.eloteTokens ?? 0),
+      shameTokens: Number(entry.shameTokens ?? 0),
+    });
+    if (list.length > 1000) list.splice(0, list.length - 1000);
+    this.uuidToSystemHistory.set(uuid, list);
+  }
+
+  getSystemHistory(uuid: string): {
+    timestamp: number; kind: string; text: string;
+    roomId?: string; variant?: string; round?: number;
+    role?: 'P1'|'P2'|''; pavoTokens?: number; eloteTokens?: number; shameTokens?: number;
+  }[] {
+    return [...(this.uuidToSystemHistory.get(uuid) || [])];
+  }
+
+  clearSystemHistory(uuid: string): void {
+    this.uuidToSystemHistory.delete(uuid);
+  }
 }