@pretty-chitty/core 1.1.1

package/src/library/game/Pick.ts

@@ -0,0 +1,314 @@
+import { Chit } from "./Chit";
+import { GalleryItemChitChildrenSource } from "./GalleryItemChitChildrenSource";
+import { IButtonLibrary } from "./Game";
+import { Confirm, GameButton, ToggleGalleryButton } from "./GameButton";
+import { PickPrompt } from "./Prompt";
+import { MismatchError, Turn } from "./Turn";
+
+export type FindChit = (id: string) => Chit;
+export type PickType = "ChitPick" | "ButtonPick";
+export type PickSerialization = {
+  type: PickType;
+  message?: string;
+  help?: string;
+  details: any;
+  context?: string;
+};
+
+export abstract class Pick {
+  /** @internal */
+  public messageContents?: string;
+  /** @internal */
+  public helpContents?: string;
+  /** @internal */
+  abstract get type(): PickType;
+
+  /** @internal */
+  public focusChits: Chit[] = [];
+
+  /** @internal */
+  public contextChit?: Chit;
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  /** @internal */
+  confirmLock(_turn: Turn<any, any, any>) {
+    // do nothing
+  }
+
+  /** @internal */
+  abstract serializeDetails(): any;
+  /** @internal */
+  abstract deserializeDetails(state: any, findChit: FindChit, buttonLibrary: IButtonLibrary): void;
+  /** @internal */
+  abstract resolveDetails(details: any): Promise<void>;
+  /** @internal */
+  abstract stageIn(prompt: PickPrompt): void;
+  /** @internal */
+  abstract stageOut(): void;
+  /** @internal */
+  abstract autoResolve(): Promise<void | undefined>;
+  /** @internal */
+  abstract numberOfChoices(): number;
+
+  /** @internal */
+  canAutoResolve() {
+    return this.numberOfChoices() === 1;
+  }
+
+  message(message?: string): this {
+    this.messageContents = message;
+    return this;
+  }
+
+  help(help?: string): this {
+    this.helpContents = help;
+    return this;
+  }
+
+  /** @internal */
+  serialize(): PickSerialization {
+    return {
+      type: this.type,
+      help: this.helpContents,
+      message: this.messageContents,
+      details: this.serializeDetails(),
+      context: this.contextChit ? this.contextChit.id : undefined,
+    };
+  }
+
+  /** @internal */
+  public static deserialize(pick: PickSerialization, findChit: FindChit, buttonLibrary: IButtonLibrary): Pick {
+    let p: Pick | undefined = undefined;
+    switch (pick.type) {
+      case "ChitPick": {
+        p = new ChitPick();
+        break;
+      }
+      case "ButtonPick": {
+        p = new ButtonPick();
+        break;
+      }
+    }
+
+    if (p) {
+      p.contextChit = pick.context ? findChit(pick.context) : undefined;
+      p.messageContents = pick.message;
+      p.helpContents = pick.help;
+      p.deserializeDetails(pick.details, findChit, buttonLibrary);
+      return p;
+    }
+
+    throw new Error(`Pick type ${pick.type} not known`);
+  }
+
+  focus(chit: Chit | Chit[]): this {
+    if (Array.isArray(chit)) {
+      this.focusChits.push(...chit);
+    } else {
+      this.focusChits.push(chit);
+    }
+    return this;
+  }
+
+  context(chit: Chit | undefined): this {
+    this.contextChit = chit;
+    return this;
+  }
+
+  /** @internal */
+  closeGallery?: () => void;
+
+  /** @internal */
+  processFocus() {
+    // show it?
+    this.focusChits.forEach((c) => {
+      if (c.renderInstance) {
+        c.renderInstance.rootRenderInstance.markHasChitsEntering();
+        if (c.renderInstance.absorbsClickEventsForChildren) {
+          this.closeGallery = c.renderInstance.rootRenderInstance.showGallery(new GalleryItemChitChildrenSource(c));
+        }
+      }
+    });
+  }
+}
+
+export class ChitPick<T extends Chit> extends Pick {
+  /** @internal */
+  type: PickType = "ChitPick";
+
+  /** @internal */
+  public chits: T[] = [];
+
+  /** @internal */
+  public cb: (chit: T) => void | Promise<void> = () => {};
+
+  public button?: ToggleGalleryButton;
+
+  /** @internal */
+  serializeDetails() {
+    const result: any = {
+      c: this.chits.map((chit) => chit.id),
+      f: this.focusChits.map((chit) => chit.id),
+    };
+
+    if (this.button) {
+      result.b = this.button.serialize();
+      result.b.__buttonType = Object.getPrototypeOf(this.button).constructor.name;
+    }
+
+    return result;
+  }
+
+  focus(chit?: Chit | Chit[]): this {
+    if (!chit) {
+      this.focusChits.push(...this.chits);
+    } else if (Array.isArray(chit)) {
+      this.focusChits.push(...chit);
+    } else {
+      this.focusChits.push(chit);
+    }
+    return this;
+  }
+
+  /** @internal */
+  deserializeDetails(
+    { c, f, b }: { c: string[]; f: string[]; b?: any },
+    findChit: FindChit,
+    buttonLibrary: IButtonLibrary,
+  ): void {
+    this.chits = c.map((chitId) => findChit(chitId) as T).filter((d) => d);
+    this.focusChits = f.map((chitId) => findChit(chitId)).filter((d) => d);
+
+    if (b) {
+      const HARDCODED_BUTTON_LIBRARY: { [id: string]: new () => GameButton } = { Confirm };
+      const buttonType = b.__buttonType;
+      const ButtonType = buttonLibrary[buttonType] ?? HARDCODED_BUTTON_LIBRARY[buttonType];
+      if (!ButtonType) {
+        throw new Error(`Cannot find button type ${buttonType}`);
+      }
+      this.button = new ButtonType() as ToggleGalleryButton;
+      this.button.deserialize(b, findChit);
+    }
+  }
+
+  /** @internal */
+  resolveDetails(chitId: string) {
+    const selectedChit = this.chits.find((chit) => chit.id === chitId);
+    if (!selectedChit) {
+      throw new MismatchError();
+    }
+    return Promise.resolve(this.cb(selectedChit));
+  }
+
+  /** @internal */
+  stageIn(prompt: PickPrompt) {
+    this.chits.forEach((c) => (c.onClick = () => prompt.resolvePick(this, c.id)));
+    this.processFocus();
+    this.button?.computeItemSource(this);
+    if (this.button?.autoShow && this.button?.galleryItemSource) {
+      this.closeGallery = this.chits[0]?.renderInstance?.rootRenderInstance.showGallery(this.button.galleryItemSource);
+    }
+  }
+
+  /** @internal */
+  stageOut() {
+    this.chits.forEach((c) => (c.onClick = undefined));
+    if (this.closeGallery) {
+      this.closeGallery();
+    }
+    if (this.button instanceof ToggleGalleryButton && this.button?.galleryItemSource) {
+      this.chits[0]?.renderInstance?.rootRenderInstance.hideGallery(this.button.galleryItemSource);
+    }
+  }
+
+  /** @internal */
+  override confirmLock(turn: Turn<any, any, any>) {
+    this.chits.forEach((chit) => chit.confirmLock(turn));
+  }
+
+  /** @internal */
+  numberOfChoices() {
+    return this.chits.length;
+  }
+
+  /** @internal */
+  autoResolve() {
+    return Promise.resolve(this.cb(this.chits[0]));
+  }
+
+  toggleButton(button: ToggleGalleryButton): this {
+    this.button = button;
+    return this;
+  }
+}
+
+export class ButtonPick extends Pick {
+  /** @internal */
+  type: PickType = "ButtonPick";
+
+  public button?: GameButton;
+
+  /** @internal */
+  numberOfChoices() {
+    return 1;
+  }
+
+  /** @internal */
+  autoResolve() {
+    return Promise.resolve(this.button && this.button.cb && this.button.cb());
+  }
+
+  /** @internal */
+  canAutoResolve() {
+    return this.button?.canAutoResolve ?? true;
+  }
+
+  /** @internal */
+  serializeDetails() {
+    if (!this.button) {
+      throw new Error("Cannot resolve without a button defined");
+    }
+
+    const details = this.button.serialize();
+    details.__buttonType = Object.getPrototypeOf(this.button).constructor.name;
+    details.__f = this.focusChits.map((chit) => chit.id);
+    return details;
+  }
+
+  /** @internal */
+  deserializeDetails(state: any, findChit: FindChit, buttonLibrary: IButtonLibrary) {
+    const HARDCODED_BUTTON_LIBRARY: { [id: string]: new () => GameButton } = { Confirm };
+    const buttonType = state.__buttonType;
+    this.focusChits = state.__f.map((chitId: string) => findChit(chitId)).filter((d: Chit) => d);
+    const ButtonType = buttonLibrary[buttonType] ?? HARDCODED_BUTTON_LIBRARY[buttonType];
+    if (!ButtonType) {
+      throw new Error(`Cannot find button type ${buttonType}`);
+    }
+    this.button = new ButtonType();
+    this.button.deserialize(state, findChit);
+  }
+
+  /** @internal */
+  resolveDetails() {
+    if (!this.button) {
+      throw new Error("Cannot resolve without a button defined");
+    }
+    return Promise.resolve(this.button && this.button.cb && this.button.cb());
+  }
+
+  /** @internal */
+  stageIn(prompt: PickPrompt) {
+    if (this.button) {
+      this.button.cb = () => {
+        if (this.button) {
+          this.button.cb = () => {};
+        }
+        prompt.resolvePick(this, null);
+      };
+    }
+    this.processFocus();
+  }
+
+  /** @internal */
+  stageOut() {}
+}

package/src/library/game/PlayerChit.ts

@@ -0,0 +1,43 @@
+import { ChildOutlet, NonEditable } from "../utilities/Annotations";
+import { PlayerCanvas } from "../utilities/CanvasStack/PlayerCanvas";
+import { Chit } from "./Chit";
+import { PlayerInfo } from "./PlayerInfo";
+import { PlayerPromptStatusChit } from "./PlayerPromptStatusChit";
+
+export class PlayerChit extends Chit {
+  /** @internal */
+  @NonEditable type = "player";
+
+  public playerId: string = "no id";
+  public name: string = "no name";
+  public imageUrl?: string;
+  public color: string = "#000000";
+
+  /** @internal */
+  @NonEditable public matchScoreNumber?: number;
+
+  @ChildOutlet promptStatus = new PlayerPromptStatusChit();
+
+  public get panelTab() {
+    return {
+      color: this.color,
+      icon: new PlayerCanvas(this).get(),
+    };
+  }
+
+  public get icon() {
+    return new PlayerCanvas(this).get();
+  }
+
+  public get logKey() {
+    return `:${this.playerId}:`;
+  }
+
+  /** @internal */
+  setPlayerInfo(playerInfo: PlayerInfo) {
+    this.playerId = playerInfo.id;
+    this.name = playerInfo.name;
+    this.id = playerInfo.id;
+    this.imageUrl = playerInfo.imageUrl;
+  }
+}

package/src/library/game/PlayerInfo.ts

@@ -0,0 +1,30 @@
+import multiavatar from "@multiavatar/multiavatar";
+import base64 from "base-64";
+
+export interface IPlayerInfo {
+  id: string;
+  name: string;
+  imageUrl?: string;
+}
+
+export class PlayerInfo {
+  public imageUrl?: string;
+  public id: string;
+  public name: string;
+
+  constructor(idOrPlayerInfo: string | IPlayerInfo, name?: string) {
+    if (typeof idOrPlayerInfo === "string") {
+      this.id = idOrPlayerInfo;
+      this.name = name!;
+    } else {
+      this.id = idOrPlayerInfo.id;
+      this.name = idOrPlayerInfo.name;
+      this.imageUrl = idOrPlayerInfo.imageUrl;
+    }
+
+    if (!this.imageUrl && window?.URL) {
+      const data = multiavatar(`${this.name} ${this.id}`, true).replace("<svg", '<svg width="231" height="231"');
+      this.imageUrl = `data:image/svg+xml;base64,${base64.encode(data)}`;
+    }
+  }
+}

package/src/library/game/PlayerPromptStatusChit.ts

@@ -0,0 +1,20 @@
+import { NonEditable } from "../utilities/Annotations";
+import { EventChannel } from "../utilities/EventChannel";
+import { Chit } from "./Chit";
+import { Prompt } from "./Prompt";
+import StaticChitTypeRegistry from "./StaticChitTypeRegistry";
+
+export class PlayerPromptStatusChit extends Chit {
+  /** @internal */
+  public latestPromptMessage?: string;
+  /** @internal */
+  @NonEditable public latestPrompt = new EventChannel<Prompt | undefined>(undefined, 50);
+  /** @internal */
+  @NonEditable public latestPromptResponseTime = 0;
+
+  public canRender(): boolean {
+    return false;
+  }
+}
+
+StaticChitTypeRegistry["PlayerPromptStatusChit"] = PlayerPromptStatusChit;

package/src/library/game/Prompt.ts

@@ -0,0 +1,292 @@
+import { Chit } from "./Chit";
+import { IButtonLibrary } from "./Game";
+import { Confirm, GameButton } from "./GameButton";
+import { ButtonPick, ChitPick, Pick } from "./Pick";
+import { MismatchError, Turn } from "./Turn";
+
+type PromptType = "SelectPrompt" | "ConfirmPrompt" | "PickPrompt" | "NoValidMovesPrompt";
+
+export type PromptSerialization = {
+  type: PromptType;
+  canReset: boolean;
+  details: any;
+};
+
+const defaultFindChit: FindChit = () => {
+  throw new Error("NOT SET");
+};
+
+type FindChit = (id: string) => Chit;
+
+export abstract class Prompt {
+  public id = "";
+  public resolved = false;
+  public clock = 0;
+  public response: any;
+  private cbs: ((success: boolean) => void)[] = [];
+  public findChit: FindChit = defaultFindChit;
+  public buttonLibrary: IButtonLibrary = { Confirm };
+
+  public shouldRerun?: Turn<any, any, any>;
+  public shouldStepBack = false;
+  public shouldReset = false;
+
+  public canReset = false;
+
+  serialize(): PromptSerialization {
+    return {
+      type: this.type,
+      canReset: this.canReset,
+      details: this.serializeDetails(),
+    };
+  }
+
+  deserialize(prompt: PromptSerialization) {
+    this.canReset = prompt.canReset;
+    this.deserializeDetails(prompt.details);
+  }
+
+  onResolve(cb: (success: boolean) => void) {
+    this.cbs.push(cb);
+  }
+
+  destroy() {
+    this.cbs.forEach((cb) => cb(false));
+  }
+
+  resolve(details: any) {
+    this.resolved = true;
+    this.resolveDetails(details);
+    this.response = details;
+    this.cbs.forEach((cb) => cb(true));
+  }
+
+  stepBack(fullReset: boolean = false) {
+    if (!this.canReset) {
+      throw new Error("Cannot be stepped back");
+    }
+    this.resolved = true;
+    this.shouldReset = fullReset;
+    this.shouldStepBack = true;
+    this.cbs.forEach((cb) => cb(false));
+  }
+
+  abstract get type(): PromptType;
+  abstract serializeDetails(): any;
+  abstract deserializeDetails(state: any): void;
+  abstract resolveDetails(details: any): void;
+  abstract stageIn(): void;
+  abstract stageOut(): void;
+
+  public get message() {
+    return "Message";
+  }
+
+  public get help(): string {
+    return "";
+  }
+
+  public formatHelpText() {
+    return `# ${this.message}\n\n${this.help}`;
+  }
+
+  public get buttons(): GameButton[] {
+    return [];
+  }
+
+  public static deserialize(prompt: PromptSerialization, findChit: FindChit, buttonLibrary: IButtonLibrary): Prompt {
+    let p: Prompt | undefined = undefined;
+    switch (prompt.type) {
+      case "SelectPrompt": {
+        p = new SelectPrompt();
+        break;
+      }
+      case "PickPrompt": {
+        p = new PickPrompt();
+        break;
+      }
+      case "NoValidMovesPrompt": {
+        p = new NoValidMovesPrompt();
+        break;
+      }
+    }
+
+    if (p) {
+      p.findChit = findChit;
+      p.buttonLibrary = buttonLibrary;
+      p.deserialize(prompt);
+      return p;
+    }
+
+    throw new Error(`Prompt type ${prompt.type} not known`);
+  }
+}
+
+export class NoValidMovesPrompt extends Prompt {
+  type: PromptType = "NoValidMovesPrompt";
+
+  _message = "No valid moves available";
+  _help = "Undo and try a different action";
+
+  get message() {
+    return this._message;
+  }
+  set message(newMessage: string) {
+    this._message = newMessage;
+  }
+  get help() {
+    return this._help;
+  }
+  set help(newHelp: string) {
+    this._help = newHelp;
+  }
+
+  serializeDetails(): any {
+    return {
+      message: this._message,
+      help: this._help,
+    };
+  }
+
+  deserializeDetails(state: any): void {
+    this._message = state.message;
+    this._help = state.help;
+  }
+
+  resolveDetails() {
+    throw new Error("NoValidMovesPrompt cannot be resolved");
+  }
+
+  stageIn(): void {}
+
+  stageOut(): void {}
+}
+
+export class SelectPrompt extends Prompt {
+  type: PromptType = "SelectPrompt";
+
+  public chits: Chit[] = [];
+  public selectedChit: Chit | undefined;
+
+  serializeDetails(): any {
+    return this.chits.map((chit) => chit.id);
+  }
+
+  deserializeDetails(chitIds: string[]): void {
+    this.chits = chitIds.map((chitId) => this.findChit(chitId));
+  }
+
+  resolveDetails(chitId: string) {
+    this.resolved = true;
+    this.selectedChit = this.chits.find((chit) => chit.id === chitId);
+    if (!this.selectedChit) {
+      throw new MismatchError();
+    }
+  }
+
+  stageIn() {
+    this.chits.forEach((c) => (c.onClick = () => this.resolve(c.id)));
+  }
+
+  stageOut() {
+    this.chits.forEach((c) => (c.onClick = undefined));
+  }
+}
+
+type PickResolution = { idx: number; value: any };
+
+export class PickPrompt extends Prompt {
+  type: PromptType = "PickPrompt";
+
+  private _message?: string;
+  private _help?: string;
+
+  public picks: Pick[] = [];
+  public finished: () => void | Promise<void> = () => {};
+
+  override get message() {
+    if (this._message) {
+      return this._message;
+    }
+
+    return this.picks
+      .map((p) => p.messageContents)
+      .filter((d) => d)
+      .join(" or ");
+  }
+
+  override get help() {
+    if (this._help) {
+      return this._help;
+    }
+
+    return this.picks
+      .map((p) => p.helpContents)
+      .filter((d) => d)
+      .join("\n\nor\n\n");
+  }
+
+  async autoResolve(): Promise<boolean> {
+    if (this.picks.length === 1 && this.picks[0].canAutoResolve()) {
+      await this.picks[0].autoResolve();
+      return true;
+    }
+    return false;
+  }
+
+  serializeDetails(): any {
+    return {
+      message: this._message,
+      help: this._help,
+      picks: this.picks.map((p) => p.serialize()),
+    };
+  }
+
+  deserializeDetails(details: { help: string | undefined; message: string | undefined; picks: any[] }): void {
+    this.picks = details.picks.map((d) => Pick.deserialize(d, this.findChit, this.buttonLibrary));
+    this._message = details.message;
+    this._help = details.help;
+  }
+
+  resolvePick(pick: Pick, value: any) {
+    const idx = this.picks.indexOf(pick);
+    this.resolve({ idx, value });
+  }
+
+  resolveDetails(resolution: PickResolution) {
+    if (resolution.idx === undefined) {
+      return;
+    }
+
+    this.resolved = true;
+    const pick = this.picks[resolution.idx];
+    this.finished = () => pick.resolveDetails(resolution?.value);
+  }
+
+  stageIn() {
+    this.picks.forEach((p) => p.stageIn(this));
+  }
+
+  stageOut() {
+    this.picks.forEach((p) => p.stageOut());
+  }
+
+  setMessageAndHelp(message?: string, help?: string) {
+    this._message = message;
+    this._help = help;
+  }
+
+  override get buttons(): GameButton[] {
+    return this.picks
+      .map((p) => {
+        if (p instanceof ButtonPick) {
+          return p.button;
+        }
+        if (p instanceof ChitPick) {
+          return p.button;
+        }
+        return undefined;
+      })
+      .filter((a) => a) as GameButton[];
+  }
+}