@pretty-chitty/core 1.1.1

package/src/library/game/TurnState.ts

@@ -0,0 +1,187 @@
+import { MismatchError } from "./Turn";
+
+export type DecisionType = "prompt" | "rng" | "turn";
+
+export type PromptResponse = {
+  readonly type: "prompt";
+  response?: any;
+  timestamp: Date;
+};
+
+export type RngResponse = { readonly type: "rng"; value: number };
+
+export type Decision = PromptResponse | RngResponse | TurnState;
+
+export class TurnState {
+  readonly type = "turn";
+  id = "root";
+  playerId?: string;
+  createdDate = Date.now();
+
+  decisions: Decision[] = [];
+
+  private parentTurnState: TurnState | undefined;
+  private parentTurnIndex = 0;
+
+  toJSON() {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { parentTurnIndex, parentTurnState, ...rest } = this;
+    return rest;
+  }
+
+  public getOrCreatePromptResponse(index: number): PromptResponse {
+    if (index < this.decisions.length) {
+      const result = this.decisions[index];
+      if (result.type !== "prompt") {
+        throw new MismatchError();
+      }
+      return result as PromptResponse;
+    } else if (index === this.decisions.length) {
+      this.decisions.push({
+        type: "prompt",
+        timestamp: new Date(),
+      });
+      return this.decisions[this.decisions.length - 1] as PromptResponse;
+    } else {
+      throw new MismatchError();
+    }
+  }
+  public setOrCreatePromptResponse(index: number, response: PromptResponse): void {
+    if (index < this.decisions.length) {
+      const result = this.decisions[index];
+      if (result.type !== "prompt") {
+        throw new MismatchError();
+      }
+      this.decisions[index] = response;
+    } else if (index === this.decisions.length) {
+      this.decisions.push(response);
+    } else {
+      throw new MismatchError();
+    }
+  }
+
+  public getOrCreateRng(index: number): number {
+    if (index < this.decisions.length) {
+      const result = this.decisions[index];
+      if (result.type !== "rng") {
+        throw new MismatchError();
+      }
+      return (result as RngResponse).value;
+    } else if (index === this.decisions.length) {
+      const rng = Math.random();
+      this.decisions.push({
+        type: "rng",
+        value: rng,
+      });
+      return rng;
+    } else {
+      throw new MismatchError();
+    }
+  }
+
+  public getOrCreateTurnState(index: number): TurnState {
+    if (index < this.decisions.length) {
+      const result = this.decisions[index];
+      if (result.type !== "turn") {
+        throw new MismatchError();
+      }
+      return result as TurnState;
+    } else if (index === this.decisions.length) {
+      const result = new TurnState();
+      result.parentTurnState = this;
+      result.parentTurnIndex = index;
+      this.decisions.push(result);
+      return result;
+    } else {
+      throw new MismatchError();
+    }
+  }
+
+  public deserialize(serialized: any) {
+    this.playerId = serialized.playerId;
+    this.id = serialized.id;
+    this.createdDate = serialized.createdDate ?? Date.now();
+    this.decisions = (serialized.decisions ?? []).map((d: Decision, i: number) => {
+      if (d.type === "turn") {
+        const existing = this.decisions[i];
+        if (existing?.type === "turn") {
+          existing.deserialize(d);
+        } else {
+          const r = new TurnState();
+          r.parentTurnState = this;
+          r.parentTurnIndex = i;
+          r.deserialize(d);
+          return r;
+        }
+      }
+      return d;
+    });
+  }
+
+  public hasUserMadeChoiceSinceUserContextChangedOrRng(index: number): boolean {
+    if (index < 0 && this.parentTurnState && this.parentTurnState.playerId === this.playerId) {
+      return this.parentTurnState.hasUserMadeChoiceSinceUserContextChangedOrRng(this.parentTurnIndex);
+    }
+
+    for (let i = index; i >= 0; i--) {
+      const lastDecision = this.decisions[i];
+      if (!lastDecision) {
+        continue;
+      } else if (lastDecision.type === "rng") {
+        return false;
+      } else if (lastDecision.type === "prompt") {
+        return true;
+      } else if (lastDecision.type === "turn") {
+        const subTurn = lastDecision as TurnState;
+        if (subTurn.decisions.length === 0) {
+          continue;
+        }
+
+        if (subTurn.playerId === this.playerId) {
+          return subTurn.hasUserMadeChoiceSinceUserContextChangedOrRng(subTurn.decisions.length - 1);
+        }
+        return false;
+      }
+    }
+    return false;
+  }
+
+  public stepBack() {
+    if (!this.hasUserMadeChoiceSinceUserContextChangedOrRng(this.decisions.length)) {
+      // should be -1? does it matter?
+      throw new Error("Cannot step back");
+    }
+
+    const lastDecision = this.decisions[this.decisions.length - 1];
+    if (!lastDecision) {
+      throw new Error("Cannot step back - no decisions");
+    }
+
+    if (lastDecision.type === "turn") {
+      lastDecision.stepBack();
+      if (lastDecision.decisions.length > 0) {
+        return;
+      }
+    }
+
+    this.decisions.pop();
+  }
+
+  public fullStepBack() {
+    while (this.hasUserMadeChoiceSinceUserContextChangedOrRng(this.decisions.length)) {
+      const lastDecision = this.decisions[this.decisions.length - 1];
+      if (!lastDecision) {
+        throw new Error("Cannot step back - no decisions");
+      }
+
+      if (lastDecision.type === "turn") {
+        lastDecision.stepBack();
+        if (lastDecision.decisions.length > 0) {
+          return;
+        }
+      }
+
+      this.decisions.pop();
+    }
+  }
+}

package/src/library/game/clientTransport/ClientPrompts.ts

@@ -0,0 +1,102 @@
+import { EventChannel } from "../../utilities/EventChannel";
+import { ClockDetails, samePasses } from "../ClockDetails";
+import { Connection } from "../Connection";
+import { ConnectionObject } from "../ConnectionObject";
+import { PlayerChit } from "../PlayerChit";
+import { Prompt, PromptSerialization } from "../Prompt";
+import { RootChit } from "../RootChit";
+import { ServerPrompts } from "../serverTransport/ServerPrompts";
+import { ClientTime } from "./ClientTime";
+
+export class ClientPrompts<P extends PlayerChit, R extends RootChit<P>> extends ConnectionObject {
+  private waitingPrompts: { [playerId: string]: EventChannel<PromptSerialization | undefined> } = {};
+  private serverPrompts: ServerPrompts<P, R>;
+  public currentPrompt = new EventChannel<Prompt | undefined>(undefined);
+
+  private _currentPromptSpec?: PromptSerialization;
+
+  constructor(
+    private playerId: string,
+    private connection: Connection,
+    private clientTime: ClientTime,
+  ) {
+    super();
+
+    this.serverPrompts = connection.get<ServerPrompts<P, R>>("ServerPrompts");
+    this.register(this.clientTime.currentClock.on(this.checkIfPromptCanBeInflated.bind(this)));
+    this.register(this.clientTime.maxClock.on(this.checkIfPromptCanBeInflated.bind(this)));
+    this.register(this.clientTime.clientTimeState.live.on(this.checkIfPromptCanBeInflated.bind(this)));
+    this.register(this.clientTime.clientTimeState.isWaitingOnAnimations.on(this.checkIfPromptCanBeInflated.bind(this)));
+    this.register(this.clientTime.activeLog.on(this.fixActiveLog.bind(this)));
+    this.register(this.getPromptEventChannelForPlayer(this.playerId).on(this.checkIfPromptCanBeInflated.bind(this)));
+  }
+
+  fixActiveLog() {
+    if (this.currentPrompt.value && this.clientTime.activeLog.value) {
+      this.clientTime.activeLog.value = undefined;
+    }
+  }
+
+  private checkIfPromptCanBeInflated() {
+    const isLive = this.clientTime.clientTimeState.live.value;
+    const currentTime = this.clientTime.currentClock.value.clock;
+    const maxTime = this.clientTime.maxClock.value.clock;
+    const isWaitingOnAnimations = this.clientTime.clientTimeState.isWaitingOnAnimations.value;
+    const promptSpec = this.getPromptEventChannelForPlayer(this.playerId).value;
+
+    if (isLive && promptSpec && promptSpec == this._currentPromptSpec) {
+      // do nothing - we have already inflated our prompt and it is still the correct prompt.  as long as we are "live" there is no
+      // need to deflate it
+    } else if (
+      isLive &&
+      promptSpec &&
+      currentTime === maxTime &&
+      currentTime > 0 &&
+      !isWaitingOnAnimations &&
+      samePasses(this.clientTime.currentClock.value, this.clientTime.maxClock.value)
+    ) {
+      if (this.currentPrompt.value) {
+        this.currentPrompt.value.stageOut();
+      }
+
+      this._currentPromptSpec = promptSpec;
+      const prompt = Prompt.deserialize(promptSpec, this.clientTime.findChit, this.clientTime.game.buttonLibrary);
+      prompt.onResolve(async (success) => {
+        this.fixActiveLog();
+        if (success) {
+          const newPromptSpec = await this.serverPrompts.resolvePrompt(prompt.response);
+          this.getPromptEventChannelForPlayer(this.playerId).value = newPromptSpec ?? undefined;
+        } else if (prompt.shouldStepBack) {
+          this.getPromptEventChannelForPlayer(this.playerId).value = undefined;
+          await this.serverPrompts.stepBackPrompt(prompt.shouldReset ?? false);
+        }
+      });
+      prompt.stageIn();
+
+      this.currentPrompt.value = prompt;
+      this.fixActiveLog();
+    } else {
+      this._currentPromptSpec = undefined;
+      if (this.currentPrompt.value) {
+        this.currentPrompt.value.stageOut();
+      }
+      this.currentPrompt.value = undefined;
+      this.fixActiveLog();
+    }
+  }
+
+  public async setPromptForPlayer(playerId: string, prompt?: PromptSerialization, clockDetails?: ClockDetails) {
+    this.getPromptEventChannelForPlayer(playerId).value = prompt;
+    if (clockDetails) {
+      this.clientTime.newMaxClock(clockDetails);
+    }
+  }
+
+  public getPromptEventChannelForPlayer(playerId: string) {
+    let p = this.waitingPrompts[playerId];
+    if (!p) {
+      p = this.waitingPrompts[playerId] = new EventChannel<PromptSerialization | undefined>(undefined);
+    }
+    return p;
+  }
+}

package/src/library/game/clientTransport/ClientStatus.ts

@@ -0,0 +1,36 @@
+import { EventChannel } from "../../utilities/EventChannel";
+import { Connection } from "../Connection";
+import { ConnectionObject } from "../ConnectionObject";
+import { PlayerChit } from "../PlayerChit";
+import { RootChit } from "../RootChit";
+import { ServerStatus } from "../serverTransport/ServerStatus";
+
+type ClientGameResult = {
+  winnerIds: string[];
+};
+
+export class ClientStatus<P extends PlayerChit, R extends RootChit<P>> extends ConnectionObject {
+  public errorMessage = new EventChannel<string | undefined>(undefined);
+  public matchResult = new EventChannel<ClientGameResult | undefined>(undefined);
+  private serverStatus: ServerStatus<P, R>;
+
+  constructor(private connection: Connection) {
+    super();
+
+    this.serverStatus = connection.get<ServerStatus<P, R>>("ServerStatus");
+  }
+
+  async setErrorMessage(error: string | undefined) {
+    this.errorMessage.value = error;
+  }
+
+  async setMatchResult(winnerIds?: string[]) {
+    if (winnerIds) {
+      this.matchResult.value = {
+        winnerIds: winnerIds,
+      };
+    } else {
+      this.matchResult.value = undefined;
+    }
+  }
+}

package/src/library/game/clientTransport/ClientTime.ts

@@ -0,0 +1,256 @@
+import { SparkChit } from "../SparkChit";
+import { EventChannel } from "../../utilities/EventChannel";
+import { Chit } from "../Chit";
+import { ClientTimeState } from "../ClientTimeState";
+import { ClockDetails, samePasses } from "../ClockDetails";
+import { Connection } from "../Connection";
+import { ConnectionObject } from "../ConnectionObject";
+import { Game } from "../Game";
+import { RootChit } from "../RootChit";
+import { ServerTime } from "../serverTransport/ServerTime";
+import { ClientPrompts } from "./ClientPrompts";
+
+export class ClientTime extends ConnectionObject {
+  private lastSerializedState: { [chitId: string]: string } = {};
+
+  public clientPrompt?: ClientPrompts<any, any>;
+
+  constructor(
+    public connection: Connection,
+    public game: Game<any, any>,
+    public clientTimeState: ClientTimeState,
+  ) {
+    super();
+
+    this.serverTime = this.connection.get<ServerTime<any, any>>("ServerTime");
+
+    this.register(this.clientTimeState.targetClock.on(() => this.processNewTargetClock()));
+    this.register(
+      this.clientTimeState.isWaitingOnAnimations.on((isWaiting) => {
+        if (
+          !isWaiting &&
+          this.clientTimeState.live.value &&
+          this.clientTimeState.targetClock.value < this.maxClock.value.clock
+        ) {
+          this.clientTimeState.targetClock.value++;
+        }
+      }),
+    );
+
+    this.clientTimeState.animationSpeedMultiplier.value =
+      parseFloat(localStorage["animationSpeedMultiplier"] ?? "1") || 1;
+    this.register(
+      this.clientTimeState.animationSpeedMultiplier.on((targetSpeed) => {
+        localStorage["animationSpeedMultiplier"] = targetSpeed;
+      }),
+    );
+
+    this.clientTimeState.skipReplay.value = parseFloat(localStorage["skipReplay"] ?? "0") === 1;
+    this.register(
+      this.clientTimeState.skipReplay.on((skipReplay) => {
+        localStorage["skipReplay"] = skipReplay ? "1" : "0";
+      }),
+    );
+
+    this.clientTimeState.showLog.value = parseFloat(localStorage["showLog"] ?? "0") === 1;
+    this.register(
+      this.clientTimeState.showLog.on((showLog) => {
+        localStorage["showLog"] = showLog ? "1" : "0";
+      }),
+    );
+  }
+
+  public currentClock = new EventChannel<ClockDetails>({ clock: 0, pass: -1 });
+  private chitLookup: { [id: string]: Chit } = {};
+  public maxClock = new EventChannel<ClockDetails>({ clock: 0, pass: -1 });
+  public rootChit = new EventChannel<RootChit<any> | undefined>(undefined);
+  public activeLog = new EventChannel<string | undefined>(undefined);
+  private startTime = 1;
+
+  public async gameLogs() {
+    return await this.serverTime.gameLog();
+  }
+
+  public readonly findChit: (id: string) => Chit = (id: string) => {
+    const result = this.chitLookup[id];
+    if (!result) {
+      throw new Error("Cannot find chit");
+    }
+    return result;
+  };
+
+  public readonly findChitUnsafe: (id: string) => Chit | undefined = (id: string) => {
+    return this.chitLookup[id];
+  };
+
+  private serverTime: ServerTime<any, any>;
+
+  public async setStartTime(newTime: number) {
+    if (this.clientTimeState.targetClock.value <= newTime || newTime === 0) {
+      this.clientTimeState.isLoading.value = true;
+
+      if (!this.clientTimeState.skipReplay.value) {
+        this.startTime = newTime;
+        this.clientTimeState.targetClock.value = newTime;
+      } else {
+        this.clientTimeState.goLive(this.maxClock.value.clock);
+      }
+    }
+  }
+
+  public async newMaxClock(newMaxClock: ClockDetails) {
+    const oldClock = this.maxClock.value;
+    const isSamePass = samePasses(oldClock, newMaxClock);
+
+    if (isSamePass && oldClock.clock === newMaxClock.clock) {
+      return;
+    }
+
+    this.maxClock.value = newMaxClock;
+    if (this.clientTimeState.live.value || !isSamePass) {
+      if (
+        !this.clientTimeState.isWaitingOnAnimations.value &&
+        this.clientTimeState.targetClock.value < this.maxClock.value.clock
+      ) {
+        this.clientTimeState.targetClock.value++;
+      } else if (!isSamePass && !this.clientTimeState.isWaitingOnAnimations.value) {
+        this.clientTimeState.targetClock.value = this.maxClock.value.clock;
+        this.processNewTargetClock();
+      } else if (!this.clientTimeState.isWaitingOnAnimations.value) {
+        // some other use has reset...
+        this.clientTimeState.targetClock.value = this.maxClock.value.clock;
+      } else {
+        this.processNewTargetClock();
+      }
+    }
+  }
+
+  private _states: { [stateId: number]: string } = {};
+  private inflateSerializedResponse(newState: { [state: number]: string }, chitStates: { [id: string]: number }) {
+    Object.assign(this._states, newState);
+    return Object.fromEntries(Object.entries(chitStates).map(([key, value]) => [key, this._states[value]]));
+  }
+
+  private async processNewTargetClock() {
+    const newTargetClock = this.clientTimeState.targetClock.value;
+    const currentClock = this.currentClock.value;
+
+    if (newTargetClock > this.maxClock.value.clock) {
+      this.clientTimeState.targetClock.value = this.maxClock.value.clock;
+      return;
+    }
+    if (newTargetClock < 1) {
+      this.clientTimeState.targetClock.value = 1;
+      return;
+    }
+
+    // make sure our async operations don't get interrupted by auto-advancing the timeline
+    const animationKey = `minimumAnimationDuration${Date.now()}`;
+    this.clientTimeState.setAnimationState(animationKey, true);
+
+    const response = await this.serverTime.serializeDelta(this.clientTimeState.targetClock.value);
+    const serializedChits = this.inflateSerializedResponse(response.newStates, response.chits);
+
+    // make sure nothing changed while we were waiting...
+    if (this.clientTimeState.targetClock.value === newTargetClock && currentClock === this.currentClock.value) {
+      if (newTargetClock > this.startTime) {
+        this.clientTimeState.isLoading.value = false;
+      }
+
+      // track the active log message
+      this.activeLog.value = response.log?.message;
+      this.clientPrompt?.fixActiveLog();
+
+      // first make sure all chits exist (because they may link to each other)
+      Object.entries(serializedChits).forEach(([id, value]) => {
+        let chit = this.chitLookup[id];
+        if (!chit) {
+          const c = Chit.deflate(value, this.game);
+          if (c) {
+            chit = this.chitLookup[id] = c;
+          }
+        }
+      });
+
+      Object.values(this.chitLookup).forEach((chit) => {
+        if (chit.id && !serializedChits[chit.id]) {
+          if (chit.parentFallback) {
+            chit.beginDeserializing();
+            chit.setParent(chit.parentFallback, chit.parentOutlet ?? "graveyard");
+            chit.doneDeserializing();
+          } else {
+            chit.removeFromParent();
+          }
+          delete this.lastSerializedState[chit.id];
+        }
+      });
+
+      this.currentClock.value = response.clockDetails;
+
+      // now actually load the new state
+      const changedIds = new Set(
+        Object.entries(serializedChits)
+          .filter(([id, value]) => this.chitLookup[id] && this.lastSerializedState[id] !== value)
+          .map(([id]) => id),
+      );
+
+      const chits: Chit[] = Object.entries(serializedChits)
+        .filter(([id, value]) => this.chitLookup[id] && this.lastSerializedState[id] !== value)
+        .map(([id]) => this.chitLookup[id]);
+
+      chits.forEach((chit) => chit.beginDeserializing());
+
+      Object.entries(serializedChits)
+        .filter(([id]) => changedIds.has(id))
+        .forEach(([id, value]) => {
+          const chit = this.chitLookup[id];
+          chit.deserialize(value, this.findChit);
+          this.lastSerializedState[id] = value;
+        });
+
+      chits.forEach((chit) => chit.doneDeserializing());
+
+      this.rootChit.value = this.findChit("root") as RootChit<any>;
+
+      // sometimes deserializing chits does not result in animations (maybe a pure texture change?)
+      // in that case, we need to make sure that the clock moves forward
+      setTimeout(() => this.clientTimeState.setAnimationState(animationKey, false), 100);
+    } else {
+      this.clientTimeState.setAnimationState(animationKey, false);
+    }
+  }
+
+  public async chitHistory(chits: Chit[]) {
+    const sparkHistory = await this.serverTime.chitHistory(chits.map((s) => s.id!));
+    const result: { [id: string]: { clock: number; chit: Chit }[] } = {};
+
+    const chitLookup: { [id: string]: Chit } = Object.entries(this.chitLookup).reduce(
+      (acc, [id, chit]) => {
+        const serialized = chit.serialize();
+        const c = Chit.deflate(serialized, this.game);
+        if (c) {
+          acc[id] = c;
+        }
+        return acc;
+      },
+      {} as { [id: string]: Chit },
+    );
+    const findChit = (id: string) => chitLookup[id];
+
+    Object.keys(chitLookup).forEach((id: string) => {
+      chitLookup[id].deserialize(this.chitLookup[id].serialize(), findChit);
+    });
+
+    Object.entries(sparkHistory).forEach(([id, history]) => {
+      result[id] = [];
+      history.forEach((h: any) => {
+        const c = Chit.deflate(h.state, this.game);
+        if (c) {
+          c.deserialize(h.state, findChit);
+          result[id].push({ clock: h.clock, chit: c });
+        }
+      });
+    });
+    return result;
+  }
+}

package/src/library/game/serverTransport/ServerPrompts.ts

@@ -0,0 +1,76 @@
+import { Connection } from "../Connection";
+import { ConnectionObject } from "../ConnectionObject";
+import { Match } from "../Match";
+import { PlayerChit } from "../PlayerChit";
+import { PromptSerialization } from "../Prompt";
+import { RootChit } from "../RootChit";
+import { ClientPrompts } from "../clientTransport/ClientPrompts";
+
+export class ServerPrompts<P extends PlayerChit, R extends RootChit<P>> extends ConnectionObject {
+  private clientPrompts: ClientPrompts<P, R>;
+  constructor(
+    private playerId: string,
+    private match: Match<P, R>,
+    private connection: Connection,
+  ) {
+    super();
+
+    this.clientPrompts = this.connection.get<ClientPrompts<P, R>>("ClientPrompts");
+
+    // I HATE THIS
+    // but it's fine? maybe?
+    let unsubs: (() => void)[] = [];
+    this.register(
+      (() => {
+        const cb = match.turn.on((newTurn) => {
+          unsubs.forEach((cb) => cb());
+          unsubs = [];
+
+          if (newTurn) {
+            unsubs = newTurn.rootChit.players.map((player) =>
+              player.promptStatus.latestPrompt.on((latestPrompt: any) =>
+                this.clientPrompts.setPromptForPlayer(
+                  player.playerId,
+                  latestPrompt?.serialize(),
+                  this.match.turn.value?.clockDetails(playerId),
+                ),
+              ),
+            );
+          }
+        });
+
+        return () => {
+          cb();
+          unsubs.forEach((cb) => cb());
+        };
+      })(),
+    );
+  }
+
+  private get playerChits() {
+    return this.match.turn.value?.rootChit.players;
+  }
+
+  async resolvePrompt(response: any): Promise<void | PromptSerialization> {
+    const player = this.playerChits?.find((p) => p.playerId === this.playerId);
+    if (player && player.promptStatus.latestPrompt.value) {
+      let cb: (() => void) | undefined;
+      const p = new Promise((resolve) => {
+        cb = this.match.onChange(() => resolve(0), false);
+      });
+      player.promptStatus.latestPrompt.value.resolve(response);
+      await p;
+      if (cb) {
+        cb();
+      }
+      return player.promptStatus.latestPrompt.value?.serialize();
+    }
+  }
+
+  async stepBackPrompt(fullReset: boolean = false) {
+    const player = this.playerChits?.find((p) => p.playerId === this.playerId);
+    if (player && player.promptStatus.latestPrompt.value && player.promptStatus.latestPrompt.value.canReset) {
+      player.promptStatus.latestPrompt.value.stepBack(fullReset);
+    }
+  }
+}

package/src/library/game/serverTransport/ServerStatus.ts

@@ -0,0 +1,31 @@
+import { Connection } from "../Connection";
+import { ConnectionObject } from "../ConnectionObject";
+import { Match } from "../Match";
+import { PlayerChit } from "../PlayerChit";
+import { RootChit } from "../RootChit";
+import { ClientStatus } from "../clientTransport/ClientStatus";
+
+export class ServerStatus<P extends PlayerChit, R extends RootChit<P>> extends ConnectionObject {
+  private clientStatus: ClientStatus<P, R>;
+
+  constructor(
+    private match: Match<P, R>,
+    private connection: Connection,
+  ) {
+    super();
+
+    this.clientStatus = this.connection.get<ClientStatus<P, R>>("ClientStatus");
+
+    this.register(
+      this.match.errorState.on((errorMessage) => {
+        this.clientStatus.setErrorMessage(errorMessage);
+      }),
+    );
+
+    this.register(
+      this.match.result.on((result) => {
+        this.clientStatus.setMatchResult(result?.winners?.map((winner) => winner.id ?? ""));
+      }),
+    );
+  }
+}