@dreamboard-games/sdk 0.2.0

package/src/reducer/setup-bootstrap-helpers.ts

@@ -0,0 +1,171 @@
+import type {
+  CardIdOfManifest,
+  DieIdOfManifest,
+  GeneratedManifestContractLike,
+  PieceIdOfManifest,
+  PlayerIdOfManifest,
+  SetupBootstrapContainerRef,
+  SetupBootstrapPerPlayerContainerTemplateRef,
+  SetupBootstrapStep,
+  SetupBootstrapDestinationRef,
+} from "./model";
+
+export function shuffle<
+  Manifest extends GeneratedManifestContractLike =
+    GeneratedManifestContractLike,
+>(
+  container: SetupBootstrapContainerRef<Manifest>,
+): SetupBootstrapStep<Manifest> {
+  return {
+    type: "shuffle",
+    container,
+  };
+}
+
+export function dealToPlayerZone<
+  Manifest extends GeneratedManifestContractLike =
+    GeneratedManifestContractLike,
+>({
+  from,
+  zoneId,
+  count,
+  playerIds,
+}: {
+  from: Extract<
+    SetupBootstrapContainerRef<Manifest>,
+    { type: "sharedZone" | "sharedBoardContainer" }
+  >;
+  zoneId: Extract<
+    SetupBootstrapPerPlayerContainerTemplateRef<Manifest>,
+    { type: "playerZone" }
+  >["zoneId"];
+  count: number;
+  playerIds?: readonly PlayerIdOfManifest<Manifest>[];
+}): SetupBootstrapStep<Manifest> {
+  return {
+    type: "deal",
+    from,
+    to: {
+      type: "playerZone",
+      zoneId,
+    } as SetupBootstrapPerPlayerContainerTemplateRef<Manifest>,
+    count,
+    playerIds,
+  };
+}
+
+export function dealToPlayerBoardContainer<
+  Manifest extends GeneratedManifestContractLike =
+    GeneratedManifestContractLike,
+>({
+  from,
+  boardId,
+  containerId,
+  count,
+  playerIds,
+}: {
+  from: Extract<
+    SetupBootstrapContainerRef<Manifest>,
+    { type: "sharedZone" | "sharedBoardContainer" }
+  >;
+  boardId: Extract<
+    SetupBootstrapPerPlayerContainerTemplateRef<Manifest>,
+    { type: "playerBoardContainer" }
+  >["boardId"];
+  containerId: Extract<
+    SetupBootstrapPerPlayerContainerTemplateRef<Manifest>,
+    { type: "playerBoardContainer" }
+  >["containerId"];
+  count: number;
+  playerIds?: readonly PlayerIdOfManifest<Manifest>[];
+}): SetupBootstrapStep<Manifest> {
+  return {
+    type: "deal",
+    from,
+    to: {
+      type: "playerBoardContainer",
+      boardId,
+      containerId,
+    } as SetupBootstrapPerPlayerContainerTemplateRef<Manifest>,
+    count,
+    playerIds,
+  };
+}
+
+export function seedSharedBoardContainer<
+  Manifest extends GeneratedManifestContractLike =
+    GeneratedManifestContractLike,
+>({
+  from,
+  boardId,
+  containerId,
+  count,
+  componentIds,
+}: {
+  from: SetupBootstrapContainerRef<Manifest>;
+  boardId: Extract<
+    SetupBootstrapDestinationRef<Manifest>,
+    { type: "sharedBoardContainer" }
+  >["boardId"];
+  containerId: Extract<
+    SetupBootstrapDestinationRef<Manifest>,
+    { type: "sharedBoardContainer" }
+  >["containerId"];
+  count?: number;
+  componentIds?: readonly (
+    | CardIdOfManifest<Manifest>
+    | PieceIdOfManifest<Manifest>
+    | DieIdOfManifest<Manifest>
+  )[];
+}): SetupBootstrapStep<Manifest> {
+  return {
+    type: "move",
+    from,
+    to: {
+      type: "sharedBoardContainer",
+      boardId,
+      containerId,
+    } as SetupBootstrapDestinationRef<Manifest>,
+    count,
+    componentIds,
+  };
+}
+
+export function seedSharedBoardSpace<
+  Manifest extends GeneratedManifestContractLike =
+    GeneratedManifestContractLike,
+>({
+  from,
+  boardId,
+  spaceId,
+  count,
+  componentIds,
+}: {
+  from: SetupBootstrapContainerRef<Manifest>;
+  boardId: Extract<
+    SetupBootstrapDestinationRef<Manifest>,
+    { type: "sharedBoardSpace" }
+  >["boardId"];
+  spaceId: Extract<
+    SetupBootstrapDestinationRef<Manifest>,
+    { type: "sharedBoardSpace" }
+  >["spaceId"];
+  count?: number;
+  componentIds?: readonly (
+    | CardIdOfManifest<Manifest>
+    | PieceIdOfManifest<Manifest>
+    | DieIdOfManifest<Manifest>
+  )[];
+}): SetupBootstrapStep<Manifest> {
+  return {
+    type: "move",
+    from,
+    to: {
+      type: "sharedBoardSpace",
+      boardId,
+      spaceId,
+    } as SetupBootstrapDestinationRef<Manifest>,
+    count,
+    componentIds,
+  };
+}

package/src/reducer/setup-bootstrap.ts

@@ -0,0 +1,481 @@
+import {
+  assertCardAllowedInContainer,
+  assertCardAllowedInZone,
+  cloneRuntimeTable,
+  ensureArray,
+  getComponentsInContainer,
+  getComponentsOnSpace,
+} from "./table-ops";
+import { nextRandomInt } from "./rng";
+import type {
+  RuntimeComponentLocation,
+  RuntimeRngState,
+  RuntimeTableRecord,
+  SetupBootstrapContainerRef,
+  SetupBootstrapDestinationRef,
+  SetupBootstrapPerPlayerContainerTemplateRef,
+  SetupBootstrapStep,
+} from "./model";
+import type { PlayerId } from "./per-player";
+import { perPlayerGet, perPlayerSet } from "./per-player";
+
+type StatefulBootstrapContext = {
+  table: RuntimeTableRecord;
+  runtime: {
+    rng: RuntimeRngState;
+  };
+};
+
+type ResolvedSharedZoneRef = {
+  kind: "sharedZone";
+  zoneId: string;
+};
+
+type ResolvedPlayerZoneRef = {
+  kind: "playerZone";
+  zoneId: string;
+  playerId: string;
+};
+
+type ResolvedBoardZoneRef = {
+  kind: "container";
+  boardId: string;
+  containerId: string;
+  zoneId: string;
+};
+
+type ResolvedBoardSpaceRef = {
+  kind: "space";
+  boardId: string;
+  spaceId: string;
+};
+
+type ResolvedContainerRef =
+  | ResolvedSharedZoneRef
+  | ResolvedPlayerZoneRef
+  | ResolvedBoardZoneRef
+  | ResolvedBoardSpaceRef;
+
+function isCardComponent(
+  table: RuntimeTableRecord,
+  componentId: string,
+): boolean {
+  return componentId in table.cards;
+}
+
+function resolveRuntimeBoardId(
+  table: RuntimeTableRecord,
+  boardId: string,
+  playerId?: string,
+): string {
+  if (playerId) {
+    const perPlayerBoardId = `${boardId}:${playerId}`;
+    if (table.boards.byId[perPlayerBoardId]) {
+      return perPlayerBoardId;
+    }
+  }
+  if (table.boards.byId[boardId]) {
+    return boardId;
+  }
+  throw new Error(`Unknown board '${boardId}'.`);
+}
+
+function resolveContainerRef(
+  table: RuntimeTableRecord,
+  ref: SetupBootstrapContainerRef | SetupBootstrapDestinationRef,
+): ResolvedContainerRef {
+  if (ref.type === "sharedZone") {
+    return {
+      kind: "sharedZone",
+      zoneId: ref.zoneId,
+    };
+  }
+
+  if (ref.type === "playerZone") {
+    return {
+      kind: "playerZone",
+      zoneId: ref.zoneId,
+      playerId: ref.playerId,
+    };
+  }
+
+  if (ref.type === "sharedBoardContainer") {
+    const board = table.boards.byId[resolveRuntimeBoardId(table, ref.boardId)];
+    const container = board?.containers[ref.containerId];
+    if (!container) {
+      throw new Error(
+        `Unknown board container '${ref.containerId}' on board '${ref.boardId}'.`,
+      );
+    }
+    return {
+      kind: "container",
+      boardId: board.id,
+      containerId: ref.containerId,
+      zoneId: container.zoneId,
+    };
+  }
+
+  if (ref.type === "playerBoardContainer") {
+    const board =
+      table.boards.byId[
+        resolveRuntimeBoardId(table, ref.boardId, ref.playerId)
+      ];
+    const container = board?.containers[ref.containerId];
+    if (!container) {
+      throw new Error(
+        `Unknown board container '${ref.containerId}' on board '${ref.boardId}' for '${ref.playerId}'.`,
+      );
+    }
+    return {
+      kind: "container",
+      boardId: board.id,
+      containerId: ref.containerId,
+      zoneId: container.zoneId,
+    };
+  }
+
+  if (ref.type === "sharedBoardSpace") {
+    const board = table.boards.byId[resolveRuntimeBoardId(table, ref.boardId)];
+    if (!board) {
+      throw new Error(`Unknown board '${ref.boardId}'.`);
+    }
+    const space = board?.spaces[ref.spaceId];
+    if (!space) {
+      throw new Error(
+        `Unknown board space '${ref.spaceId}' on board '${ref.boardId}'.`,
+      );
+    }
+    return {
+      kind: "space",
+      boardId: board.id,
+      spaceId: ref.spaceId,
+    };
+  }
+
+  const board =
+    table.boards.byId[resolveRuntimeBoardId(table, ref.boardId, ref.playerId)];
+  if (!board) {
+    throw new Error(
+      `Unknown board '${ref.boardId}' for player '${ref.playerId}'.`,
+    );
+  }
+  const space = board?.spaces[ref.spaceId];
+  if (!space) {
+    throw new Error(
+      `Unknown board space '${ref.spaceId}' on board '${ref.boardId}' for '${ref.playerId}'.`,
+    );
+  }
+  return {
+    kind: "space",
+    boardId: board.id,
+    spaceId: ref.spaceId,
+  };
+}
+
+function readContainerComponents(
+  table: RuntimeTableRecord,
+  ref: ResolvedContainerRef,
+): string[] {
+  if (ref.kind === "sharedZone") {
+    return [
+      ...ensureArray(table.zones.shared[ref.zoneId] ?? table.decks[ref.zoneId]),
+    ];
+  }
+
+  if (ref.kind === "playerZone") {
+    const zoneValue = table.zones.perPlayer[ref.zoneId];
+    const handValue = table.hands[ref.zoneId];
+    const seat = ref.playerId as PlayerId;
+    return [
+      ...ensureArray(
+        (zoneValue !== undefined ? perPlayerGet(zoneValue, seat) : undefined) ??
+          (handValue !== undefined ? perPlayerGet(handValue, seat) : undefined),
+      ),
+    ];
+  }
+
+  if (ref.kind === "space") {
+    return getComponentsOnSpace(table, ref.boardId, ref.spaceId);
+  }
+
+  return getComponentsInContainer(table, ref.boardId, ref.containerId);
+}
+
+function sharedZoneLocationFor(
+  table: RuntimeTableRecord,
+  componentId: string,
+  zoneId: string,
+  position: number,
+): RuntimeComponentLocation {
+  if (isCardComponent(table, componentId)) {
+    return {
+      type: "InDeck",
+      deckId: zoneId,
+      playedBy: null,
+      position,
+    };
+  }
+
+  return {
+    type: "InZone",
+    zoneId,
+    playedBy: null,
+    position,
+  };
+}
+
+function updateCardVisibilityForZone(
+  table: RuntimeTableRecord,
+  componentId: string,
+  ref: ResolvedContainerRef,
+): void {
+  if (!isCardComponent(table, componentId)) {
+    return;
+  }
+
+  if (ref.kind === "playerZone") {
+    const visibility = table.zones.visibility[ref.zoneId];
+    table.ownerOfCard[componentId] = ref.playerId;
+    table.visibility[componentId] =
+      visibility === "all" || visibility === "public"
+        ? { faceUp: true }
+        : { faceUp: false, visibleTo: [ref.playerId] };
+    return;
+  }
+
+  if (ref.kind === "sharedZone") {
+    const visibility = table.zones.visibility[ref.zoneId];
+    if (visibility === "hidden" || visibility === "ownerOnly") {
+      table.visibility[componentId] = { faceUp: false };
+      return;
+    }
+    table.visibility[componentId] = { faceUp: true };
+  }
+}
+
+function writeContainerComponents(
+  table: RuntimeTableRecord,
+  ref: ResolvedContainerRef,
+  componentIds: readonly string[],
+): void {
+  if (ref.kind === "sharedZone") {
+    componentIds.forEach((componentId) => {
+      assertCardAllowedInZone(table, ref.zoneId, componentId);
+    });
+    table.decks[ref.zoneId] = [...componentIds];
+    table.zones.shared[ref.zoneId] = [...componentIds];
+    componentIds.forEach((componentId, index) => {
+      table.componentLocations[componentId] = sharedZoneLocationFor(
+        table,
+        componentId,
+        ref.zoneId,
+        index,
+      );
+      updateCardVisibilityForZone(table, componentId, ref);
+    });
+    return;
+  }
+
+  if (ref.kind === "playerZone") {
+    componentIds.forEach((componentId) => {
+      assertCardAllowedInZone(table, ref.zoneId, componentId);
+    });
+    const seat = ref.playerId as PlayerId;
+    const prevHand = table.hands[ref.zoneId] ?? {
+      __perPlayer: true as const,
+      entries: [],
+    };
+    table.hands[ref.zoneId] = perPlayerSet(prevHand, seat, [...componentIds]);
+
+    const prevZone = table.zones.perPlayer[ref.zoneId] ?? {
+      __perPlayer: true as const,
+      entries: [],
+    };
+    table.zones.perPlayer[ref.zoneId] = perPlayerSet(prevZone, seat, [
+      ...componentIds,
+    ]);
+
+    componentIds.forEach((componentId, index) => {
+      table.componentLocations[componentId] = {
+        type: "InHand",
+        handId: ref.zoneId,
+        playerId: ref.playerId,
+        position: index,
+      };
+      updateCardVisibilityForZone(table, componentId, ref);
+    });
+    return;
+  }
+
+  if (ref.kind === "space") {
+    componentIds.forEach((componentId, index) => {
+      table.componentLocations[componentId] = {
+        type: "OnSpace",
+        boardId: ref.boardId,
+        spaceId: ref.spaceId,
+        position: index,
+      };
+    });
+    return;
+  }
+
+  componentIds.forEach((componentId) => {
+    assertCardAllowedInContainer(
+      table,
+      ref.boardId,
+      ref.containerId,
+      componentId,
+    );
+  });
+  componentIds.forEach((componentId, index) => {
+    table.componentLocations[componentId] = {
+      type: "InContainer",
+      boardId: ref.boardId,
+      containerId: ref.containerId,
+      position: index,
+    };
+  });
+}
+
+function selectMovedComponents(
+  current: readonly string[],
+  step: Extract<SetupBootstrapStep, { type: "move" }>,
+): string[] {
+  if (step.componentIds && typeof step.count === "number") {
+    throw new Error(
+      "Setup bootstrap move step cannot specify both count and componentIds.",
+    );
+  }
+
+  if (step.componentIds) {
+    const missing = step.componentIds.filter(
+      (componentId) => !current.includes(componentId),
+    );
+    if (missing.length > 0) {
+      throw new Error(
+        `Setup bootstrap move step references missing components: ${missing.join(", ")}`,
+      );
+    }
+    return [...step.componentIds];
+  }
+
+  if (typeof step.count === "number") {
+    return current.slice(0, step.count);
+  }
+
+  return [...current];
+}
+
+function resolveDealTargetRef(
+  table: RuntimeTableRecord,
+  ref: SetupBootstrapPerPlayerContainerTemplateRef,
+  playerId: string,
+): ResolvedContainerRef {
+  if (ref.type === "playerZone") {
+    return {
+      kind: "playerZone",
+      zoneId: ref.zoneId,
+      playerId,
+    };
+  }
+
+  const board =
+    table.boards.byId[resolveRuntimeBoardId(table, ref.boardId, playerId)];
+  const container = board?.containers[ref.containerId];
+  if (!container) {
+    throw new Error(
+      `Unknown board container '${ref.containerId}' on board '${ref.boardId}' for '${playerId}'.`,
+    );
+  }
+  return {
+    kind: "container",
+    boardId: board.id,
+    containerId: ref.containerId,
+    zoneId: container.zoneId,
+  };
+}
+
+export function applySetupBootstrap<State extends StatefulBootstrapContext>(
+  state: State,
+  steps: readonly SetupBootstrapStep[],
+): State {
+  if (steps.length === 0) {
+    return state;
+  }
+
+  const nextTable = cloneRuntimeTable(state.table);
+  let nextRng = state.runtime.rng;
+
+  for (const step of steps) {
+    if (step.type === "shuffle") {
+      const container = resolveContainerRef(nextTable, step.container);
+      const shuffled = readContainerComponents(nextTable, container);
+      for (let lastIndex = shuffled.length - 1; lastIndex > 0; lastIndex -= 1) {
+        const [swapIndex, updatedRng] = nextRandomInt(lastIndex + 1, nextRng);
+        nextRng = updatedRng;
+        const current = shuffled[lastIndex];
+        const swap = shuffled[swapIndex];
+        if (current === undefined || swap === undefined) {
+          throw new Error(
+            `setup shuffle: invalid index (lastIndex=${lastIndex}, swapIndex=${swapIndex}, length=${shuffled.length})`,
+          );
+        }
+        shuffled[lastIndex] = swap;
+        shuffled[swapIndex] = current;
+      }
+      writeContainerComponents(nextTable, container, shuffled);
+      continue;
+    }
+
+    if (step.type === "move") {
+      const from = resolveContainerRef(nextTable, step.from);
+      const to = resolveContainerRef(nextTable, step.to);
+      const currentFrom = readContainerComponents(nextTable, from);
+      const moved = selectMovedComponents(currentFrom, step);
+      const remaining = currentFrom.filter(
+        (componentId) => !moved.includes(componentId),
+      );
+      const currentTo = readContainerComponents(nextTable, to);
+
+      writeContainerComponents(nextTable, from, remaining);
+      writeContainerComponents(nextTable, to, [...currentTo, ...moved]);
+      continue;
+    }
+
+    const from = resolveContainerRef(nextTable, step.from);
+    if (from.kind === "playerZone") {
+      throw new Error(
+        "Setup bootstrap deal steps require a shared source container.",
+      );
+    }
+    const playerIds = step.playerIds
+      ? [...step.playerIds]
+      : [...nextTable.playerOrder];
+    let sourceComponents = readContainerComponents(nextTable, from);
+
+    for (const playerId of playerIds) {
+      if (sourceComponents.length === 0) {
+        break;
+      }
+      const dealt = sourceComponents.slice(0, step.count);
+      if (dealt.length === 0) {
+        break;
+      }
+      sourceComponents = sourceComponents.slice(dealt.length);
+      const target = resolveDealTargetRef(nextTable, step.to, playerId);
+      const currentTo = readContainerComponents(nextTable, target);
+      writeContainerComponents(nextTable, target, [...currentTo, ...dealt]);
+    }
+
+    writeContainerComponents(nextTable, from, sourceComponents);
+  }
+
+  return {
+    ...state,
+    table: nextTable,
+    runtime: {
+      ...state.runtime,
+      rng: nextRng,
+    },
+  };
+}