@pretty-chitty/core 1.1.1

package/src/library/game/Match.ts

@@ -0,0 +1,187 @@
+import { Chit } from "./Chit";
+import { Connection } from "./Connection";
+import { ConnectionTransport } from "./ConnectionTransport";
+import { Game, GameResult } from "./Game";
+import { ServerTime } from "./serverTransport/ServerTime";
+import { PlayerInfo } from "./PlayerInfo";
+import { MismatchError, RerunError, Turn } from "./Turn";
+import { TurnState } from "./TurnState";
+import { IMatchStorage } from "./MatchStorage";
+import nextTick from "next-tick";
+import { ServerPrompts } from "./serverTransport/ServerPrompts";
+import { EventChannel } from "../utilities/EventChannel";
+import { RootChit } from "./RootChit";
+import { ServerStatus } from "./serverTransport/ServerStatus";
+import { PlayerChit } from "./PlayerChit";
+
+export class Match<P extends PlayerChit, R extends RootChit<P>> {
+  public state: TurnState = new TurnState();
+  public result = new EventChannel<undefined | GameResult<P>>(undefined);
+  public turn = new EventChannel<undefined | Turn<GameResult<P>, P, R>>(undefined);
+  public errorState = new EventChannel<undefined | string>(undefined);
+  private onChangeCallbacks: (() => void)[] = [];
+
+  constructor(
+    public game: Game<P, R>,
+    public players: PlayerInfo[],
+    private matchStorage: IMatchStorage,
+  ) {}
+
+  async load() {
+    const savedState = await this.matchStorage.readState();
+    if (savedState !== null) {
+      this.state.deserialize(savedState);
+    }
+    this.matchStorage.registerNewStateCallback((savedState) => {
+      this.state = new TurnState();
+      this.state.deserialize(savedState);
+      if (this.errorState.value) {
+        this.turn.value?.destroy();
+        this.turn.value = undefined;
+        this.start();
+      } else if (this.turn.value) {
+        this.turn.value
+          .processNewSavedState(this.state)
+          .then(() => {
+            console.log("Processed new saved state");
+          })
+          .catch((e: any) => {
+            console.error("Error processing new saved state", e);
+          });
+      }
+
+      // TODO: if the match is over and are resetting.... what do we do?
+    });
+  }
+
+  public findPlayer(playerId: string): PlayerInfo {
+    const result = this.players.find((p) => p.id === playerId);
+    if (!result) {
+      throw new Error(`Player ${playerId} not found`);
+    }
+    return result;
+  }
+
+  async start() {
+    if (this.turn.value) {
+      throw new Error("Can only start once per Match instance");
+    }
+
+    // if players change (promise status, etc.) then we need to notify
+    // as that means the clock has changed (or promise status)
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      try {
+        this.result.value = undefined;
+        this.errorState.value = undefined;
+        const rootChit = new this.game.chitLibrary.Root();
+        rootChit.id = "root";
+        rootChit.game = this.game;
+
+        this.players.forEach((p) => {
+          const Player = this.game.chitLibrary.Player;
+          const player = new Player();
+          player.setPlayerInfo(p);
+          player.promptStatus.latestPrompt.on(() => this.notify(), false);
+          rootChit.players.add(player);
+          return player;
+        });
+
+        let counter = 1;
+        rootChit.walk((c: Chit) => {
+          if (!c.id) {
+            c.id = `r-ac-${counter++}`;
+          }
+        });
+
+        this.turn.value = new Turn<GameResult<P>, P, R>(
+          "root",
+          this,
+          this.state,
+          async (turn) => {
+            await rootChit.players.shuffle();
+            return this.game.run(turn, rootChit);
+          },
+          [rootChit],
+        );
+        rootChit._setupTurn = this.turn.value;
+        this.turn.value.fixPass();
+        this.notify();
+
+        this.result.value = await this.turn.value.execute();
+        break;
+      } catch (e) {
+        if (e instanceof RerunError) {
+          continue;
+        }
+
+        if (e instanceof MismatchError) {
+          this.errorState.value = e.message;
+          return;
+        }
+
+        throw e;
+      }
+    }
+  }
+
+  // TODO: playerid included?
+  connect(transport: ConnectionTransport, playerId: string) {
+    const connection = new Connection(transport);
+    console.log(`Connected ${playerId}`);
+    connection.register(new ServerTime(this, playerId, connection));
+    connection.register(new ServerPrompts(playerId, this, connection));
+    connection.register(new ServerStatus(this, connection));
+    return connection;
+  }
+
+  private _timeout?: NodeJS.Timeout | number = undefined;
+  private notify() {
+    clearTimeout(this._timeout);
+    this._timeout = setTimeout(() => this.processNotify(), 0);
+  }
+
+  private _isSaving = false;
+  private _saveStateNeeded = false;
+  private processNotify() {
+    this.onChangeCallbacks.forEach((cb) => cb());
+
+    // TODO: this is a promise going nowhere... do we block on saving?
+    this._saveStateNeeded = true;
+    this.processSaveState();
+  }
+
+  private processSaveState() {
+    if (this._isSaving) {
+      return;
+    }
+
+    this._saveStateNeeded = false;
+    this._isSaving = true;
+    this.matchStorage
+      .saveState(
+        this.state,
+        this.turn.value?.rootChit.players.copy() ?? [],
+        this.result.value ? "finished" : "active",
+        this.result.value?.winners,
+      )
+      .finally(() => {
+        this._isSaving = false;
+        if (this._saveStateNeeded) {
+          return this.processSaveState();
+        }
+      });
+  }
+
+  public dispose() {
+    // TODO: cleanup
+  }
+
+  public onChange(cb: () => void, callNow = true) {
+    this.onChangeCallbacks.push(cb);
+    callNow && nextTick(cb);
+    return () => {
+      this.onChangeCallbacks = this.onChangeCallbacks.filter((c) => c !== cb);
+    };
+  }
+}

package/src/library/game/MatchConnection.ts

@@ -0,0 +1,5 @@
+interface MatchConnectionTransport {}
+
+export class MatchConnection {
+  constructor(private transport: MatchConnectionTransport) {}
+}

package/src/library/game/MatchStorage.ts

@@ -0,0 +1,51 @@
+import { PlayerChit } from "./PlayerChit";
+
+export interface IMatchStorage {
+  readState(): Promise<any>;
+  saveState(
+    newState: any,
+    players: PlayerChit[],
+    matchState: "active" | "finished",
+    winners?: PlayerChit[],
+  ): Promise<void>;
+  registerNewStateCallback(cb: (newState: any) => void): () => void;
+}
+
+export class LocalMatchStorage implements IMatchStorage {
+  constructor(private matchId: string) {}
+  private onChangeCallbacks: ((state: any) => void)[] = [];
+
+  private get localStorageKey() {
+    return `match${this.matchId}`;
+  }
+
+  async readState(): Promise<any> {
+    const result = localStorage[this.localStorageKey];
+    if (result) {
+      return JSON.parse(result);
+    }
+    return null;
+  }
+  async saveState(
+    newState: any,
+    players: PlayerChit[],
+    matchState: "active" | "finished",
+    winners?: PlayerChit[],
+    notify = false,
+  ): Promise<void> {
+    localStorage[this.localStorageKey] = JSON.stringify(newState);
+    if (notify) {
+      this.notify(newState);
+    }
+  }
+  registerNewStateCallback(cb: (newState: any) => void): () => void {
+    this.onChangeCallbacks.push(cb);
+    return () => {
+      this.onChangeCallbacks = this.onChangeCallbacks.filter((c) => c !== cb);
+    };
+  }
+
+  private notify(state: any) {
+    this.onChangeCallbacks.forEach((cb) => cb(state));
+  }
+}

package/src/library/game/ModalState.ts

@@ -0,0 +1,29 @@
+import { GalleryItemSource } from "../components/GalleryViewer";
+import { EventChannel } from "../utilities/EventChannel";
+
+export class ModalState {
+  public gallerySource = new EventChannel<undefined | GalleryItemSource>(undefined);
+  public actionLogVisible = new EventChannel<boolean>(false);
+  public settingsVisible = new EventChannel<boolean>(false);
+
+  constructor() {
+    this.gallerySource.on((source) => {
+      if (source) {
+        this.actionLogVisible.value = false;
+        this.settingsVisible.value = false;
+      }
+    });
+    this.actionLogVisible.on((visible) => {
+      if (visible) {
+        this.gallerySource.value = undefined;
+        this.settingsVisible.value = false;
+      }
+    });
+    this.settingsVisible.on((visible) => {
+      if (visible) {
+        this.gallerySource.value = undefined;
+        this.actionLogVisible.value = false;
+      }
+    });
+  }
+}

package/src/library/game/OrderedOutlet.ts

@@ -0,0 +1,198 @@
+import { Chit } from "./Chit";
+
+/**
+ * OrderedOutlets are ways to maintain a list of ordered chits on another (parent) chit.  Adding
+ * or removing chits from the outlet will automatically update the parent/child relationships.
+ *
+ * This should only be used in conjunction with the `@Ordered` annotation.
+ *
+ * Preferred syntax:
+ * ```
+ * class MyChit extends Chit {
+ *
+ *   @Ordered(new Vector3(1,2,-3))
+ *   public tokens = new OrderedOutlet<Token>();
+ *
+ * }
+ * ```
+ *
+ * @group Chit Annotations
+ */
+export class OrderedOutlet<C extends Chit> {
+  /** @internal */
+  public parent?: Chit;
+
+  /** @internal */
+  public outletName: string;
+
+  private chits: C[] = [];
+
+  constructor(outletName?: string, parent?: Chit) {
+    this.outletName = outletName ?? "no_name_set";
+    this.parent = parent;
+  }
+
+  public toJSON() {
+    return {
+      ___orderedOutlet: this.chits.map((c) => c.toJSON()),
+    };
+  }
+
+  /** @internal */
+  public deserialize(chits: C[]) {
+    this.chits = chits;
+  }
+
+  public last(): C | undefined {
+    return this.chits[this.chits.length - 1];
+  }
+
+  public add(c: C) {
+    if (this.parent?.isDeserializing) {
+      return;
+    }
+    c.setParent();
+
+    this.chits.push(c);
+    this.fixSort();
+    this.fixOrder();
+  }
+
+  public addAll(c: OrderedOutlet<C> | C[]) {
+    if (this.parent?.isDeserializing) {
+      return;
+    }
+
+    if (c instanceof OrderedOutlet) {
+      c.chits.forEach((c) => c.setParent());
+      c.chits.forEach((c) => this.chits.push(c));
+    } else {
+      c.forEach((c) => c.setParent());
+      c.forEach((c) => this.chits.push(c));
+    }
+    this.fixSort();
+    this.fixOrder();
+  }
+
+  public async shuffle() {
+    if (this.parent) {
+      const from = await this.parent.currentTurn.takeRng(this.length);
+      const to = await this.parent.currentTurn.takeRng(this.length);
+      for (let i = 0; i < this.chits.length; i++) {
+        const j = Math.floor(from() * this.chits.length);
+        const k = Math.floor(to() * this.chits.length);
+        const temp = this.chits[j];
+        this.chits[j] = this.chits[k];
+        this.chits[k] = temp;
+      }
+    }
+    this.fixOrder();
+  }
+
+  public copy(): C[] {
+    return this.chits.concat();
+  }
+
+  public find(cb: (c: C) => boolean) {
+    return this.chits.find(cb);
+  }
+
+  public map<D>(cb: (c: C) => D): D[] {
+    return this.chits.map(cb);
+  }
+
+  public some(cb: (c: C) => boolean): boolean {
+    return this.chits.some(cb);
+  }
+
+  public every(cb: (c: C) => boolean): boolean {
+    return this.chits.every(cb);
+  }
+
+  public reduce<D>(cb: (acc: D, c: C) => D, initial: D): D {
+    return this.chits.reduce(cb, initial);
+  }
+
+  public findIndex(cb: (c: C) => boolean): number {
+    return this.chits.findIndex(cb);
+  }
+
+  public flatMap<D>(cb: (c: C) => D[]): D[] {
+    return this.chits.flatMap(cb);
+  }
+
+  public filter(cb: (c: C) => boolean): C[] {
+    return this.chits.filter(cb);
+  }
+
+  public forEach(cb: (c: C) => void) {
+    this.chits.forEach(cb);
+  }
+
+  public get(i: number): C {
+    const result = this.chits[i];
+    if (!result) {
+      throw new Error("Index out of bounds");
+    }
+    return result;
+  }
+
+  public tryGet(i: number): C | undefined {
+    return this.chits[i];
+  }
+
+  public remove(c: C | C[]) {
+    if (this.parent?.isDeserializing) {
+      return;
+    }
+
+    const removedChits: C[] = [];
+    if (Array.isArray(c)) {
+      const s = new Set(c);
+      this.chits = this.chits.filter((chit) => {
+        const found = s.has(chit);
+        if (found) {
+          removedChits.push(chit);
+        }
+        return !found;
+      });
+    } else {
+      this.chits = this.chits.filter((chit) => {
+        if (chit !== c) {
+          return true;
+        }
+        removedChits.push(chit);
+        return false;
+      });
+    }
+
+    if (removedChits.length > 0) {
+      removedChits.forEach((c) => c.setParent());
+
+      // TODO: depending on order of deserialization this might be misbehaving
+      this.fixOrder();
+    }
+  }
+
+  public get length() {
+    return this.chits.length;
+  }
+
+  public pop() {
+    const result = this.chits.pop();
+    if (result) {
+      this.remove(result);
+    }
+    return result;
+  }
+
+  private fixOrder() {
+    this.chits.forEach((c, i) => {
+      c.setParent(this.parent, this.outletName, i);
+    });
+  }
+
+  private fixSort() {
+    // do nothing by default?
+  }
+}