@mpgd/cli 0.64.0 → 0.65.0

package/templates/phaser-game/src/platform/sessionGatedServices.ts

@@ -1,20 +1,22 @@
-import type {
-  GameServicesClient,
-  GameServicesPurchaseResult,
-  GameServicesRewardedAdResult,
-  GameServicesRuntime,
+import {
+  gameServicesPlayerChangedCode,
+  gameServicesRuntimeDisposedCode,
+  type GameServicesClient,
+  type GameServicesPurchaseResult,
+  type GameServicesRewardedAdResult,
+  type GameServicesRuntime,
 } from '@mpgd/game-services';
 
 /** The diagnostic of a purchase refused because the run is not signed in yet (retryable). */
 export const starterSessionRequiredCode = 'STARTER_SESSION_REQUIRED';
 
-function sessionRequiredPurchase(): GameServicesPurchaseResult {
+function refusedPurchase(code: string): GameServicesPurchaseResult {
   return {
     status: 'failed',
     purchase: {
       status: 'failed',
       entitlementIds: [],
-      diagnostic: { code: starterSessionRequiredCode, retryable: true },
+      diagnostic: { code, retryable: true },
     },
   };
 }
@@ -25,11 +27,16 @@ function sessionRequiredReward(): GameServicesRewardedAdResult {
 
 /** A purchase, restore, or reward claim was asked for before the guest sign-in succeeded. */
 export class StarterSessionRequiredError extends Error {
-  readonly code = 'STARTER_SESSION_REQUIRED';
+  readonly code: string;
 
-  constructor() {
-    super('The game is not signed in to its identity service yet; try again when it is online.');
+  constructor(code: string = starterSessionRequiredCode) {
+    super(
+      code === starterSessionRequiredCode
+        ? 'The game is not signed in to its identity service yet; try again when it is online.'
+        : 'Another player signed in; the game restarts for that player.',
+    );
     this.name = 'StarterSessionRequiredError';
+    this.code = code;
   }
 }
 
@@ -69,8 +76,14 @@ export type StarterSessionGatedServices = GameServicesRuntime & {
  *   runtime binds its late reward evidence recovery at boot.
  * - When the player becomes known, the services are created once; the
  *   caller runs the game runtime's `reconcile()` from `onActivated` (the
- *   startup recovery, with the action coordinator's). A later sign-in naming another player
- *   (not expected within one run) is ignored with a warning.
+ *   startup recovery, with the action coordinator's). A later sign-in naming
+ *   another player (not expected within one run) closes them for good, as
+ *   the services' own session check does: purchases answer `failed` with the
+ *   retryable diagnostic `GAME_SERVICES_PLAYER_CHANGED`, recovery and Delete
+ *   account go away, and `onPlayerChanged` asks the host to boot again for
+ *   that player once the old services stopped. They are never re-created
+ *   for the new player inside this run: the scenes, the action coordinator,
+ *   and the notifications still hold the boot player.
  * - `accountDeletion` is `undefined` until then, and the services' after
  *   (read live); `onReady` tells Delete account to appear then.
  * - `ensureSession` is present only when the configuration has a client
@@ -90,19 +103,39 @@ export function createSessionGatedGameServices(input: {
    * one a purchase or restore started): run the game runtime's `reconcile()`.
    */
   readonly onActivated?: () => void;
+  /** Called at once when a later sign-in names another player: block input or show a switching screen. */
+  readonly onPlayerChanging?: (playerId: string) => void;
+  /** Called once, after a sign-in named another player closed the services: boot again for it. */
+  readonly onPlayerChanged?: (playerId: string) => void;
   readonly warn?: (message: string, error?: unknown) => void;
 }): StarterSessionGatedServices {
   const warn = input.warn ?? ((message: string, error?: unknown) => console.warn(message, error ?? ''));
   let inner: GameServicesRuntime | undefined;
   let innerPlayer: string | undefined;
+  /** Set once another player signed in, or the services were disposed: nothing comes up again. */
+  let closedCode: string | undefined;
   const readyListeners = new Set<() => void>();
+  /** The services the scenes may use now: none once closed. */
+  const live = (): GameServicesRuntime | undefined => (closedCode === undefined
+    ? inner
+    : undefined);
 
   const activate = (playerId: string): void => {
+    if (closedCode !== undefined) {
+      return;
+    }
     if (inner !== undefined) {
       if (playerId !== innerPlayer) {
+        closedCode = gameServicesPlayerChangedCode;
+        readyListeners.clear();
         warn(
-          '[game-services] a later sign-in named another player; the services keep the first until restart.',
+          '[game-services] a later sign-in named another player; the services closed until restart.',
         );
+        notifyChanging(input.onPlayerChanging, playerId, warn);
+        // Fail closed first; the host restarts once the old reconciler has stopped.
+        void inner.dispose().catch((error: unknown) => {
+          warn('[game-services] the services could not be closed cleanly', error);
+        }).finally(() => input.onPlayerChanged?.(playerId));
       }
       return;
     }
@@ -132,16 +165,17 @@ export function createSessionGatedGameServices(input: {
   input.onPlayer(activate);
 
   const ready = async (): Promise<GameServicesRuntime> => {
-    if (inner === undefined) {
+    if (inner === undefined && closedCode === undefined) {
       const playerId = await input.ensurePlayer();
       if (playerId !== undefined) {
         activate(playerId);
       }
     }
-    if (inner === undefined) {
-      throw new StarterSessionRequiredError();
+    const services = live();
+    if (services === undefined) {
+      throw new StarterSessionRequiredError(closedCode);
     }
-    return inner;
+    return services;
   };
   const readyClientOrUndefined = async (): Promise<GameServicesClient | undefined> => {
     try {
@@ -166,7 +200,9 @@ export function createSessionGatedGameServices(input: {
     client = {
       purchase: async (purchase, options) => {
         const ready = await readyClientOrUndefined();
-        return ready === undefined ? sessionRequiredPurchase() : ready.purchase(purchase, options);
+        return ready === undefined
+          ? refusedPurchase(closedCode ?? starterSessionRequiredCode)
+          : ready.purchase(purchase, options);
       },
       claimRewardedAd: async (reward, options) => {
         const ready = await readyClientOrUndefined();
@@ -177,7 +213,7 @@ export function createSessionGatedGameServices(input: {
     // Read live: the reconciler of the services created after sign-in.
     Object.defineProperty(client, 'commerceReconciler', {
       enumerable: true,
-      get: () => inner?.client?.commerceReconciler,
+      get: () => live()?.client?.commerceReconciler,
     });
   }
 
@@ -205,13 +241,105 @@ export function createSessionGatedGameServices(input: {
             }
           },
         }),
+    async dispose() {
+      closedCode ??= gameServicesRuntimeDisposedCode;
+      readyListeners.clear();
+      await inner?.dispose();
+    },
   } as StarterSessionGatedServices;
   // Read live: `undefined` until the player is known, so rewarded ads stay off until then,
   // and Delete account appears once there is an account (the lobby's next visit).
   Object.defineProperties(services, {
     mode: { enumerable: true, get: () => inner?.mode ?? input.probe.mode },
-    monetizationRecovery: { enumerable: true, get: () => inner?.monetizationRecovery },
-    accountDeletion: { enumerable: true, get: () => inner?.accountDeletion },
+    monetizationRecovery: { enumerable: true, get: () => live()?.monetizationRecovery },
+    accountDeletion: { enumerable: true, get: () => live()?.accountDeletion },
   });
   return services;
 }
+
+/**
+ * Closes `services` once the server session names another player than
+ * `playerId` (an account switch within the run): `onPlayerChanging` hears it
+ * at once (the runtime's own `sessionPlayerId` check already refuses every
+ * request from that moment; block input or show a switching screen), then
+ * the services are disposed (an open store sheet first journals its answer)
+ * and `onPlayerChanged` asks the host to restart for that player. Services
+ * created for another player than the session's current one stay closed,
+ * which `warn` reports. `onDisposed` runs once, after the services were
+ * disposed either way (the store binding pin is released there).
+ * `dispose()` also stops watching.
+ */
+export function bindStarterServicesToPlayer(input: {
+  readonly services: GameServicesRuntime;
+  readonly playerId: string;
+  readonly session: {
+    current(): { readonly playerId: string } | undefined;
+    onAuthenticated(listener: (session: { readonly playerId: string }) => void): () => void;
+  };
+  readonly onPlayerChanging?: (playerId: string) => void;
+  readonly onPlayerChanged?: (playerId: string) => void;
+  readonly onDisposed?: () => void;
+  readonly warn?: (message: string, error?: unknown) => void;
+}): GameServicesRuntime {
+  const warn = input.warn ?? ((message: string, error?: unknown) => console.warn(message, error ?? ''));
+  const { services } = input;
+  const current = input.session.current()?.playerId;
+  const createdForAnother = current !== undefined && current !== input.playerId;
+  let closing: Promise<void> | undefined;
+  const close = (): Promise<void> => {
+    closing ??= services.dispose().catch((error: unknown) => {
+      warn('[game-services] the services could not be closed cleanly', error);
+    }).finally(() => input.onDisposed?.());
+    return closing;
+  };
+  let changed = false;
+  /** The unsubscribe, once `onAuthenticated` returned it. */
+  const watching: { stop?: () => void } = {};
+  const onSession = (next: { readonly playerId: string }): void => {
+    if (changed || next.playerId === input.playerId) {
+      return;
+    }
+    changed = true;
+    watching.stop?.();
+    notifyChanging(input.onPlayerChanging, next.playerId, warn);
+    void close().finally(() => input.onPlayerChanged?.(next.playerId));
+  };
+  if (createdForAnother) {
+    // Created for another player than the session's (a local placeholder):
+    // closed at once and the pin released, so services for the session's
+    // player can be created. No restart: the host that created these would
+    // create them the same way again.
+    changed = true;
+    warn(
+      "[game-services] created for a player that is not the server session's; they are closed. "
+        + "Create them with the session's player.",
+    );
+    void close();
+  } else {
+    watching.stop = input.session.onAuthenticated(onSession);
+    if (changed) {
+      // The session announced another player while subscribing.
+      watching.stop();
+    }
+  }
+  return {
+    ...services,
+    async dispose() {
+      watching.stop?.();
+      await close();
+    },
+  };
+}
+
+/** Tells the host at once that another player signed in; a throwing callback is only reported. */
+function notifyChanging(
+  callback: ((playerId: string) => void) | undefined,
+  playerId: string,
+  warn: (message: string, error?: unknown) => void,
+): void {
+  try {
+    callback?.(playerId);
+  } catch (error) {
+    warn('[game-services] the player change callback failed', error);
+  }
+}

package/templates/phaser-game/src/styles.css

@@ -61,3 +61,15 @@ canvas {
   font-size: 16px;
   line-height: 1.5;
 }
+
+.player-switch {
+  position: fixed;
+  inset: 0;
+  z-index: 1000;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: rgb(0 0 0 / 70%);
+  color: #f8fafc;
+  font-size: 18px;
+}