@dreamboard-games/sdk 0.2.0

package/src/reducer/table-queries.ts

@@ -0,0 +1,372 @@
+import type {
+  BoardContainerIdOfTable,
+  BoardIdOfTable,
+  BoardTypeIdOfTable,
+  CardIdOfTable,
+  ComponentDataOfTable,
+  ComponentIdOfTable,
+  DeckIdOfTable,
+  HandIdOfTable,
+  HexBoardIdOfTable,
+  HexSpaceIdOfTable,
+  PlayerIdOfTable,
+  RelationTypeIdOfTable,
+  RuntimeTableRecord,
+  SpaceIdOfTable,
+  SpaceTypeIdOfTable,
+  SquareBoardIdOfTable,
+  SquareSpaceIdOfTable,
+  TableQueries,
+  TableQueriesOfState,
+  TiledBoardIdOfTable,
+  TiledEdgeIdOfTable,
+  TiledEdgeTypeIdOfTable,
+  TiledVertexIdOfTable,
+  TiledVertexTypeIdOfTable,
+} from "./model";
+import {
+  getAdjacentSpaces,
+  getAllPlayerZoneCards,
+  getAllSharedZoneCards,
+  getBoard,
+  getBoardsByTypeId,
+  getCard,
+  getCardsById,
+  getCardOwner,
+  getCardVisibility,
+  getSlotOccupants,
+  getSlotOccupantsByHost,
+  getComponentContainerLocation,
+  getComponentDeckLocation,
+  getComponentEdgeLocation,
+  getComponentHandLocation,
+  getComponentLocation,
+  getComponentSlotLocation,
+  getComponentSpaceLocation,
+  getComponentVertexLocation,
+  getComponentZoneLocation,
+  getComponentsInContainer,
+  getComponentsOnEdge,
+  getComponentsOnSpace,
+  getComponentsOnVertex,
+  getContainer,
+  getEdge,
+  getEdgesByTypeId,
+  getHexBoard,
+  getHexSpace,
+  getHexSpaceAt,
+  getIncidentEdges,
+  getIncidentVertices,
+  canAffordResources,
+  getMissingResources,
+  getNextPlayerInOrder,
+  getPlayerOrder,
+  getPlayerResourceAmount,
+  getPlayerResourceTotal,
+  getPlayerResources,
+  getPlayerZoneCardCollection,
+  getPlayerZoneCards,
+  getRelatedSpaces,
+  getSharedZoneCardCollection,
+  getSharedZoneCards,
+  getSpace,
+  getSpaceDistance,
+  getSpaceEdges,
+  getSpacesByTypeId,
+  getSpaceVertices,
+  getSquareBoard,
+  getSquareDistance,
+  getSquareNeighbors,
+  getSquareSpace,
+  getSquareSpaceAt,
+  getTiledBoard,
+  getVertex,
+  getVerticesByTypeId,
+} from "./table-ops";
+
+export function createTableQueries<Table extends RuntimeTableRecord>(
+  table: Table,
+): TableQueries<Table> {
+  return {
+    board: {
+      get: <BoardId extends BoardIdOfTable<Table>>(boardId: BoardId) =>
+        getBoard(table, boardId),
+      hex: <BoardId extends HexBoardIdOfTable<Table>>(boardId: BoardId) =>
+        getHexBoard(table, boardId),
+      square: <BoardId extends SquareBoardIdOfTable<Table>>(boardId: BoardId) =>
+        getSquareBoard(table, boardId),
+      tiled: <BoardId extends TiledBoardIdOfTable<Table>>(boardId: BoardId) =>
+        getTiledBoard(table, boardId),
+      space: <
+        BoardId extends BoardIdOfTable<Table>,
+        SpaceId extends SpaceIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        spaceId: SpaceId,
+      ) => getSpace(table, boardId, spaceId),
+      hexSpace: <
+        BoardId extends HexBoardIdOfTable<Table>,
+        SpaceId extends HexSpaceIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        spaceId: SpaceId,
+      ) => getHexSpace(table, boardId, spaceId),
+      squareSpace: <
+        BoardId extends SquareBoardIdOfTable<Table>,
+        SpaceId extends SquareSpaceIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        spaceId: SpaceId,
+      ) => getSquareSpace(table, boardId, spaceId),
+      container: <
+        BoardId extends BoardIdOfTable<Table>,
+        ContainerId extends BoardContainerIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        containerId: ContainerId,
+      ) => getContainer(table, boardId, containerId),
+      edge: <
+        BoardId extends TiledBoardIdOfTable<Table>,
+        EdgeId extends TiledEdgeIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        edgeId: EdgeId,
+      ) => getEdge(table, boardId, edgeId),
+      vertex: <
+        BoardId extends TiledBoardIdOfTable<Table>,
+        VertexId extends TiledVertexIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        vertexId: VertexId,
+      ) => getVertex(table, boardId, vertexId),
+      byType: <TypeId extends BoardTypeIdOfTable<Table>>(typeId: TypeId) =>
+        getBoardsByTypeId(table, typeId),
+      spacesByType: <
+        BoardId extends BoardIdOfTable<Table>,
+        TypeId extends SpaceTypeIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        typeId: TypeId,
+      ) => getSpacesByTypeId(table, boardId, typeId),
+      edgesByType: <
+        BoardId extends TiledBoardIdOfTable<Table>,
+        TypeId extends TiledEdgeTypeIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        typeId: TypeId,
+      ) => getEdgesByTypeId(table, boardId, typeId),
+      verticesByType: <
+        BoardId extends TiledBoardIdOfTable<Table>,
+        TypeId extends TiledVertexTypeIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        typeId: TypeId,
+      ) => getVerticesByTypeId(table, boardId, typeId),
+      adjacentSpaces: <
+        BoardId extends BoardIdOfTable<Table>,
+        SpaceId extends SpaceIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        spaceId: SpaceId,
+      ) => getAdjacentSpaces(table, boardId, spaceId),
+      relatedSpaces: <
+        BoardId extends BoardIdOfTable<Table>,
+        SpaceId extends SpaceIdOfTable<Table, BoardId>,
+        TypeId extends RelationTypeIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        spaceId: SpaceId,
+        relationTypeId: TypeId,
+      ) => getRelatedSpaces(table, boardId, spaceId, relationTypeId),
+      incidentEdges: <
+        BoardId extends TiledBoardIdOfTable<Table>,
+        VertexId extends TiledVertexIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        vertexId: VertexId,
+      ) => getIncidentEdges(table, boardId, vertexId),
+      incidentVertices: <
+        BoardId extends TiledBoardIdOfTable<Table>,
+        EdgeId extends TiledEdgeIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        edgeId: EdgeId,
+      ) => getIncidentVertices(table, boardId, edgeId),
+      spaceEdges: <BoardId extends TiledBoardIdOfTable<Table>>(
+        boardId: BoardId,
+        spaceId: SpaceIdOfTable<Table, BoardId>,
+      ) => getSpaceEdges(table, boardId, spaceId),
+      spaceVertices: <BoardId extends TiledBoardIdOfTable<Table>>(
+        boardId: BoardId,
+        spaceId: SpaceIdOfTable<Table, BoardId>,
+      ) => getSpaceVertices(table, boardId, spaceId),
+      spaceDistance: <
+        BoardId extends BoardIdOfTable<Table>,
+        SpaceId extends SpaceIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        fromSpaceId: SpaceId,
+        toSpaceId: SpaceId,
+      ) => getSpaceDistance(table, boardId, fromSpaceId, toSpaceId),
+      hexSpaceAt: <BoardId extends HexBoardIdOfTable<Table>>(
+        boardId: BoardId,
+        q: number,
+        r: number,
+      ) => getHexSpaceAt(table, boardId, q, r),
+      squareSpaceAt: <BoardId extends SquareBoardIdOfTable<Table>>(
+        boardId: BoardId,
+        row: number,
+        col: number,
+      ) => getSquareSpaceAt(table, boardId, row, col),
+      squareNeighbors: <
+        BoardId extends SquareBoardIdOfTable<Table>,
+        SpaceId extends SquareSpaceIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        spaceId: SpaceId,
+        options?: { mode?: "orthogonal" | "diagonal" | "all" },
+      ) => getSquareNeighbors(table, boardId, spaceId, options),
+      squareDistance: <
+        BoardId extends SquareBoardIdOfTable<Table>,
+        SpaceId extends SquareSpaceIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        fromSpaceId: SpaceId,
+        toSpaceId: SpaceId,
+        options?: { metric?: "manhattan" | "chebyshev" },
+      ) => getSquareDistance(table, boardId, fromSpaceId, toSpaceId, options),
+      spaceOccupants: <
+        BoardId extends BoardIdOfTable<Table>,
+        SpaceId extends SpaceIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        spaceId: SpaceId,
+      ) => getComponentsOnSpace(table, boardId, spaceId),
+      containerOccupants: <
+        BoardId extends BoardIdOfTable<Table>,
+        ContainerId extends BoardContainerIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        containerId: ContainerId,
+      ) => getComponentsInContainer(table, boardId, containerId),
+      edgeOccupants: <
+        BoardId extends TiledBoardIdOfTable<Table>,
+        EdgeId extends TiledEdgeIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        edgeId: EdgeId,
+      ) => getComponentsOnEdge(table, boardId, edgeId),
+      vertexOccupants: <
+        BoardId extends TiledBoardIdOfTable<Table>,
+        VertexId extends TiledVertexIdOfTable<Table, BoardId>,
+      >(
+        boardId: BoardId,
+        vertexId: VertexId,
+      ) => getComponentsOnVertex(table, boardId, vertexId),
+    },
+    zone: {
+      sharedCards: <ZoneId extends DeckIdOfTable<Table>>(zoneId: ZoneId) =>
+        getSharedZoneCards(table, zoneId),
+      sharedCardCollection: <ZoneId extends DeckIdOfTable<Table>>(
+        zoneId: ZoneId,
+      ) => getSharedZoneCardCollection(table, zoneId),
+      allSharedCards: () => getAllSharedZoneCards(table),
+      playerCards: <
+        PlayerId extends PlayerIdOfTable<Table>,
+        ZoneId extends HandIdOfTable<Table>,
+      >(
+        playerId: PlayerId,
+        zoneId: ZoneId,
+      ) => getPlayerZoneCards(table, playerId, zoneId),
+      playerCardCollection: <
+        PlayerId extends PlayerIdOfTable<Table>,
+        ZoneId extends HandIdOfTable<Table>,
+      >(
+        playerId: PlayerId,
+        zoneId: ZoneId,
+      ) => getPlayerZoneCardCollection(table, playerId, zoneId),
+      allPlayerCards: <ZoneId extends HandIdOfTable<Table>>(zoneId: ZoneId) =>
+        getAllPlayerZoneCards(table, zoneId),
+    },
+    card: {
+      get: <CardId extends CardIdOfTable<Table>>(cardId: CardId) =>
+        getCard(table, cardId),
+      byIds: <CardIds extends readonly CardIdOfTable<Table>[]>(
+        cardIds: CardIds,
+      ) => getCardsById(table, cardIds),
+      owner: <CardId extends CardIdOfTable<Table>>(cardId: CardId) =>
+        getCardOwner(table, cardId),
+      visibility: <CardId extends CardIdOfTable<Table>>(cardId: CardId) =>
+        getCardVisibility(table, cardId),
+    },
+    slot: {
+      occupants: (host, slotId) => getSlotOccupants(table, host, slotId),
+      occupantsByHost: (host) => getSlotOccupantsByHost(table, host),
+      pieceOccupants: (hostId, slotId) =>
+        getSlotOccupants(table, { kind: "piece", id: hostId }, slotId),
+      pieceOccupantsByHost: (hostId) =>
+        getSlotOccupantsByHost(table, { kind: "piece", id: hostId }),
+      dieOccupants: (hostId, slotId) =>
+        getSlotOccupants(table, { kind: "die", id: hostId }, slotId),
+      dieOccupantsByHost: (hostId) =>
+        getSlotOccupantsByHost(table, { kind: "die", id: hostId }),
+    },
+    player: {
+      order: () => getPlayerOrder(table),
+      nextInOrder: (playerId) => getNextPlayerInOrder(table, playerId),
+      resources: (playerId) => getPlayerResources(table, playerId),
+      resource: (playerId, resourceId) =>
+        getPlayerResourceAmount(table, playerId, resourceId),
+      resourceTotal: (playerId) => getPlayerResourceTotal(table, playerId),
+      canAfford: (playerId, amounts) =>
+        canAffordResources(table, playerId, amounts),
+      missingResources: (playerId, amounts) =>
+        getMissingResources(table, playerId, amounts),
+    },
+    component: {
+      data: <ComponentId extends ComponentIdOfTable<Table>>(
+        componentId: ComponentId,
+      ) =>
+        (table.cards[componentId] ??
+          table.pieces[componentId] ??
+          table.dice[componentId]) as
+          | ComponentDataOfTable<Table, ComponentId>
+          | undefined,
+      location: <ComponentId extends ComponentIdOfTable<Table>>(
+        componentId: ComponentId,
+      ) => getComponentLocation(table, componentId),
+      deck: <ComponentId extends ComponentIdOfTable<Table>>(
+        componentId: ComponentId,
+      ) => getComponentDeckLocation(table, componentId),
+      hand: <ComponentId extends ComponentIdOfTable<Table>>(
+        componentId: ComponentId,
+      ) => getComponentHandLocation(table, componentId),
+      zone: <ComponentId extends ComponentIdOfTable<Table>>(
+        componentId: ComponentId,
+      ) => getComponentZoneLocation(table, componentId),
+      space: <ComponentId extends ComponentIdOfTable<Table>>(
+        componentId: ComponentId,
+      ) => getComponentSpaceLocation(table, componentId),
+      container: <ComponentId extends ComponentIdOfTable<Table>>(
+        componentId: ComponentId,
+      ) => getComponentContainerLocation(table, componentId),
+      edge: <ComponentId extends ComponentIdOfTable<Table>>(
+        componentId: ComponentId,
+      ) => getComponentEdgeLocation(table, componentId),
+      vertex: <ComponentId extends ComponentIdOfTable<Table>>(
+        componentId: ComponentId,
+      ) => getComponentVertexLocation(table, componentId),
+      slot: <ComponentId extends ComponentIdOfTable<Table>>(
+        componentId: ComponentId,
+      ) => getComponentSlotLocation(table, componentId),
+    },
+  };
+}
+
+export function createStateQueries<State extends { table: RuntimeTableRecord }>(
+  state: State,
+): TableQueriesOfState<State> {
+  return createTableQueries(
+    state.table,
+  ) as unknown as TableQueriesOfState<State>;
+}

package/src/reducer/transaction.ts

@@ -0,0 +1,120 @@
+import type { Op } from "./compose";
+import type {
+  BoardIdOfTable,
+  CardIdOfTable,
+  ComponentIdOfTable,
+  PlayerIdOfTable,
+  PlayerZoneIdOfTable,
+  RuntimeTableRecord,
+  SpaceIdOfTable,
+  TableOfState,
+  TableQueriesOfState,
+} from "./model";
+import { createReducerOps, type ReducerOps } from "./ops";
+import { createStateQueries } from "./table-queries";
+
+export type RotatePlayerZoneArgs<
+  State extends { table: RuntimeTableRecord },
+  ZoneId extends PlayerZoneIdOfTable<TableOfState<State>> = PlayerZoneIdOfTable<
+    TableOfState<State>
+  >,
+  PlayerId extends PlayerIdOfTable<TableOfState<State>> = PlayerIdOfTable<
+    TableOfState<State>
+  >,
+> = {
+  zoneId: ZoneId;
+  direction: "left" | "right";
+  players?: readonly PlayerId[];
+  cardIdsByPlayer?: Partial<
+    Record<PlayerId, readonly CardIdOfTable<TableOfState<State>>[]>
+  >;
+  position?: "top" | "bottom";
+};
+
+type TransactionMethods<State extends { table: RuntimeTableRecord }> = {
+  [Key in Exclude<
+    keyof ReducerOps<State>,
+    "moveComponentToSpace"
+  >]: ReducerOps<State>[Key] extends (...args: infer Args) => Op<State>
+    ? (...args: Args) => State
+    : never;
+} & {
+  moveComponentToSpace<
+    BoardId extends BoardIdOfTable<TableOfState<State>>,
+    SpaceId extends SpaceIdOfTable<TableOfState<State>, BoardId>,
+    ComponentId extends ComponentIdOfTable<TableOfState<State>>,
+  >(args: {
+    componentId: ComponentId;
+    boardId: BoardId;
+    spaceId: SpaceId;
+  }): State;
+};
+
+export type ReducerTransaction<State extends { table: RuntimeTableRecord }> =
+  TransactionMethods<State> & {
+    readonly state: State;
+    readonly q: TableQueriesOfState<State>;
+    apply(op: Op<State>): State;
+    rotatePlayerZone<
+      ZoneId extends PlayerZoneIdOfTable<TableOfState<State>>,
+      PlayerId extends PlayerIdOfTable<TableOfState<State>>,
+    >(
+      args: RotatePlayerZoneArgs<State, ZoneId, PlayerId>,
+    ): State;
+  };
+
+export type ReducerEdit<State extends { table: RuntimeTableRecord }> = <
+  DraftState extends State,
+>(
+  state: DraftState,
+) => ReducerTransaction<DraftState>;
+
+export function createReducerTransaction<
+  State extends { table: RuntimeTableRecord },
+>(initialState: State, ops: ReducerOps<State> = createReducerOps<State>()) {
+  let currentState = initialState;
+  let currentQueries = createStateQueries(currentState);
+
+  const refresh = (nextState: State): State => {
+    currentState = nextState;
+    currentQueries = createStateQueries(currentState);
+    return currentState;
+  };
+
+  const apply = (op: Op<State>): State => refresh(op(currentState));
+
+  const base = {
+    get state() {
+      return currentState;
+    },
+    get q() {
+      return currentQueries;
+    },
+    apply,
+  };
+
+  return new Proxy(base, {
+    get(target, property, receiver) {
+      if (property in target) {
+        return Reflect.get(target, property, receiver);
+      }
+      const opFactory = ops[property as keyof ReducerOps<State>];
+      if (typeof opFactory !== "function") {
+        return undefined;
+      }
+      return (...args: readonly unknown[]) => {
+        const op = (opFactory as (...args: readonly unknown[]) => Op<State>)(
+          ...args,
+        );
+        return apply(op);
+      };
+    },
+  }) as ReducerTransaction<State>;
+}
+
+export function createReducerEdit<State extends { table: RuntimeTableRecord }>(
+  ops: ReducerOps<State> = createReducerOps<State>(),
+): ReducerEdit<State> {
+  return <DraftState extends State>(state: DraftState) =>
+    createReducerTransaction(state, ops as unknown as ReducerOps<DraftState>);
+}