@dreamboard-games/sdk 0.2.1-alpha.1 → 0.3.0-alpha.1

package/src/reducer/bundle/trusted/engine-instruction-resolver.ts

@@ -1,254 +0,0 @@
-import type { DispatchTraceEntry, TrustedRuntimeInput } from "../../core/types";
-import type { RuntimeInstructionForState } from "../../core/runtime-instruction";
-import type {
-  PhaseMapOf,
-  ReducerGameContractLike,
-  ViewMapOf,
-} from "../../model";
-import {
-  cloneRuntimeTable,
-  ensureArray,
-  shufflePlayerZoneCards,
-} from "../../table-ops";
-import {
-  sampleDieValue,
-  shuffleWithRng,
-  type RngConsumption,
-} from "./rng-sampler";
-import type {
-  TrustedInput,
-  TrustedPlayerId,
-  TrustedState,
-} from "./runtime-scope";
-
-function toRngTrace<
-  State,
-  PlayerId extends string,
-  ReducerInput extends TrustedRuntimeInput<PlayerId>,
->(
-  consumptions: readonly RngConsumption[],
-): DispatchTraceEntry<State, PlayerId, ReducerInput>[] {
-  return consumptions.map((consumption) => ({
-    type: "rngConsumption" as const,
-    operation: consumption.operation,
-    traceEntry: consumption.traceEntry,
-  }));
-}
-
-export function createEngineInstructionResolver<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
->() {
-  type State = TrustedState<Contract>;
-  type PlayerId = TrustedPlayerId<Contract>;
-  type ReducerInput = TrustedInput<Contract>;
-
-  function resolveRollDie(
-    state: State,
-    instruction: Extract<
-      RuntimeInstructionForState<State>,
-      { kind: "engine.rollDie" }
-    >,
-  ): {
-    state: State;
-    queuedInputs: ReducerInput[];
-    queuedInstructions: RuntimeInstructionForState<State>[];
-    trace: DispatchTraceEntry<State, PlayerId, ReducerInput>[];
-  } {
-    const die = state.table.dice[instruction.dieId];
-    if (!die) {
-      throw new Error(`Cannot roll unknown die '${instruction.dieId}'.`);
-    }
-    if (!Number.isInteger(die.sides) || die.sides <= 0) {
-      throw new Error(
-        `Cannot roll die '${instruction.dieId}' with invalid sides '${die.sides}'.`,
-      );
-    }
-    const nextTable = cloneRuntimeTable(state.table);
-    const sampled = sampleDieValue(die.sides, state.runtime.rng);
-    nextTable.dice[instruction.dieId] = {
-      ...die,
-      value: sampled.value,
-    };
-    const queuedInputs: ReducerInput[] = instruction.continuation
-      ? [
-          {
-            kind: "continuation",
-            continuationId: instruction.continuation.id,
-            resumeData: instruction.continuation.data,
-            source: "effect",
-            effectKind: "rollDie",
-            response: {
-              dieId: instruction.dieId,
-              value: sampled.value,
-            },
-          } as unknown as ReducerInput,
-        ]
-      : [];
-    return {
-      state: {
-        ...state,
-        table: nextTable,
-        runtime: {
-          ...state.runtime,
-          rng: sampled.nextRng,
-        },
-      },
-      queuedInputs,
-      queuedInstructions: [],
-      trace: toRngTrace<State, PlayerId, ReducerInput>([sampled.consumption]),
-    };
-  }
-
-  function resolveShuffleSharedZone(
-    state: State,
-    instruction: Extract<
-      RuntimeInstructionForState<State>,
-      { kind: "engine.shuffleSharedZone" }
-    >,
-  ): {
-    state: State;
-    queuedInputs: ReducerInput[];
-    queuedInstructions: RuntimeInstructionForState<State>[];
-    trace: DispatchTraceEntry<State, PlayerId, ReducerInput>[];
-  } {
-    const nextTable = cloneRuntimeTable(state.table);
-    const deckCards = [...ensureArray(nextTable.decks[instruction.zoneId])];
-    const shuffled = shuffleWithRng(deckCards, state.runtime.rng);
-    const orderedCardIds = [...shuffled.orderedValues];
-    nextTable.decks[instruction.zoneId] = shuffled.orderedValues;
-    nextTable.zones.shared[instruction.zoneId] = [...shuffled.orderedValues];
-    for (const [index, cardId] of shuffled.orderedValues.entries()) {
-      const currentLocation = nextTable.componentLocations[cardId];
-      nextTable.componentLocations[cardId] =
-        currentLocation?.type === "InDeck" || currentLocation?.type === "InZone"
-          ? {
-              ...currentLocation,
-              type: "InDeck",
-              deckId: instruction.zoneId,
-              playedBy: currentLocation.playedBy ?? null,
-              position: index,
-            }
-          : {
-              type: "InDeck",
-              deckId: instruction.zoneId,
-              playedBy: null,
-              position: index,
-            };
-    }
-    const queuedInputs: ReducerInput[] = instruction.continuation
-      ? [
-          {
-            kind: "continuation",
-            continuationId: instruction.continuation.id,
-            resumeData: instruction.continuation.data,
-            source: "effect",
-            effectKind: "shuffleSharedZone",
-            response: {
-              zoneId: instruction.zoneId,
-              orderedCardIds,
-            },
-          } as unknown as ReducerInput,
-        ]
-      : [];
-    return {
-      state: {
-        ...state,
-        table: nextTable,
-        runtime: {
-          ...state.runtime,
-          rng: shuffled.nextRng,
-        },
-      },
-      queuedInputs,
-      queuedInstructions: [],
-      trace: toRngTrace<State, PlayerId, ReducerInput>(shuffled.consumptions),
-    };
-  }
-
-  function resolveShufflePlayerZone(
-    state: State,
-    instruction: Extract<
-      RuntimeInstructionForState<State>,
-      { kind: "engine.shufflePlayerZone" }
-    >,
-  ): {
-    state: State;
-    queuedInputs: ReducerInput[];
-    queuedInstructions: RuntimeInstructionForState<State>[];
-    trace: DispatchTraceEntry<State, PlayerId, ReducerInput>[];
-  } {
-    const nextTable = cloneRuntimeTable(state.table);
-    const zoneCards = shufflePlayerZoneCards(
-      nextTable,
-      instruction.zoneId,
-      instruction.playerId,
-    );
-    const shuffled = shuffleWithRng(
-      zoneCards,
-      state.runtime.rng,
-      "shufflePlayerZone",
-    );
-    const orderedCardIds = [...shuffled.orderedValues];
-    shufflePlayerZoneCards(
-      nextTable,
-      instruction.zoneId,
-      instruction.playerId,
-      orderedCardIds,
-    );
-    for (const [index, cardId] of orderedCardIds.entries()) {
-      const currentLocation = nextTable.componentLocations[cardId];
-      nextTable.componentLocations[cardId] =
-        currentLocation?.type === "InHand"
-          ? {
-              ...currentLocation,
-              type: "InHand",
-              handId: instruction.zoneId,
-              playerId: instruction.playerId,
-              position: index,
-            }
-          : {
-              type: "InHand",
-              handId: instruction.zoneId,
-              playerId: instruction.playerId,
-              position: index,
-            };
-    }
-    const queuedInputs: ReducerInput[] = instruction.continuation
-      ? [
-          {
-            kind: "continuation",
-            continuationId: instruction.continuation.id,
-            resumeData: instruction.continuation.data,
-            source: "effect",
-            effectKind: "shufflePlayerZone",
-            response: {
-              zoneId: instruction.zoneId,
-              playerId: instruction.playerId,
-              orderedCardIds,
-            },
-          } as unknown as ReducerInput,
-        ]
-      : [];
-    return {
-      state: {
-        ...state,
-        table: nextTable,
-        runtime: {
-          ...state.runtime,
-          rng: shuffled.nextRng,
-        },
-      },
-      queuedInputs,
-      queuedInstructions: [],
-      trace: toRngTrace<State, PlayerId, ReducerInput>(shuffled.consumptions),
-    };
-  }
-
-  return {
-    resolveRollDie,
-    resolveShuffleSharedZone,
-    resolveShufflePlayerZone,
-  };
-}

package/src/reducer/bundle/trusted/flow-instruction-resolver.ts

@@ -1,73 +0,0 @@
-import type { DispatchTraceEntry } from "../../core/types";
-import type { RuntimeInstructionForState } from "../../core/runtime-instruction";
-import type {
-  PhaseMapOf,
-  ReducerGameContractLike,
-  ViewMapOf,
-} from "../../model";
-import type { createLifecycleRunner } from "./lifecycle-runner";
-import type {
-  TrustedInput,
-  TrustedPhaseName,
-  TrustedPlayerId,
-  TrustedState,
-} from "./runtime-scope";
-
-type LifecycleRunnerFor<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
-> = ReturnType<typeof createLifecycleRunner<Contract, Definitions, Views>>;
-
-export function createFlowInstructionResolver<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
->(lifecycle: LifecycleRunnerFor<Contract, Definitions, Views>) {
-  type State = TrustedState<Contract>;
-  type PhaseName = TrustedPhaseName<Contract, Definitions, Views>;
-  type PlayerId = TrustedPlayerId<Contract>;
-  type ReducerInput = TrustedInput<Contract>;
-
-  function resolveTransition(
-    state: State,
-    instruction: Extract<
-      RuntimeInstructionForState<State>,
-      { kind: "flow.transition" }
-    >,
-  ): {
-    state: State;
-    queuedInputs: ReducerInput[];
-    queuedInstructions: RuntimeInstructionForState<State>[];
-    trace: DispatchTraceEntry<State, PlayerId, ReducerInput>[];
-  } {
-    const initialized = lifecycle.initializePhaseResult(
-      {
-        ...state,
-        flow: {
-          ...state.flow,
-          currentPhase:
-            instruction.to as unknown as State["flow"]["currentPhase"],
-        },
-        runtime: {
-          ...state.runtime,
-          lastTransition: {
-            from: state.flow.currentPhase,
-            to: instruction.to,
-          },
-        } as State["runtime"],
-      },
-      instruction.to as PhaseName,
-    );
-    return {
-      state: initialized.state,
-      queuedInputs: [],
-      queuedInstructions: initialized.instructions,
-      trace: [],
-    };
-  }
-
-  return {
-    resolveTransition,
-  };
-}