@zaisma/game-server 1.9.0 → 1.11.0

package/bin/local-play.js

@@ -145,6 +145,8 @@ function defaultState() {
     // Each player's guest, while they play as one: { id, name }.
     guests: {},
     friends: [],
+    // Friend requests waiting between bench accounts: { from, to, createdAtMs }.
+    friendRequests: [],
     blocks: [],
     ownedItems: {},
     items: [],
@@ -629,6 +631,8 @@ export async function startLocalPlay(givenOptions) {
     if (rest === "" && method === "DELETE") {
       state.accounts = state.accounts.filter((each) => each.id !== account.id);
       state.friends = state.friends.filter((pair) => !pair.includes(account.id));
+      state.friendRequests = (state.friendRequests ?? []).filter((each) => each.from !== account.id && each.to !== account.id);
+      state.acceptedFriendRequests = (state.acceptedFriendRequests ?? []).filter((each) => each.from !== account.id && each.to !== account.id);
       state.blocks = state.blocks.filter((block) => block.blocker !== account.id && block.blocked !== account.id);
       state.purchases = state.purchases.filter((purchase) => purchase.accountId !== account.id);
       delete state.ownedItems[account.id];
@@ -951,6 +955,67 @@ export async function startLocalPlay(givenOptions) {
       }
       return reply(200, { player: { player_id: target.playerId, name: target.username }, is_friend: friendIdsOf(account.id).includes(target.id), is_blocked: state.blocks.some((block) => block.blocker === account.id && block.blocked === target.id) });
     }
+    // Friend requests between bench accounts, as Zaisma's game page sends and answers them (apps/site/src/friend-requests.ts).
+    if (path === "/friends/requests" || path.startsWith("/friends/requests/")) {
+      if (!account) return reply(401, { error: { code: "not_signed_in", message: "Sign in to add friends." } });
+      const requests = (state.friendRequests ??= []);
+      const isBlockedPair = (other) => state.blocks.some((block) => isPair([block.blocker, block.blocked], account.id, other.id));
+      const isFriend = (other) => friendIdsOf(account.id).includes(other.id);
+      const waitingFrom = (from, to) => requests.find((each) => each.from === from && each.to === to);
+      const makeFriends = (other) => {
+        // The sender hears of the accept on their next look, for a day, as on Zaisma.
+        (state.acceptedFriendRequests ??= []).push({ from: other.id, to: account.id, answeredAtMs: Date.now() });
+        state.friendRequests = requests.filter((each) => !isPair([each.from, each.to], account.id, other.id));
+        if (!isFriend(other)) state.friends.push([account.id, other.id]);
+        saveState();
+        log(`${account.username} and ${other.username} are friends now.`);
+      };
+      if (request.method === "GET" && path === "/friends/requests") {
+        const accepted = (state.acceptedFriendRequests ?? []).filter((each) => each.from === account.id && each.answeredAtMs > Date.now() - 86400000 && isFriend({ id: each.to })).map((each) => ({ to: accountOf(each.to), answeredAtMs: each.answeredAtMs })).filter((each) => each.to);
+        return reply(200, {
+          requests: requests.filter((each) => each.to === account.id).map((each) => ({ from: accountOf(each.from), createdAtMs: each.createdAtMs })).filter((each) => each.from).map((each) => ({ player_id: each.from.playerId, name: each.from.username, created_at_ms: each.createdAtMs, game_slug: gameSlug })).reverse(),
+          accepted: accepted.map((each) => ({ player_id: each.to.playerId, name: each.to.username, answered_at_ms: each.answeredAtMs })).reverse(),
+        });
+      }
+      const aboutMatch = /^\/friends\/requests\/about\/(player_[a-z0-9]{1,40})$/.exec(path);
+      if (request.method === "GET" && aboutMatch) {
+        const other = accountOfPlayer(aboutMatch[1]);
+        if (!other || other.id === account.id) return reply(200, { player: null, can_send: false, has_sent: false, is_friend: false });
+        const hasSent = Boolean(waitingFrom(account.id, other.id));
+        const canSend = !isFriend(other) && !hasSent && !isBlockedPair(other) && other.ageBand === account.ageBand && (Boolean(waitingFrom(other.id, account.id)) || glass.takesFriendRequests(other.ageBand, other.socialMode));
+        return reply(200, { player: { player_id: other.playerId, name: other.username }, can_send: canSend, has_sent: hasSent, is_friend: isFriend(other) });
+      }
+      if (isPost && path === "/friends/requests") {
+        const body = await readJson(request);
+        const other = typeof body.player_id === "string" ? accountOfPlayer(body.player_id) : null;
+        if (!other || other.id === account.id) return reply(409, { error: { code: "not_an_account", message: "Only players signed in to Zaisma take friend requests." } });
+        if (isFriend(other)) return reply(409, { error: { code: "already_friends", message: "You're friends already." } });
+        if (waitingFrom(other.id, account.id)) {
+          makeFriends(other);
+          return reply(200, { status: "friends" });
+        }
+        if (waitingFrom(account.id, other.id)) return reply(409, { error: { code: "already_sent", message: "Your request is waiting for them." } });
+        if (isBlockedPair(other) || other.ageBand !== account.ageBand || !glass.takesFriendRequests(other.ageBand, other.socialMode)) return reply(409, { error: { code: "not_taking_requests", message: "They aren't taking friend requests from you." } });
+        requests.push({ from: account.id, to: other.id, createdAtMs: Date.now() });
+        saveState();
+        log(`${account.username} sent ${other.username} a friend request.`);
+        return reply(200, { status: "sent" });
+      }
+      const answerMatch = /^\/friends\/requests\/(player_[a-z0-9]{1,40})\/(accept|turn-down)$/.exec(path);
+      if (isPost && answerMatch) {
+        await readText(request);
+        const other = accountOfPlayer(answerMatch[1]);
+        if (!other || !waitingFrom(other.id, account.id)) return reply(404, { error: { code: "request_not_found", message: "That request isn't waiting any more." } });
+        if (answerMatch[2] === "accept") makeFriends(other);
+        else {
+          state.friendRequests = requests.filter((each) => !(each.from === other.id && each.to === account.id));
+          saveState();
+          log(`${account.username} turned down ${other.username}'s friend request.`);
+        }
+        return reply(200, { answer: answerMatch[2] === "accept" ? "accepted" : "turned_down" });
+      }
+      return reply(404, { error: { code: "not_found", message: "Nothing here." } });
+    }
     // A report goes to Zaisma's moderators, or the game's developer: here the terminal says what it would send.
     if (isPost && path === `${game}/report`) {
       const body = await readJson(request);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaisma/game-server",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "description": "Run your Zaisma game server: the same rooms on Zaisma or on your own server.",
   "license": "MIT",
   "homepage": "https://zaisma.com",

package/sdk/zaisma.d.ts

@@ -240,8 +240,35 @@ declare namespace Zaisma {
      * await Zaisma.friends.setRoom(null);   // left the match
      */
     setRoom(room: OwnServerRoom | null): Promise<void>;
+    /**
+     * Offer the player to send another player a friend request, from your own scoreboard, lobby or menu.
+     * Zaisma asks the player first on its page ("Send Mia a friend request?", with the name Zaisma knows
+     * them by), so nothing is sent without them, and the other player gets it over their game's corner and
+     * on zaisma.com/friends. Players can also send one from Players in Zaisma's bar, so a button of your
+     * own is optional. Resolves with what happened: "sent"; "cancelled" when the player said no or another
+     * question was up; "already_friends"; or "not_taking_requests" when the other player doesn't take them
+     * from this one (their settings, their age group, a block, or a guest), which never says which. Your game
+     * never hears of requests themselves, only that two players are friends (room.areFriends on your game server, and the
+     * passes' tags, from their next join). Fails with error.code "account_needed" for a guest (ask them to
+     * sign in with {@link player.signIn}), "bad_player_id" for something that isn't a player's id, and
+     * "not_on_zaisma" when the game isn't played on Zaisma.
+     *
+     * @example
+     * // A button beside each player on your end-of-match screen.
+     * const { status } = await Zaisma.friends.sendRequest(player.id);
+     * if (status === "sent") button.textContent = "Request sent";
+     */
+    sendRequest(playerId: string): Promise<FriendRequestAnswer>;
   }
 
+  /** What became of a friend request the game offered ({@link Friends.sendRequest}). */
+  interface FriendRequestAnswer {
+    status: FriendRequestStatus;
+  }
+
+  /** "sent", "cancelled" (the player said no), "already_friends", or "not_taking_requests" (never why). */
+  type FriendRequestStatus = "sent" | "cancelled" | "already_friends" | "not_taking_requests";
+
   /** The player's friends playing this game ({@link Friends.list}). */
   interface FriendList {
     /** By name. Empty when none of them are playing it. */
@@ -539,6 +566,32 @@ declare namespace Zaisma {
    */
   const versions: Versions;
 
+  /**
+   * Whether Zaisma's page covers the game right now, so a game can pause or hold the player's input while it does.
+   * coveredBy is "sheet" while one of Zaisma's sheets is open over the game (buying, Players, Report: the player is
+   * busy with it), "card" while one of its cards is over the game's corner (Still there?, Keep your progress; the
+   * game stays in view and playable), and null otherwise. Always null outside Zaisma's page (your own site, a
+   * local test). Listen for "coveredBy" to hear each change.
+   * @example
+   * Zaisma.page.on("coveredBy", (coveredBy) => {
+   *   if (coveredBy === "sheet") pauseGame();
+   *   else resumeGame();
+   * });
+   */
+  const page: Page;
+
+  /** Whether Zaisma's page covers the game ({@link page}). */
+  interface Page {
+    /** "sheet", "card" or null: what of Zaisma's is over the game now. Read-only. */
+    readonly coveredBy: CoveredBy;
+    /** Listen for "coveredBy": called with the new value each time it changes. A wrong name fails with error.code "unknown_event". */
+    on(event: "coveredBy", listener: (coveredBy: CoveredBy) => void): Page;
+    off(event: "coveredBy", listener: (coveredBy: CoveredBy) => void): Page;
+  }
+
+  /** What of Zaisma's covers the game ({@link page}): one of its sheets, one of its cards, or nothing. */
+  type CoveredBy = "sheet" | "card" | null;
+
   /** A version published "now" ({@link versions}). */
   interface Versions {
     /** Listen for "update". A wrong name fails with error.code "unknown_event". */

package/sdk/zaisma.js

@@ -37,6 +37,7 @@
   var SAVES_EVENTS = ["conflict", "developerChange"];
   var ITEMS_EVENTS = ["purchase", "refund", "sheetOpen", "sheetClose"];
   var VERSIONS_EVENTS = ["update"];
+  var PAGE_EVENTS = ["coveredBy"];
   var BUY_OPTIONS = ["itemCount", "gameAccountId"];
   /** The room messages this SDK speaks (zaisma.d.ts: the wire protocol), sent in the hello. */
   var PROTOCOL_VERSION_NUMBER = 1;
@@ -617,6 +618,9 @@
       } else if (message.type === "blocks") {
         room._blocks = new Set(Array.isArray(message.playerIds) ? message.playerIds : []);
         room._mutedChanged();
+      } else if (message.type === "friend_request") {
+        // Someone here sent this player a friend request, or accepted theirs: the Zaisma page looks now (never who).
+        if (onZaismaPage()) window.parent.postMessage({ type: "zaisma:friend-requests" }, config.site);
       } else if (message.type === "message") {
         room._emit("message", message.data, typeof message.fromPlayerId === "string" ? message.fromPlayerId : null);
       } else if (message.type === "chat" || message.type === "chat_sent" || message.type === "chat_stopped" || (message.type === "error" && typeof message.chatNumber === "number")) {
@@ -2020,6 +2024,34 @@
     });
   }
 
+  /*
+   * Whether Zaisma's page covers the game: "sheet" while one of its sheets is open over it (buying, Players, Report), "card" while one of
+   * its cards is over the game's corner, null otherwise, and always null outside Zaisma's page. The page says so whenever it changes
+   * (zaisma:covered), and only the page is heard. A game can pause while a sheet covers it.
+   */
+  var pageEvents = new Emitter(PAGE_EVENTS, "Zaisma.page has");
+  var coveredBy = null;
+  var zaismaPage = {
+    on: function (event, listener) {
+      pageEvents.on(event, listener);
+      return zaismaPage;
+    },
+    off: function (event, listener) {
+      pageEvents.off(event, listener);
+      return zaismaPage;
+    },
+  };
+  Object.defineProperty(zaismaPage, "coveredBy", { enumerable: true, get: function () { return coveredBy; } });
+  if (config.site && window.parent !== window) {
+    window.addEventListener("message", function (event) {
+      if (event.origin !== config.site || event.source !== window.parent || !event.data || event.data.type !== "zaisma:covered") return;
+      var now = event.data.coveredBy === "sheet" || event.data.coveredBy === "card" ? event.data.coveredBy : null;
+      if (now === coveredBy) return;
+      coveredBy = now;
+      pageEvents._emit("coveredBy", now);
+    });
+  }
+
   /*
    * The player's cloud saves, for games that draw their own save screens. The game page on Zaisma holds
    * the player's session and answers (apps/site/src/saves-client.ts); the game never talks to a server.
@@ -2457,6 +2489,51 @@
   }
 
   var rooms = { list: listRooms, quickJoin: quickJoin, linkedRoomCode: roomCodeFromPage(), linkedServerUrl: roomCodeFromPage() ? serverUrlFromPage() : null, isLinkedAsSpectator: watchFromPage() };
-  var friends = { list: listFriends, setRoom: setOwnRoom };
-  window.Zaisma = { sdkVersionNumber: 1, gameSlug: config.game || null, player: player, joinRoom: joinRoom, rooms: rooms, server: server, invite: invite, checkChat: checkChat, openPlayersPanel: openPlayersPanel, links: links, items: items, friends: friends, saves: saves, versions: versions };
+  /*
+   * Friend requests (zaisma.d.ts: Friends.sendRequest): the Zaisma page asks the player before anything is
+   * sent, with the name Zaisma knows the other player by, so no game sends one on a player's behalf. Once one
+   * is sent, from here or the page's Players, the rooms the other player is in tell their game to have their
+   * page look now; Zaisma's record is the request itself.
+   */
+  var friendRequestAsk = null;
+  var FRIEND_REQUEST_STATUSES = ["sent", "cancelled", "already_friends", "not_taking_requests"];
+  function sendFriendRequest(playerId) {
+    if (!onZaismaPage() || !config.rooms) return Promise.reject(notOnZaisma("Friend requests come from Zaisma, so they work only in games played on Zaisma."));
+    if (typeof playerId !== "string" || !/^player_[a-z0-9]{1,40}$/.test(playerId)) return Promise.reject(codedError("bad_player_id", "Zaisma.friends.sendRequest takes a player's id from room.players or Zaisma.friends.list."));
+    return getPass().then(function (mine) {
+      if (mine.kind !== "account") throw codedError("account_needed", "Friend requests are for players signed in to Zaisma: ask the player to sign in first (Zaisma.player.signIn).");
+      // One question at a time: another request while the page is asking is a no.
+      if (friendRequestAsk) return { status: "cancelled" };
+      friendRequestAsk = new Promise(function (resolve) {
+        var isAsking = false;
+        var timer = setTimeout(function () { if (!isAsking) settle("cancelled"); }, 3000);
+        function settle(status) {
+          removeEventListener("message", onMessage);
+          clearTimeout(timer);
+          friendRequestAsk = null;
+          resolve({ status: status });
+        }
+        function onMessage(event) {
+          var told = event.data;
+          if (event.origin !== config.site || event.source !== window.parent || !told || told.type !== "zaisma:friend-request" || told.playerId !== playerId) return;
+          if (told.status === "asking") isAsking = true;
+          else if (FRIEND_REQUEST_STATUSES.indexOf(told.status) !== -1) settle(told.status);
+        }
+        addEventListener("message", onMessage);
+        window.parent.postMessage({ type: "zaisma:friend-request", playerId: playerId }, config.site);
+      });
+      return friendRequestAsk;
+    });
+  }
+  // A request sent (by the game's own button or the page's Players), or one accepted: the rooms the other player is in nudge their game.
+  window.addEventListener("message", function (event) {
+    var told = event.data;
+    if (!config.site || event.origin !== config.site || event.source !== window.parent || !told || told.type !== "zaisma:friend-request" || (told.status !== "sent" && told.status !== "accepted") || typeof told.playerId !== "string") return;
+    joined.forEach(function (room) {
+      if (!room._done && !room.isSpectator && room.players.some(function (each) { return each.id === told.playerId; })) room._say({ type: "friend_request", playerId: told.playerId });
+    });
+  });
+
+  var friends = { list: listFriends, setRoom: setOwnRoom, sendRequest: sendFriendRequest };
+  window.Zaisma = { sdkVersionNumber: 1, gameSlug: config.game || null, player: player, joinRoom: joinRoom, rooms: rooms, server: server, invite: invite, checkChat: checkChat, openPlayersPanel: openPlayersPanel, links: links, items: items, friends: friends, saves: saves, versions: versions, page: zaismaPage };
 })();

package/src/qr-code.d.ts

@@ -1,13 +1,14 @@
 /**
  * QR codes for game and room links (docs/DECISIONS.md, "QR codes"): players get one behind Share,
- * developers on the dashboard and through the API and MCP. Byte mode, error correction level M,
- * versions 1 to 10 (up to 213 bytes, far more than a link needs). Written here rather than taken from a
+ * developers on the dashboard and through the API and MCP. Byte mode, error correction level H, so a
+ * small picture over its middle (a game's icon) still leaves it readable, versions 1 to 10 (up to 119
+ * bytes, far more than a link needs). Written here rather than taken from a
  * package so the site's page and the API draw the same code with no dependency; it follows ISO/IEC
  * 18004 the way Project Nayuki's reference encoder does.
  */
 export declare const QR_CODE_LIMITS: {
-    /** Version 10 at level M holds 213 bytes. */
-    readonly maximumTextBytes: 213;
+    /** Version 10 at level H holds 119 bytes. */
+    readonly maximumTextBytes: 119;
     /** Light modules around the code, as the standard asks. */
     readonly quietZoneModuleCount: 4;
 };

package/src/qr-code.js

@@ -1,21 +1,22 @@
 /**
  * QR codes for game and room links (docs/DECISIONS.md, "QR codes"): players get one behind Share,
- * developers on the dashboard and through the API and MCP. Byte mode, error correction level M,
- * versions 1 to 10 (up to 213 bytes, far more than a link needs). Written here rather than taken from a
+ * developers on the dashboard and through the API and MCP. Byte mode, error correction level H, so a
+ * small picture over its middle (a game's icon) still leaves it readable, versions 1 to 10 (up to 119
+ * bytes, far more than a link needs). Written here rather than taken from a
  * package so the site's page and the API draw the same code with no dependency; it follows ISO/IEC
  * 18004 the way Project Nayuki's reference encoder does.
  */
 export const QR_CODE_LIMITS = {
-    /** Version 10 at level M holds 213 bytes. */
-    maximumTextBytes: 213,
+    /** Version 10 at level H holds 119 bytes. */
+    maximumTextBytes: 119,
     /** Light modules around the code, as the standard asks. */
     quietZoneModuleCount: 4,
 };
-// Level M: error correction codewords per block and blocks, by version (index 0 unused).
-const ERROR_CORRECTION_CODEWORD_COUNTS_PER_BLOCK = [0, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26];
-const ERROR_CORRECTION_BLOCK_COUNTS = [0, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5];
-/** Error correction level M (medium)'s two bits in the format information. */
-const MEDIUM_CORRECTION_FORMAT_NUMBER = 0;
+// Level H: error correction codewords per block and blocks, by version (index 0 unused).
+const ERROR_CORRECTION_CODEWORD_COUNTS_PER_BLOCK = [0, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28];
+const ERROR_CORRECTION_BLOCK_COUNTS = [0, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8];
+/** Error correction level H (high)'s two bits in the format information. */
+const HIGH_CORRECTION_FORMAT_NUMBER = 2;
 const HIGHEST_VERSION_NUMBER = 10;
 const isBitSet = (bitsNumber, bitIndex) => ((bitsNumber >>> bitIndex) & 1) !== 0;
 function rawDataModuleCount(versionNumber) {
@@ -226,7 +227,7 @@ export function qrCodeModules(text) {
         }
     }));
     const drawFormat = (maskIndex) => {
-        const formatNumber = (MEDIUM_CORRECTION_FORMAT_NUMBER << 3) | maskIndex;
+        const formatNumber = (HIGH_CORRECTION_FORMAT_NUMBER << 3) | maskIndex;
         let remainderNumber = formatNumber;
         for (let stepIndex = 0; stepIndex < 10; stepIndex++)
             remainderNumber = (remainderNumber << 1) ^ ((remainderNumber >>> 9) * 0x537);

package/src/room.d.ts

@@ -892,6 +892,8 @@ export type ServerMessage = {
 } | {
     type: "blocks";
     playerIds: string[];
+} | {
+    type: "friend_request";
 } | {
     type: "chat";
     fromPlayerId: string;
@@ -959,6 +961,9 @@ export type ClientMessage = {
 } | {
     type: "unblock";
     playerId: string;
+} | {
+    type: "friend_request";
+    playerId: string;
 } | {
     type: "probe_answer";
     probeNumber: number;
@@ -1427,6 +1432,12 @@ export declare class RoomCore<S = any> {
     private tellBlocks;
     /** A player's game blocked a player in the room (a guest's block, or one just made), or took one back. */
     private sessionBlock;
+    /**
+     * A player's game page just sent another player here a friend request, or accepted theirs (docs/DECISIONS.md,
+     * "Friend requests in games"): the room tells that player's game to have their page look now, rather than at its next check-in.
+     * Zaisma's record is the request; this says only "look", never who it's from, so a lying client gains nothing.
+     */
+    private friendRequestTold;
     /** Players in the match who haven't walked away: what room lists and "playing now" count. */
     get playingCount(): number;
     /**

package/src/room.js

@@ -1071,6 +1071,20 @@ export class RoomCore {
         this.tellBlocks();
         return null;
     }
+    /**
+     * A player's game page just sent another player here a friend request, or accepted theirs (docs/DECISIONS.md,
+     * "Friend requests in games"): the room tells that player's game to have their page look now, rather than at its next check-in.
+     * Zaisma's record is the request; this says only "look", never who it's from, so a lying client gains nothing.
+     */
+    friendRequestTold(playerId, message) {
+        const otherPlayerId = message.playerId;
+        if (typeof otherPlayerId !== "string" || otherPlayerId === playerId || !this.players.has(otherPlayerId))
+            return "bad_message";
+        if (this.hasBlockBetween(playerId, otherPlayerId))
+            return null;
+        this.sendText(otherPlayerId, JSON.stringify({ type: "friend_request" }));
+        return null;
+    }
     /** Players in the match who haven't walked away: what room lists and "playing now" count. */
     get playingCount() {
         return this.players.size - this.kept.size;
@@ -1691,6 +1705,8 @@ export class RoomCore {
                 return this.sessionBlock(playerId, message, true);
             case "unblock":
                 return this.sessionBlock(playerId, message, false);
+            case "friend_request":
+                return this.friendRequestTold(playerId, message);
             default:
                 // A type this room doesn't know, maybe from a newer SDK: counted and limited above, then ignored.
                 return typeof message.type === "string" ? null : "bad_message";