@pretty-chitty/core 1.1.2 → 1.2.1

package/src/library/game/Match.ts

@@ -7,7 +7,6 @@ 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";
@@ -25,6 +24,7 @@ export class Match<P extends PlayerChit, R extends RootChit<P>> {
     public game: Game<P, R>,
     public players: PlayerInfo[],
     private matchStorage: IMatchStorage,
+    private matchOptions?: any,
   ) {}
 
   async load() {
@@ -74,9 +74,10 @@ export class Match<P extends PlayerChit, R extends RootChit<P>> {
       try {
         this.result.value = undefined;
         this.errorState.value = undefined;
-        const rootChit = new this.game.chitLibrary.Root();
+        const rootChit = new this.game.chitLibrary.Root() as R;
         rootChit.id = "root";
         rootChit.game = this.game;
+        rootChit.processMatchOptions(this.matchOptions ?? {});
 
         this.players.forEach((p) => {
           const Player = this.game.chitLibrary.Player;
@@ -179,7 +180,7 @@ export class Match<P extends PlayerChit, R extends RootChit<P>> {
 
   public onChange(cb: () => void, callNow = true) {
     this.onChangeCallbacks.push(cb);
-    callNow && nextTick(cb);
+    callNow && queueMicrotask(cb);
     return () => {
       this.onChangeCallbacks = this.onChangeCallbacks.filter((c) => c !== cb);
     };

package/src/library/game/MatchStorage.ts

@@ -49,3 +49,40 @@ export class LocalMatchStorage implements IMatchStorage {
     this.onChangeCallbacks.forEach((cb) => cb(state));
   }
 }
+
+export class EphemeralMatchStorage implements IMatchStorage {
+  constructor(private matchId: string) {}
+  private onChangeCallbacks: ((state: any) => void)[] = [];
+
+  private state: string = "{}";
+
+  async readState(): Promise<any> {
+    const result = this.state;
+    if (result) {
+      return JSON.parse(result);
+    }
+    return null;
+  }
+  async saveState(
+    newState: any,
+    players: PlayerChit[],
+    matchState: "active" | "finished",
+    winners?: PlayerChit[],
+    notify = false,
+  ): Promise<void> {
+    this.state = 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

@@ -3,6 +3,7 @@ import { EventChannel } from "../utilities/EventChannel";
 
 export class ModalState {
   public gallerySource = new EventChannel<undefined | GalleryItemSource>(undefined);
+  public inlineGallerySource = new EventChannel<undefined | GalleryItemSource>(undefined);
   public actionLogVisible = new EventChannel<boolean>(false);
   public settingsVisible = new EventChannel<boolean>(false);
 

package/src/library/game/OrderedOutlet.ts

@@ -64,8 +64,9 @@ export class OrderedOutlet<C extends Chit> {
     }
 
     if (c instanceof OrderedOutlet) {
-      c.chits.forEach((c) => c.setParent());
-      c.chits.forEach((c) => this.chits.push(c));
+      const chits = c.chits;
+      chits.forEach((c) => c.setParent());
+      chits.forEach((c) => this.chits.push(c));
     } else {
       c.forEach((c) => c.setParent());
       c.forEach((c) => this.chits.push(c));
@@ -76,11 +77,10 @@ export class OrderedOutlet<C extends Chit> {
 
   public async shuffle() {
     if (this.parent) {
-      const from = await this.parent.currentTurn.takeRng(this.length);
-      const to = await this.parent.currentTurn.takeRng(this.length);
+      const rngs = await this.parent.currentTurn.takeRng(this.length * 2);
       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 j = Math.floor(rngs() * this.chits.length);
+        const k = Math.floor(rngs() * this.chits.length);
         const temp = this.chits[j];
         this.chits[j] = this.chits[k];
         this.chits[k] = temp;

package/src/library/game/Pick.ts

@@ -2,11 +2,12 @@ import { Chit } from "./Chit";
 import { GalleryItemChitChildrenSource } from "./GalleryItemChitChildrenSource";
 import { IButtonLibrary } from "./Game";
 import { Confirm, GameButton, ToggleGalleryButton } from "./GameButton";
+import { OrderedOutlet } from "./OrderedOutlet";
 import { PickPrompt } from "./Prompt";
 import { MismatchError, Turn } from "./Turn";
 
 export type FindChit = (id: string) => Chit;
-export type PickType = "ChitPick" | "ButtonPick";
+export type PickType = "ChitPick" | "ButtonPick" | "DragPick";
 export type PickSerialization = {
   type: PickType;
   message?: string;
@@ -88,6 +89,10 @@ export abstract class Pick {
         p = new ButtonPick();
         break;
       }
+      case "DragPick": {
+        p = new DragPick();
+        break;
+      }
     }
 
     if (p) {
@@ -206,7 +211,11 @@ export class ChitPick<T extends Chit> extends Pick {
     this.processFocus();
     this.button?.computeItemSource(this);
     if (this.button?.autoShow && this.button?.galleryItemSource) {
-      this.closeGallery = this.chits[0]?.renderInstance?.rootRenderInstance.showGallery(this.button.galleryItemSource);
+      const inline = localStorage.galleryFullScreen !== `"modal"`; // hacky but maybe okay
+      this.closeGallery = this.chits[0]?.renderInstance?.rootRenderInstance.showGallery(
+        this.button.galleryItemSource,
+        inline,
+      );
     }
   }
 
@@ -242,6 +251,93 @@ export class ChitPick<T extends Chit> extends Pick {
   }
 }
 
+export class DragTarget<C extends Chit, S extends Chit> {
+  public chits: C[] = [];
+  public cb: (sourceChit: S, targetChit: C) => void | Promise<void> = () => {};
+
+  static from<C extends Chit, S extends Chit>(
+    chit: C | C[] | OrderedOutlet<C>,
+    cb: (sourceChit: S, targetChit: C) => void | Promise<void>,
+  ) {
+    const result = new DragTarget<C, S>();
+    result.chits =
+      chit instanceof OrderedOutlet ? chit.copy() : Array.isArray(chit) ? (chit.filter((c) => c) as C[]) : [chit];
+    result.cb = cb;
+    return result;
+  }
+}
+
+export class DragPick<C extends Chit> extends Pick {
+  /** @internal */
+  type: PickType = "DragPick";
+
+  public chits: C[] = [];
+
+  public dropTargets: DragTarget<any, C>[] = [];
+
+  /** @internal */
+  serializeDetails() {
+    const result: any = {
+      c: this.chits.map((chit) => chit.id),
+      d: this.dropTargets.map((dropTarget) => dropTarget.chits.map((chit) => chit.id)),
+    };
+    return result;
+  }
+
+  /** @internal */
+  deserializeDetails({ c, d }: { c: string[]; d: string[][] }, findChit: FindChit): void {
+    this.chits = c.map((chitId) => findChit(chitId) as C).filter((d) => d);
+    this.dropTargets = d.map((dropIds: string[]) => {
+      const result = new DragTarget<any, C>();
+      result.chits = dropIds.map((chitId: string) => findChit(chitId)).filter((d) => d);
+      return result;
+    });
+  }
+
+  /** @internal */
+  resolveDetails({ chitId, targetChitId }: { chitId: string; targetChitId: string }): Promise<void> {
+    const selectedChit = this.chits.find((chit) => chit.id === chitId);
+    if (!selectedChit) {
+      throw new MismatchError();
+    }
+
+    for (const dropTarget of this.dropTargets) {
+      const targetChit = dropTarget.chits.find((chit) => chit.id === targetChitId);
+      if (targetChit) {
+        return Promise.resolve(dropTarget.cb(selectedChit, targetChit));
+      }
+    }
+    throw new MismatchError();
+  }
+
+  /** @internal */
+  stageIn(prompt: PickPrompt) {
+    this.chits.forEach((c) => {
+      c.dropTargets = this.dropTargets.flatMap((dt) => dt.chits);
+      c.onDrag = (droppedChit: Chit) => {
+        prompt.resolvePick(this, { chitId: c.id!, targetChitId: droppedChit.id! });
+      };
+    });
+  }
+
+  /** @internal */
+  stageOut() {
+    this.chits.forEach((c) => (c.onDrag = undefined));
+  }
+
+  /** @internal */
+  autoResolve(): Promise<void | undefined> {
+    const selectedChit = this.chits[0];
+    const targetChit = this.dropTargets[0].chits[0];
+    return Promise.resolve(this.dropTargets[0].cb(selectedChit, targetChit));
+  }
+
+  /** @internal */
+  numberOfChoices(): number {
+    return this.chits.length * this.dropTargets.reduce((sum, dt) => sum + dt.chits.length, 0);
+  }
+}
+
 export class ButtonPick extends Pick {
   /** @internal */
   type: PickType = "ButtonPick";

package/src/library/game/PlayerChit.ts

@@ -10,9 +10,21 @@ export class PlayerChit extends Chit {
 
   public playerId: string = "no id";
   public name: string = "no name";
-  public imageUrl?: string;
   public color: string = "#000000";
 
+  /** @internal */
+  private _imageUrl?: string = undefined;
+  get imageUrl() {
+    if (!this._imageUrl) {
+      const tempPlayerInfo = new PlayerInfo(this.playerId, this.name);
+      return tempPlayerInfo.generateAvatar();
+    }
+    return this._imageUrl;
+  }
+  set imageUrl(value: string | undefined) {
+    this._imageUrl = value;
+  }
+
   /** @internal */
   @NonEditable public matchScoreNumber?: number;
 

package/src/library/game/PlayerInfo.ts

@@ -8,10 +8,30 @@ export interface IPlayerInfo {
 }
 
 export class PlayerInfo {
-  public imageUrl?: string;
   public id: string;
   public name: string;
 
+  /** @internal */
+  public generateAvatar() {
+    if (!this._imageUrl && window?.URL) {
+      const data = multiavatar(`${this.name} ${this.id}`, true).replace("<svg", '<svg width="231" height="231"');
+      return `data:image/svg+xml;base64,${base64.encode(data)}`;
+    }
+    return undefined;
+  }
+
+  /** @internal */
+  private _imageUrl?: string;
+  get imageUrl() {
+    if (!this._imageUrl && window?.URL) {
+      return this.generateAvatar();
+    }
+    return this._imageUrl;
+  }
+  set imageUrl(value: string | undefined) {
+    this._imageUrl = value;
+  }
+
   constructor(idOrPlayerInfo: string | IPlayerInfo, name?: string) {
     if (typeof idOrPlayerInfo === "string") {
       this.id = idOrPlayerInfo;
@@ -23,8 +43,7 @@ export class PlayerInfo {
     }
 
     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)}`;
+      this.imageUrl = this.generateAvatar();
     }
   }
 }

package/src/library/game/Prompt.ts

@@ -4,7 +4,7 @@ import { Confirm, GameButton } from "./GameButton";
 import { ButtonPick, ChitPick, Pick } from "./Pick";
 import { MismatchError, Turn } from "./Turn";
 
-type PromptType = "SelectPrompt" | "ConfirmPrompt" | "PickPrompt" | "NoValidMovesPrompt";
+type PromptType = "PickPrompt" | "NoValidMovesPrompt";
 
 export type PromptSerialization = {
   type: PromptType;
@@ -97,10 +97,6 @@ export abstract class Prompt {
   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;
@@ -162,37 +158,6 @@ export class NoValidMovesPrompt extends Prompt {
   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 {

package/src/library/game/RootChit.ts

@@ -1,4 +1,4 @@
-import { NonEditable } from "../utilities/Annotations";
+import { NonEditable, getSelectableProperties, SelectablePropertyInfo } from "../utilities/Annotations";
 import { Chit } from "./Chit";
 import { DropdownChit } from "./DropdownChit";
 import { OrderedOutlet } from "./OrderedOutlet";
@@ -8,6 +8,9 @@ import { LayoutNode, createLayoutFromTree, PanelLayoutResult } from "../utilitie
 export type { PanelLayoutResult } from "../utilities/LayoutHelper";
 
 export class RootChit<P extends PlayerChit> extends Chit {
+  minPlayers = 2;
+  maxPlayers = 4;
+
   /** @internal */
   @NonEditable type = "root";
 
@@ -51,4 +54,41 @@ export class RootChit<P extends PlayerChit> extends Chit {
   public getDropdowns(): DropdownChit[] {
     return [];
   }
+
+  /** Sets up a demo game.  Returns the player count to use in the demo game.  */
+  public setupDemoGame(): number {
+    return this.minPlayers;
+  }
+
+  /**
+   * Gets all properties on this RootChit instance that are marked with the @Selectable decorator.
+   *
+   * @returns An array of SelectablePropertyInfo containing the field name, label, choices, and current value
+   */
+  /** @internal */
+  public getConfigurationOptions(): SelectablePropertyInfo[] {
+    return getSelectableProperties(this);
+  }
+
+  /** @internal */
+  public getCurrentlySelectedMatchOptions(): any {
+    const result = {};
+    const selectables = this.getConfigurationOptions();
+    for (const selectable of selectables) {
+      if ((this as any)[selectable.fieldName] !== undefined) {
+        (result as any)[selectable.fieldName] = (this as any)[selectable.fieldName];
+      }
+    }
+    return result;
+  }
+
+  /** @internal */
+  public processMatchOptions(options: any): void {
+    const selectables = this.getConfigurationOptions();
+    for (const selectable of selectables) {
+      if (options[selectable.fieldName] !== undefined) {
+        (this as any)[selectable.fieldName] = options[selectable.fieldName];
+      }
+    }
+  }
 }

package/src/library/game/Turn.ts

@@ -1,7 +1,6 @@
-import nextTick from "next-tick";
 import { Chit } from "./Chit";
 import { Match } from "./Match";
-import { NoValidMovesPrompt, PickPrompt, Prompt, SelectPrompt } from "./Prompt";
+import { NoValidMovesPrompt, PickPrompt, Prompt } from "./Prompt";
 import { PromptResponse, RngResponse, TurnState } from "./TurnState";
 import { ButtonPick, Pick } from "./Pick";
 import { Confirm, GameButton } from "./GameButton";
@@ -188,11 +187,8 @@ export class Turn<T, P extends PlayerChit, R extends RootChit<P>> {
    */
   async takeRng(count: number, message = "confirm draw or roll"): Promise<() => number> {
     await this.possiblyConfirm(message);
-    const results: number[] = [];
-    for (let i = 0; i < count; i++) {
-      results.push(this.state.getOrCreateRng(this.decisionIndex));
-      this.decisionIndex++;
-    }
+    const results: number[] = this.state.getOrCreateMultipleRng(this.decisionIndex, count);
+    this.decisionIndex++;
 
     let counter = 0;
     return () => {
@@ -249,6 +245,35 @@ export class Turn<T, P extends PlayerChit, R extends RootChit<P>> {
     step.log = message;
   }
 
+  /**
+   * Compress the history in the timeline such that a user with maybe many moves (and changing their minds) won't
+   * clock up the replay timeline.  Basically takes all of the flushes and smushes them together into a single flush.
+   * Importantly, it leaves the (maybe lots) of decisions on the decision stack.  This just compresses flushes into a single
+   * flush step.
+   *
+   * This should only be done immediately after every zippable action *or* after undos are no longer possible.
+   */
+  zip() {
+    this.flush();
+    let hasChange = false;
+    while (this.clockSteps.length >= 2) {
+      const lastStep = this.clockSteps[this.clockSteps.length - 1];
+      const previousStep = this.clockSteps[this.clockSteps.length - 2];
+      if (!(lastStep instanceof FlushClockStep) || !(previousStep instanceof FlushClockStep)) {
+        break;
+      }
+
+      previousStep.state = { ...previousStep.state, ...lastStep.state };
+      this.clockSteps.pop();
+      hasChange = true;
+    }
+
+    if (hasChange) {
+      this.pass++;
+      this.flush();
+    }
+  }
+
   /**
    * Scan all of the chits managed by this turn.  If any of them have changed, group them together into a
    * "ClockStep".  If any new chits appear, then add them to our lookup.  If any chits are deleted (orphaned),
@@ -416,7 +441,7 @@ export class Turn<T, P extends PlayerChit, R extends RootChit<P>> {
     this.activeSubTurns.push(turn);
 
     //make sure flow goes to next tick
-    await new Promise((resolve) => nextTick(() => resolve(true)));
+    await new Promise((resolve) => queueMicrotask(() => resolve(true)));
 
     await this.checkPause();
 
@@ -453,34 +478,6 @@ export class Turn<T, P extends PlayerChit, R extends RootChit<P>> {
     return await Promise.all(turns);
   }
 
-  /**
-   * Basic selection prompt.  All chits will appear as "selected" on the respective client.
-   * Upon clicking one, the prompt will resolve itself.
-   *
-   * @param chits The list of chits that can be selected from
-   * @returns The chit that the player selected
-   */
-  public async select(chits: Chit[]): Promise<Chit> {
-    if (chits.length === 1) {
-      return chits[0];
-    }
-
-    const prompt = new SelectPrompt();
-    prompt.chits = chits;
-
-    this.prepareForPrompt(prompt);
-
-    // make sure all of these chits are locked by us - otherwise someone has made a mistake.
-    chits.forEach((chit) => chit.confirmLock(this));
-
-    await this.waitForPromptResolution(prompt);
-    if (!prompt.selectedChit) {
-      throw new Error("Prompt should have selected chit response");
-    }
-
-    return prompt.selectedChit;
-  }
-
   /**
    * If a player has gotten themselves into a corner - i.e. no valid moves - this prompt will
    * simply inform them of that and allow them to undo.
@@ -603,7 +600,7 @@ export class Turn<T, P extends PlayerChit, R extends RootChit<P>> {
       this.pause();
 
       // defer to next tick on starting
-      await new Promise<void>((resolve) => nextTick(() => resolve()));
+      await new Promise<void>((resolve) => queueMicrotask(() => resolve()));
 
       const instructions = this.handleNewSavedState(state);
 
@@ -615,7 +612,7 @@ export class Turn<T, P extends PlayerChit, R extends RootChit<P>> {
           instruction.turn.rerun(instruction.turn);
         } else if (instruction.type === "prompt") {
           await new Promise<void>((resolve, reject) =>
-            nextTick(() => {
+            queueMicrotask(() => {
               if (instruction.turn.unresolvedPrompt !== instruction.prompt) {
                 reject("waiting on incorrect prompt");
               }
@@ -627,7 +624,7 @@ export class Turn<T, P extends PlayerChit, R extends RootChit<P>> {
       }
 
       // always defer to next tick again when resuming
-      await new Promise<void>((resolve) => nextTick(() => resolve()));
+      await new Promise<void>((resolve) => queueMicrotask(() => resolve()));
     } finally {
       this.unpause();
       this.isProcessingSavedState = false;
@@ -922,7 +919,7 @@ export class Turn<T, P extends PlayerChit, R extends RootChit<P>> {
     await this.checkPause(); // state could have gotten funky here?  if we have a resolution already? maybe not so bad?
 
     if (resolution.response !== undefined) {
-      await new Promise((resolve) => nextTick(() => resolve(true))); // defer to next tick to make sure replay works identically
+      await new Promise((resolve) => queueMicrotask(() => resolve(true))); // defer to next tick to make sure replay works identically
       prompt.resolve(resolution.response);
     } else {
       if (this.player.promptStatus.latestPrompt.value) {

package/src/library/game/TurnState.ts

@@ -8,7 +8,7 @@ export type PromptResponse = {
   timestamp: Date;
 };
 
-export type RngResponse = { readonly type: "rng"; value: number };
+export type RngResponse = { readonly type: "rng"; value: number[] };
 
 export type Decision = PromptResponse | RngResponse | TurnState;
 
@@ -66,12 +66,12 @@ export class TurnState {
       if (result.type !== "rng") {
         throw new MismatchError();
       }
-      return (result as RngResponse).value;
+      return (result as RngResponse).value[0];
     } else if (index === this.decisions.length) {
       const rng = Math.random();
       this.decisions.push({
         type: "rng",
-        value: rng,
+        value: [rng],
       });
       return rng;
     } else {
@@ -79,6 +79,25 @@ export class TurnState {
     }
   }
 
+  public getOrCreateMultipleRng(index: number, count: number): number[] {
+    if (index < this.decisions.length) {
+      const result = this.decisions[index];
+      if (result.type !== "rng" || result.value.length !== count) {
+        throw new MismatchError();
+      }
+      return (result as RngResponse).value;
+    } else if (index === this.decisions.length) {
+      const rngs = Array.from({ length: count }, () => Math.random());
+      this.decisions.push({
+        type: "rng",
+        value: rngs,
+      });
+      return rngs;
+    } else {
+      throw new MismatchError();
+    }
+  }
+
   public getOrCreateTurnState(index: number): TurnState {
     if (index < this.decisions.length) {
       const result = this.decisions[index];

package/src/library/game/badAiTransport/BadAIClientPrompts.ts

@@ -0,0 +1,60 @@
+import { ClockDetails } from "../ClockDetails";
+import { Connection } from "../Connection";
+import { ConnectionObject } from "../ConnectionObject";
+import { PickType } from "../Pick";
+import { PlayerChit } from "../PlayerChit";
+import { PromptSerialization } from "../Prompt";
+import { RootChit } from "../RootChit";
+import { ServerPrompts } from "../serverTransport/ServerPrompts";
+
+export class BadAIClientPrompts<P extends PlayerChit, R extends RootChit<P>> extends ConnectionObject {
+  private serverPrompts: ServerPrompts<P, R>;
+
+  constructor(
+    private playerId: string,
+    private connection: Connection,
+  ) {
+    super();
+
+    this.serverPrompts = connection.get<ServerPrompts<P, R>>("ServerPrompts");
+  }
+
+  public async setPromptForPlayer(playerId: string, prompt?: PromptSerialization, clockDetails?: ClockDetails) {
+    console.log("Setting prompt for player", playerId, prompt, clockDetails);
+    if (prompt && playerId === this.playerId) {
+      if (prompt.type === "PickPrompt") {
+        const picks = prompt.details.picks;
+        const pickIndex = Math.floor(Math.random() * picks.length);
+        const pick = picks[pickIndex];
+        switch (pick.type as PickType) {
+          case "ButtonPick": {
+            await this.serverPrompts.resolvePrompt({
+              idx: pickIndex,
+            });
+            break;
+          }
+          case "ChitPick": {
+            await this.serverPrompts.resolvePrompt({
+              idx: pickIndex,
+              value: pick.details.c[Math.floor(Math.random() * pick.details.c.length)],
+            });
+            break;
+          }
+          case "DragPick": {
+            const target = pick.details.d[Math.floor(Math.random() * pick.details.d.length)];
+            await this.serverPrompts.resolvePrompt({
+              idx: pickIndex,
+              value: {
+                chitId: pick.details.c[Math.floor(Math.random() * pick.details.c.length)],
+                targetChitId: target[Math.floor(Math.random() * target.length)],
+              },
+            });
+            break;
+          }
+        }
+      } else if (prompt.type === "NoValidMovesPrompt") {
+        await this.serverPrompts.stepBackPrompt(false);
+      }
+    }
+  }
+}

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

@@ -153,7 +153,7 @@ export class ClientTime extends ConnectionObject {
 
     // make sure nothing changed while we were waiting...
     if (this.clientTimeState.targetClock.value === newTargetClock && currentClock === this.currentClock.value) {
-      if (newTargetClock > this.startTime) {
+      if (newTargetClock >= this.startTime) {
         this.clientTimeState.isLoading.value = false;
       }