@zaisma/game-server 1.5.0 → 1.6.0

package/src/room.js

@@ -6,6 +6,7 @@
  * developer's code that holds the official game state. A *room* is one live match,
  * running one copy of the game server. Names follow docs/NAMING.md.
  */
+import { CHAT_CHECK_LIMITS, CHAT_ROOM_LIMITS } from "./chat.js";
 import { DatabaseError } from "./database.js";
 import { isRoomCode, roomCode } from "./names.js";
 import { readSchedules } from "./schedules.js";
@@ -22,6 +23,20 @@ function shownPlayer(player) {
 export function restoreInfoOf(savedAtMs, nowMs = Date.now(), savedVersionId = null, isSavedEmpty = false) {
     return { savedAt: new Date(savedAtMs).toISOString(), lostDurationSec: isSavedEmpty ? 0 : Math.max(0, Math.round((nowMs - savedAtMs) / 1000)), savedVersionId };
 }
+/** What the sender hears when the game server's onChat stopped their message. */
+export const STOPPED_BY_GAME_MESSAGE = "Your message wasn't sent.";
+/** onChat's answer as the room acts on it: send (to toPlayerIds, or all it was sent to when null), or stop. Anything else is a mistake, and stops it. */
+export function readChatAnswer(answer) {
+    if (answer === true)
+        return { isAllowed: true, toPlayerIds: null };
+    if (answer === false)
+        return { isAllowed: false };
+    const toPlayerIds = typeof answer === "object" && answer !== null && !Array.isArray(answer) ? answer.toPlayerIds : undefined;
+    if (Array.isArray(toPlayerIds) && toPlayerIds.every((id) => typeof id === "string") && Object.keys(answer).length === 1)
+        return { isAllowed: true, toPlayerIds };
+    const given = answer === undefined || answer === null ? "nothing" : typeof answer === "string" ? `the text ${JSON.stringify(answer.slice(0, 60))}` : typeof answer === "object" ? describeObject(answer) : String(answer);
+    return { mistake: new GameServerError("bad_handler_answer", "onChat", `onChat answered ${given}, so the message was stopped.`, 'Answer true to send it, false to stop it, or { toPlayerIds: ["player_..."] } to send it to only those players.') };
+}
 function describeObject(given) {
     try {
         return (JSON.stringify(given) ?? "an object").slice(0, 80);
@@ -59,12 +74,14 @@ export const GAME_SERVER_OPTIONS = [
     "awayMode",
     "seatHoldDurationSec",
     "stateSyncEnabled",
+    "adultChatFilterEnabled",
     "reconnectTimeoutSec",
     "maximumRoomCountPerPlayer",
     "stateSaveIntervalSec",
     "setup",
     "onJoin",
     "canJoin",
+    "onChat",
     "onMoved",
     "onLeave",
     "onSpectatorJoin",
@@ -240,6 +257,8 @@ export function defineGameServer(server) {
         throw bad("hostControlsEnabled", "hostControlsEnabled isn't true or false.", "Give true or false.");
     if (server.stateSyncEnabled !== undefined && typeof server.stateSyncEnabled !== "boolean")
         throw bad("stateSyncEnabled", "stateSyncEnabled isn't true or false.", "Give true to send each player the state and then only what changes, or leave it out.");
+    if (server.adultChatFilterEnabled !== undefined && typeof server.adultChatFilterEnabled !== "boolean")
+        throw bad("adultChatFilterEnabled", "adultChatFilterEnabled isn't true or false.", "Give true to check chat between adults with Zaisma's filter too, or leave it out.");
     if (server.stateView !== undefined && !server.stateSyncEnabled)
         throw bad("stateView", "stateView only works with stateSyncEnabled.", "Add stateSyncEnabled: true, or leave stateView out.");
     if (idleCheck !== undefined && idleCheck !== "server" && idleCheck !== "client" && idleCheck !== "off") {
@@ -290,6 +309,11 @@ export const ERROR_TEXT = {
     bad_origin: "Rooms take players from the game's own page.",
     // The SDK's own: sends waiting while it reconnects ran past its queue.
     send_queue_full: "Up to 60 sends wait while reconnecting; older ones were dropped.",
+    chat_not_here: "This room's server doesn't take chat.",
+    chat_not_allowed: "You can't chat here.",
+    chat_empty: "Type a message first.",
+    chat_too_long: "That message is too long to send.",
+    chat_too_fast: "Too many messages at once. Wait a moment.",
 };
 /** What players are told when Zaisma ends a match at room.endsAt. */
 export const HOSTING_PAUSED_END_MESSAGE = "This game's hosting is paused, so this match has ended. New rooms open again when the month resets or its developer adds credit.";
@@ -323,6 +347,35 @@ export function checkRoomData(given, maximumSizeBytes) {
 export function errorMessage(code, message, details) {
     return JSON.stringify({ type: "error", code, message: message || ERROR_TEXT[code], ...details });
 }
+/** A checked pass's chat settings, for RoomCore.setChatSettings: null for a guest. A setting this version doesn't know chats with nobody. */
+export function chatSettingsOf(claims) {
+    if (claims.kind !== "account")
+        return null;
+    const whoCanChat = claims.who_can_chat === "friends" ? "friends" : claims.who_can_chat === "anyone" ? "anyone" : "nobody";
+    return { whoCanChat, chatGroupId: typeof claims.chat_group_id === "string" ? claims.chat_group_id : null };
+}
+/** Room traffic of chat, in the room's message types. */
+export const CHAT_MESSAGE_TYPE = "(chat)";
+/**
+ * A client's chat message ({type: "chat"}), or null for any other text, which goes to receive. The
+ * room's host handles chat before receive, since Zaisma's filter runs between the room and the players.
+ */
+export function readChatMessage(text) {
+    // Most messages aren't chat: only text that could be is parsed here, and one too big is receive's to refuse.
+    if (!text.includes('"chat"') || text.length > ROOM_LIMITS.maximumGameMessageSizeBytes)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object" || parsed.type !== "chat")
+        return null;
+    const chat = parsed;
+    return { chatNumber: Number.isSafeInteger(chat.chatNumber) ? chat.chatNumber : 0, text: chat.text, toPlayerIds: chat.toPlayerIds, sizeBytes: utf8ByteCount(text) };
+}
 /** WebSocket close code for a match that ended normally. */
 export const ENDED_CLOSE_CODE = 4000;
 /** Close code for a player refused or removed by the room: the SDK doesn't reconnect. */
@@ -482,6 +535,12 @@ export class RoomCore {
     sessionBlocks = new Set();
     /** Friendships between players from their accounts (Zaisma's own record, or passes on your own server): pairKey(first, second). */
     friendships = new Set();
+    /** Who each account player may chat with, from their pass: never in Player, so games never see it. */
+    chatSettings = new Map();
+    /** When each player sent their chat messages in the last CHAT_ROOM_LIMITS.chatWindowDurationMs. */
+    chatSentAtMs = new Map();
+    /** Each player's last chat messages, for Zaisma's filter to read pieces together: in memory only. */
+    recentChats = new Map();
     /** The blocks each player was last told of, so they're told again only when theirs change. */
     toldBlocks = new Map();
     /** When each player in the match was last heard from, when their game was hidden, and the idle check their game asked for. */
@@ -509,6 +568,8 @@ export class RoomCore {
     api;
     /** The room as canJoin and stateView see it: reading works, and any call that changes or sends throws room_call_unavailable. */
     canJoinRoom;
+    /** The room as onChat sees it: reading only, like canJoin. */
+    chatRoom;
     stateViewRoom;
     server;
     transport;
@@ -604,6 +665,8 @@ export class RoomCore {
                 this.sessionBlocks.add(blockKey(blocker, blocked));
             for (const [first, second] of saved.friendships ?? [])
                 this.friendships.add(pairKey(first, second));
+            for (const [id, settings] of Object.entries(saved.chatSettings ?? {}))
+                this.chatSettings.set(id, settings);
         }
         else if (startOptions.start) {
             const start = startOptions.start;
@@ -727,6 +790,7 @@ export class RoomCore {
         Object.defineProperty(this.api, PAIR_CHANGE_COUNT, { get: () => this.pairChangeCount });
         Object.defineProperty(this.api, STATE_SYNC, { value: { viewers: () => this.stateViewers(), send: (playerIds, frame) => this.sendStateFrom(playerIds, frame) } });
         this.canJoinRoom = readOnlyRoom(this.api, "canJoin");
+        this.chatRoom = readOnlyRoom(this.api, "onChat");
         this.stateViewRoom = readOnlyRoom(this.api, "stateView");
         if (restoreInfo)
             this.restored(restoreInfo, lostPlayers);
@@ -772,6 +836,7 @@ export class RoomCore {
             ...(this.endsAt ? { endsAt: this.endsAt } : {}),
             ...(this.isKept ? { isKept: true } : {}),
             ...this.savedBlocks(),
+            ...(this.chatSettings.size ? { chatSettings: Object.fromEntries([...this.chatSettings].filter(([id]) => this.known.has(id))) } : {}),
         };
     }
     /** The blocks worth keeping while the room sleeps: those between players it still remembers. */
@@ -810,6 +875,137 @@ export class RoomCore {
         this.dirty = true;
         this.pairChangeCount++;
     }
+    /** A player's chat settings from their pass, before join: null for a guest, who chats with nobody. */
+    setChatSettings(playerId, settings) {
+        if (settings)
+            this.chatSettings.set(playerId, { whoCanChat: settings.whoCanChat, chatGroupId: settings.chatGroupId });
+        else if (!this.chatSettings.delete(playerId))
+            return;
+        this.dirty = true;
+    }
+    /** Whether a player can chat at all: an account whose setting isn't nobody, with a chat group. */
+    canChat(playerId) {
+        const settings = this.chatSettings.get(playerId);
+        return settings !== undefined && settings.whoCanChat !== "nobody" && settings.chatGroupId !== null;
+    }
+    /**
+     * Whether one player's chat may reach another, canChat's rule on passes (pass.ts): two accounts in the
+     * same chat group with no block either way, friends unless both chat with anyone.
+     */
+    mayChat(senderPlayerId, receiverPlayerId) {
+        if (senderPlayerId === receiverPlayerId || !this.canChat(senderPlayerId) || !this.canChat(receiverPlayerId) || this.hasBlockBetween(senderPlayerId, receiverPlayerId))
+            return false;
+        const sender = this.chatSettings.get(senderPlayerId);
+        const receiver = this.chatSettings.get(receiverPlayerId);
+        if (sender.chatGroupId !== receiver.chatGroupId)
+            return false;
+        return (sender.whoCanChat === "anyone" && receiver.whoCanChat === "anyone") || this.areFriends(senderPlayerId, receiverPlayerId);
+    }
+    /** Who a player's chat may reach: the players in the match (or those of toPlayerIds in it), never spectators, kept only where they may chat. */
+    chatReceivers(senderPlayerId, toPlayerIds) {
+        const asked = toPlayerIds ? [...new Set(toPlayerIds)].filter((id) => this.players.has(id)) : [...this.players.keys()];
+        return asked.filter((id) => this.mayChat(senderPlayerId, id));
+    }
+    /**
+     * A chat message from a player (readChatMessage), checked by the room: the sender, the text, their pace,
+     * then the game server's onChat with the players their game sent it to. When it goes no further the room
+     * answers the sender itself (an error, or chat_stopped with stopped_by_game) and this is null. Otherwise
+     * it's the text, who may read it (chatReceivers, which may be nobody) and the sender's last messages, for
+     * the host to run Zaisma's filter and then deliverChat or stopChat.
+     */
+    async startChat(playerId, chat) {
+        const refuse = (code) => {
+            this.sendText(playerId, errorMessage(code, undefined, { chatNumber: chat.chatNumber }));
+            return null;
+        };
+        // Spectators send nothing, chat included; limited like anyone's messages, so refusing them costs little.
+        if (this.spectators.has(playerId))
+            return refuse(this.ended ? "ended" : this.take(playerId) ? "spectator_cannot_send" : "too_fast");
+        const player = this.players.get(playerId);
+        if (!player || this.ended)
+            return refuse("ended");
+        this.messageCount++;
+        this.countTraffic("inbound", CHAT_MESSAGE_TYPE, 1, chat.sizeBytes);
+        // Counted against the room's 30 a second like any message, then chat's own pace below.
+        if (!this.take(playerId))
+            return refuse("too_fast");
+        const isPlayerIdList = chat.toPlayerIds === undefined || (Array.isArray(chat.toPlayerIds) && chat.toPlayerIds.length <= this.maximumPlayerCount && chat.toPlayerIds.every((id) => typeof id === "string"));
+        if (typeof chat.text !== "string" || !isPlayerIdList)
+            return refuse("bad_message");
+        if (!this.canChat(playerId))
+            return refuse("chat_not_allowed");
+        if (!chat.text.trim())
+            return refuse("chat_empty");
+        if (chat.text.length > CHAT_CHECK_LIMITS.maximumMessageCharacterCount)
+            return refuse("chat_too_long");
+        if (!this.takeChat(playerId))
+            return refuse("chat_too_fast");
+        const presence = this.presence.get(playerId);
+        if (presence)
+            presence.seenAtMs = this.now();
+        const toPlayerIds = (chat.toPlayerIds === undefined ? [...this.players.keys()] : [...new Set(chat.toPlayerIds)]).filter((id) => id !== playerId && this.players.has(id));
+        let askedPlayerIds = toPlayerIds;
+        if (this.server.onChat) {
+            await this.settled();
+            let answer;
+            try {
+                answer = await this.server.onChat(this.state, player, this.chatRoom, { text: chat.text, toPlayerIds: [...toPlayerIds] });
+            }
+            catch (error) {
+                console.error("Game server error:", error);
+                answer = false;
+            }
+            const read = readChatAnswer(answer);
+            if ("mistake" in read)
+                console.error("Game server error:", read.mistake);
+            if ("mistake" in read || !read.isAllowed) {
+                this.stopChat(playerId, chat.chatNumber, "stopped_by_game", STOPPED_BY_GAME_MESSAGE);
+                return null;
+            }
+            if (read.toPlayerIds)
+                askedPlayerIds = toPlayerIds.filter((id) => read.toPlayerIds.includes(id));
+        }
+        const recentTexts = this.recentChatTexts(playerId);
+        this.rememberChat(playerId, chat.text);
+        return { text: chat.text, receiverPlayerIds: this.chatReceivers(playerId, askedPlayerIds), recentTexts };
+    }
+    /**
+     * Send a chat message Zaisma's filter let through to its receivers, and tell the sender it went
+     * (chat_sent), even when it reached nobody: the sender never learns who can't read them.
+     */
+    deliverChat(senderPlayerId, chatNumber, receiverPlayerIds, chat) {
+        const sentAt = new Date(this.now()).toISOString();
+        // Players who left, or blocked the sender, while the filter looked get nothing.
+        const receivers = receiverPlayerIds.filter((id) => this.players.has(id) && this.mayChat(senderPlayerId, id));
+        if (receivers.length)
+            this.sendEach(receivers, JSON.stringify({ type: "chat", fromPlayerId: senderPlayerId, text: chat.text, hasSwearing: chat.hasSwearing, hasSlur: chat.hasSlur, sentAt }), CHAT_MESSAGE_TYPE);
+        this.sendText(senderPlayerId, JSON.stringify({ type: "chat_sent", chatNumber, sentAt }));
+    }
+    /** Tell the sender their chat message was stopped: reason is the filter's, or stopped_by_game; message is what they see. */
+    stopChat(senderPlayerId, chatNumber, reason, message) {
+        this.sendText(senderPlayerId, JSON.stringify({ type: "chat_stopped", chatNumber, reason, message }));
+    }
+    /** A player's chat messages from the last CHAT_CHECK_LIMITS.recentTextDurationMs, oldest first, up to recentTextCount. */
+    recentChatTexts(playerId) {
+        const nowMs = this.now();
+        return (this.recentChats.get(playerId) ?? []).filter((sent) => nowMs - sent.sentAtMs < CHAT_CHECK_LIMITS.recentTextDurationMs).map((sent) => sent.text);
+    }
+    rememberChat(playerId, text) {
+        const nowMs = this.now();
+        const recent = (this.recentChats.get(playerId) ?? []).filter((sent) => nowMs - sent.sentAtMs < CHAT_CHECK_LIMITS.recentTextDurationMs);
+        recent.push({ text, sentAtMs: nowMs });
+        this.recentChats.set(playerId, recent.slice(-CHAT_CHECK_LIMITS.recentTextCount));
+    }
+    /** Whether a player may send another chat message: CHAT_ROOM_LIMITS.maximumChatMessageCount in any chatWindowDurationMs. */
+    takeChat(playerId) {
+        const nowMs = this.now();
+        const sentAtMs = (this.chatSentAtMs.get(playerId) ?? []).filter((atMs) => nowMs - atMs < CHAT_ROOM_LIMITS.chatWindowDurationMs);
+        const isTaken = sentAtMs.length < CHAT_ROOM_LIMITS.maximumChatMessageCount;
+        if (isTaken)
+            sentAtMs.push(nowMs);
+        this.chatSentAtMs.set(playerId, sentAtMs);
+        return isTaken;
+    }
     /** Whether two players have a block between them, either way: from their accounts, or one a player's game said it made. */
     hasBlockBetween(firstPlayerId, secondPlayerId) {
         if (firstPlayerId === secondPlayerId)
@@ -1133,7 +1329,7 @@ export class RoomCore {
         this.remember(player.id);
         this.presence.set(player.id, newPresence(this.now(), joinOptions.clientIdle === undefined ? (this.presence.get(player.id)?.clientIdle ?? {}) : clientIdle(joinOptions.clientIdle)));
         const probeIntervalSec = this.ticking ? ROOM_TUNING.probeIntervalSec : null;
-        this.sendText(player.id, JSON.stringify({ type: "welcome", me: shownPlayer(player), isSpectator: false, players: this.list(), room: this.settings(), spectatorCount: this.spectators.size, hostPlayerId: this.hostPlayerId, awayChecks: this.checks(player.id), endsAt: this.endsAt, probeIntervalSec, protocolVersionNumber: PROTOCOL_VERSION_NUMBER }));
+        this.sendText(player.id, JSON.stringify({ type: "welcome", me: shownPlayer(player), isSpectator: false, players: this.list(), room: this.settings(), spectatorCount: this.spectators.size, hostPlayerId: this.hostPlayerId, awayChecks: this.checks(player.id), endsAt: this.endsAt, probeIntervalSec, protocolVersionNumber: PROTOCOL_VERSION_NUMBER, canChat: this.canChat(player.id) }));
         // Every room gets a first ping and clock sample right away, ticking or not.
         this.probe(player.id);
         // A new connection starts with nothing of the state: a full copy comes with the next round.
@@ -1172,7 +1368,7 @@ export class RoomCore {
         this.spectators.set(spectator.id, spectator);
         this.presence.set(spectator.id, newPresence(this.now(), {}));
         const probeIntervalSec = this.ticking ? ROOM_TUNING.probeIntervalSec : null;
-        this.sendText(spectator.id, JSON.stringify({ type: "welcome", me: shownPlayer(spectator), isSpectator: true, players: this.list(), room: this.settings(), spectatorCount: this.spectators.size, hostPlayerId: this.hostPlayerId, awayChecks: { idleTimeoutSec: null, hiddenTimeoutSec: null }, endsAt: this.endsAt, probeIntervalSec, protocolVersionNumber: PROTOCOL_VERSION_NUMBER }));
+        this.sendText(spectator.id, JSON.stringify({ type: "welcome", me: shownPlayer(spectator), isSpectator: true, players: this.list(), room: this.settings(), spectatorCount: this.spectators.size, hostPlayerId: this.hostPlayerId, awayChecks: { idleTimeoutSec: null, hiddenTimeoutSec: null }, endsAt: this.endsAt, probeIntervalSec, protocolVersionNumber: PROTOCOL_VERSION_NUMBER, canChat: false }));
         this.probe(spectator.id);
         // A new connection starts with nothing of the state: a full copy comes with the next round.
         if (this.server.stateSyncEnabled) {
@@ -1254,6 +1450,8 @@ export class RoomCore {
     /** Take a player out of the match, forgetting what the room knew about them while they were in. */
     out(playerId) {
         this.players.delete(playerId);
+        this.chatSentAtMs.delete(playerId);
+        this.recentChats.delete(playerId);
         this.latestSlots.delete(playerId);
         this.stateSkippedPlayerIds.delete(playerId);
         this.fullCopyPlayerIds.delete(playerId);
@@ -1482,6 +1680,9 @@ export class RoomCore {
             case "message":
                 this.input(() => this.server.onMessage?.(this.state, player, this.api, message.data), "onMessage");
                 return null;
+            case "chat":
+                // The room's host takes chat before it gets here (readChatMessage); a host that doesn't, doesn't take chat.
+                return "chat_not_here";
             case "zaisma:purchase":
                 this.purchaseTold(playerId, message);
                 return null;