@bct-app/game-engine 0.1.1

package/README.md

@@ -0,0 +1,23 @@
+# @bct-app/game-engine
+
+Game engine utilities for BCT.
+
+## Install
+
+```bash
+pnpm add @bct-app/game-engine
+```
+
+## Build
+
+```bash
+pnpm --filter @bct-app/game-engine build
+```
+
+## Exports
+
+- `applyOperationToPlayers`
+- source/payload resolve utilities
+- player copy/map utilities
+- runtime type guards
+- engine-related type definitions

package/dist/index.d.mts

@@ -0,0 +1,113 @@
+type TAlignment = 'GOOD' | 'EVIL';
+type TReminder = {
+    mark: string;
+    color?: string;
+    duration?: number;
+    [key: string]: unknown;
+};
+type TPlayerReminder = {
+    playerSeat: number;
+    index: number;
+};
+type TPerceivedCharacter = {
+    characterId: string;
+    abilities: string[];
+    asCharacter: boolean;
+};
+type TPopulatedPlayer = {
+    seat: number;
+    abilities: string[];
+    reminders?: TReminder[];
+    alignment?: TAlignment;
+    characterId?: string;
+    perceivedCharacter?: TPerceivedCharacter;
+    isDead?: boolean;
+    hasUsedDeadVote?: boolean;
+    [key: string]: unknown;
+};
+type TAbilityInput = {
+    readonly?: boolean;
+    type?: string;
+    [key: string]: unknown;
+};
+type TPayloadSource = {
+    from: 'PAYLOAD';
+    value: number | number[];
+};
+type TConstantSource = {
+    from: 'CONSTANT';
+    value: unknown;
+};
+type TEffectorSource = {
+    from: 'EFFECTOR';
+    value?: unknown;
+};
+type TOtherSource = {
+    from: Exclude<string, 'PAYLOAD' | 'CONSTANT' | 'EFFECTOR'>;
+    value?: unknown;
+};
+type TSource = TPayloadSource | TConstantSource | TEffectorSource | TOtherSource;
+type TAlignmentSource = TSource;
+type TCharacterSource = TSource;
+type TTarget = {
+    from: 'EFFECTOR' | 'PAYLOAD' | 'CUSTOM' | string;
+    value: unknown;
+};
+type TEffect = {
+    type: string;
+    target: TTarget;
+    source: TSource;
+    followPriority?: boolean;
+};
+type TAbility = {
+    id: string;
+    inputs: TAbilityInput[];
+    effects: TEffect[];
+};
+type TPopulatedCharacter = {
+    id: string;
+    abilities: Array<{
+        id: string;
+    }>;
+};
+type TOperation = {
+    abilityId: string;
+    effector: number;
+    payloads?: unknown[];
+};
+type TTimelineNomination = {
+    voterSeats?: number[];
+};
+type TTimeline = {
+    operations?: TOperation[];
+    nominations?: TTimelineNomination[];
+};
+type TApplyOperationToPlayersArgs = {
+    players: TPopulatedPlayer[];
+    operations: TOperation[];
+    allAbilities: TAbility[];
+    characters: TPopulatedCharacter[];
+    timelines: TTimeline[];
+    timelineIndexAtNow?: number;
+};
+
+declare const applyOperationToPlayers: ({ players, operations, allAbilities, characters, timelines, timelineIndexAtNow, }: TApplyOperationToPlayersArgs) => TPopulatedPlayer[];
+
+declare const transformEmptyArray: <T>(arr: T[]) => T[];
+declare const copyPlayers: (players: TPopulatedPlayer[]) => TPopulatedPlayer[];
+declare const buildPlayerSeatMap: (players: TPopulatedPlayer[]) => Map<number, TPopulatedPlayer>;
+declare const adjustValueAsNumberArray: (value: unknown) => number[];
+declare const adjustValueAsNumber: (value: unknown) => number | undefined;
+
+declare const getValueFromPayloads: (payloads: unknown[], idx: number | number[]) => unknown;
+declare const getSourceValue: (source: TSource, payloads: unknown[]) => unknown;
+/**
+ * Resolve a value from effect source, handling PAYLOAD (with player-seat indirection), CONSTANT, and EFFECTOR.
+ */
+declare const resolveSourceValue: (source: TAlignmentSource | TCharacterSource, writableParts: TAbility["inputs"], payloads: unknown[], effector: TPopulatedPlayer | undefined, snapshotSeatMap: Map<number, TPopulatedPlayer>, resolveFromPlayer: (player: TPopulatedPlayer) => unknown) => unknown;
+
+declare const isNumberOrNumberArray: (value: unknown) => value is number | number[];
+declare const isReminder: (value: unknown) => value is TReminder;
+declare const isPlayerReminderArray: (value: unknown) => value is TPlayerReminder[];
+
+export { type TAbility, type TAbilityInput, type TAlignment, type TAlignmentSource, type TApplyOperationToPlayersArgs, type TCharacterSource, type TEffect, type TOperation, type TPerceivedCharacter, type TPlayerReminder, type TPopulatedCharacter, type TPopulatedPlayer, type TReminder, type TSource, type TTarget, type TTimeline, type TTimelineNomination, adjustValueAsNumber, adjustValueAsNumberArray, applyOperationToPlayers, buildPlayerSeatMap, copyPlayers, getSourceValue, getValueFromPayloads, isNumberOrNumberArray, isPlayerReminderArray, isReminder, resolveSourceValue, transformEmptyArray };

package/dist/index.d.ts

@@ -0,0 +1,113 @@
+type TAlignment = 'GOOD' | 'EVIL';
+type TReminder = {
+    mark: string;
+    color?: string;
+    duration?: number;
+    [key: string]: unknown;
+};
+type TPlayerReminder = {
+    playerSeat: number;
+    index: number;
+};
+type TPerceivedCharacter = {
+    characterId: string;
+    abilities: string[];
+    asCharacter: boolean;
+};
+type TPopulatedPlayer = {
+    seat: number;
+    abilities: string[];
+    reminders?: TReminder[];
+    alignment?: TAlignment;
+    characterId?: string;
+    perceivedCharacter?: TPerceivedCharacter;
+    isDead?: boolean;
+    hasUsedDeadVote?: boolean;
+    [key: string]: unknown;
+};
+type TAbilityInput = {
+    readonly?: boolean;
+    type?: string;
+    [key: string]: unknown;
+};
+type TPayloadSource = {
+    from: 'PAYLOAD';
+    value: number | number[];
+};
+type TConstantSource = {
+    from: 'CONSTANT';
+    value: unknown;
+};
+type TEffectorSource = {
+    from: 'EFFECTOR';
+    value?: unknown;
+};
+type TOtherSource = {
+    from: Exclude<string, 'PAYLOAD' | 'CONSTANT' | 'EFFECTOR'>;
+    value?: unknown;
+};
+type TSource = TPayloadSource | TConstantSource | TEffectorSource | TOtherSource;
+type TAlignmentSource = TSource;
+type TCharacterSource = TSource;
+type TTarget = {
+    from: 'EFFECTOR' | 'PAYLOAD' | 'CUSTOM' | string;
+    value: unknown;
+};
+type TEffect = {
+    type: string;
+    target: TTarget;
+    source: TSource;
+    followPriority?: boolean;
+};
+type TAbility = {
+    id: string;
+    inputs: TAbilityInput[];
+    effects: TEffect[];
+};
+type TPopulatedCharacter = {
+    id: string;
+    abilities: Array<{
+        id: string;
+    }>;
+};
+type TOperation = {
+    abilityId: string;
+    effector: number;
+    payloads?: unknown[];
+};
+type TTimelineNomination = {
+    voterSeats?: number[];
+};
+type TTimeline = {
+    operations?: TOperation[];
+    nominations?: TTimelineNomination[];
+};
+type TApplyOperationToPlayersArgs = {
+    players: TPopulatedPlayer[];
+    operations: TOperation[];
+    allAbilities: TAbility[];
+    characters: TPopulatedCharacter[];
+    timelines: TTimeline[];
+    timelineIndexAtNow?: number;
+};
+
+declare const applyOperationToPlayers: ({ players, operations, allAbilities, characters, timelines, timelineIndexAtNow, }: TApplyOperationToPlayersArgs) => TPopulatedPlayer[];
+
+declare const transformEmptyArray: <T>(arr: T[]) => T[];
+declare const copyPlayers: (players: TPopulatedPlayer[]) => TPopulatedPlayer[];
+declare const buildPlayerSeatMap: (players: TPopulatedPlayer[]) => Map<number, TPopulatedPlayer>;
+declare const adjustValueAsNumberArray: (value: unknown) => number[];
+declare const adjustValueAsNumber: (value: unknown) => number | undefined;
+
+declare const getValueFromPayloads: (payloads: unknown[], idx: number | number[]) => unknown;
+declare const getSourceValue: (source: TSource, payloads: unknown[]) => unknown;
+/**
+ * Resolve a value from effect source, handling PAYLOAD (with player-seat indirection), CONSTANT, and EFFECTOR.
+ */
+declare const resolveSourceValue: (source: TAlignmentSource | TCharacterSource, writableParts: TAbility["inputs"], payloads: unknown[], effector: TPopulatedPlayer | undefined, snapshotSeatMap: Map<number, TPopulatedPlayer>, resolveFromPlayer: (player: TPopulatedPlayer) => unknown) => unknown;
+
+declare const isNumberOrNumberArray: (value: unknown) => value is number | number[];
+declare const isReminder: (value: unknown) => value is TReminder;
+declare const isPlayerReminderArray: (value: unknown) => value is TPlayerReminder[];
+
+export { type TAbility, type TAbilityInput, type TAlignment, type TAlignmentSource, type TApplyOperationToPlayersArgs, type TCharacterSource, type TEffect, type TOperation, type TPerceivedCharacter, type TPlayerReminder, type TPopulatedCharacter, type TPopulatedPlayer, type TReminder, type TSource, type TTarget, type TTimeline, type TTimelineNomination, adjustValueAsNumber, adjustValueAsNumberArray, applyOperationToPlayers, buildPlayerSeatMap, copyPlayers, getSourceValue, getValueFromPayloads, isNumberOrNumberArray, isPlayerReminderArray, isReminder, resolveSourceValue, transformEmptyArray };

package/dist/index.js

@@ -0,0 +1,409 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  adjustValueAsNumber: () => adjustValueAsNumber,
+  adjustValueAsNumberArray: () => adjustValueAsNumberArray,
+  applyOperationToPlayers: () => applyOperationToPlayers,
+  buildPlayerSeatMap: () => buildPlayerSeatMap,
+  copyPlayers: () => copyPlayers,
+  getSourceValue: () => getSourceValue,
+  getValueFromPayloads: () => getValueFromPayloads,
+  isNumberOrNumberArray: () => isNumberOrNumberArray,
+  isPlayerReminderArray: () => isPlayerReminderArray,
+  isReminder: () => isReminder,
+  resolveSourceValue: () => resolveSourceValue,
+  transformEmptyArray: () => transformEmptyArray
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/guards.ts
+var isNumberOrNumberArray = (value) => {
+  if (typeof value === "number") {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.every((item) => typeof item === "number");
+  }
+  return false;
+};
+var isReminder = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  if (typeof candidate.mark !== "string") {
+    return false;
+  }
+  if (candidate.color !== void 0 && typeof candidate.color !== "string") {
+    return false;
+  }
+  if (candidate.duration !== void 0 && typeof candidate.duration !== "number") {
+    return false;
+  }
+  return true;
+};
+var isPlayerReminderArray = (value) => {
+  if (!Array.isArray(value)) {
+    return false;
+  }
+  return value.every((item) => {
+    if (!item || typeof item !== "object") {
+      return false;
+    }
+    const candidate = item;
+    return typeof candidate.playerSeat === "number" && typeof candidate.index === "number";
+  });
+};
+
+// src/player-utils.ts
+var transformEmptyArray = (arr) => {
+  return arr.length === 0 ? [] : arr;
+};
+var copyPlayers = (players) => {
+  return players.map((player) => ({
+    ...player,
+    abilities: [...player.abilities],
+    reminders: [...player.reminders || []]
+  }));
+};
+var buildPlayerSeatMap = (players) => {
+  const map = /* @__PURE__ */ new Map();
+  players.forEach((player) => map.set(player.seat, player));
+  return map;
+};
+var adjustValueAsNumberArray = (value) => {
+  if (isNumberOrNumberArray(value)) {
+    return typeof value === "number" ? [value] : value;
+  }
+  return [];
+};
+var adjustValueAsNumber = (value) => {
+  if (isNumberOrNumberArray(value)) {
+    return typeof value === "number" ? value : value[0] || void 0;
+  }
+  return void 0;
+};
+
+// src/source-utils.ts
+var getValueFromPayloads = (payloads, idx) => {
+  if (Array.isArray(idx)) {
+    if (idx.length < 2) {
+      return payloads[idx[0]];
+    }
+    const values = payloads[idx[0]];
+    const seatIdx = idx[1];
+    if (Array.isArray(values)) {
+      return values[seatIdx];
+    }
+    console.warn("Expected array in payloads for multiple indices, got:", values);
+    return values;
+  }
+  return payloads[idx];
+};
+var getSourceValue = (source, payloads) => {
+  if (source.from === "PAYLOAD") {
+    if (!isNumberOrNumberArray(source.value)) {
+      return void 0;
+    }
+    return getValueFromPayloads(payloads, source.value);
+  }
+  if (source.from === "CONSTANT") {
+    return source.value;
+  }
+  return null;
+};
+var resolveSourceValue = (source, writableParts, payloads, effector, snapshotSeatMap, resolveFromPlayer) => {
+  if (source.from === "PAYLOAD") {
+    const payloadValue = getSourceValue(source, payloads);
+    const idx = adjustValueAsNumberArray(source.value);
+    const part = writableParts[idx[0]];
+    if (part?.type === "PLAYER") {
+      const seat = adjustValueAsNumber(payloadValue);
+      const player = typeof seat === "number" ? snapshotSeatMap.get(seat) : void 0;
+      return player ? resolveFromPlayer(player) : void 0;
+    }
+    return payloadValue;
+  }
+  if (source.from === "CONSTANT") {
+    return source.value;
+  }
+  if (source.from === "EFFECTOR") {
+    if (!effector) {
+      return void 0;
+    }
+    const player = snapshotSeatMap.get(effector.seat);
+    return player ? resolveFromPlayer(player) : void 0;
+  }
+  return void 0;
+};
+
+// src/apply-operation.ts
+var applyOperationToPlayers = ({
+  players,
+  operations,
+  allAbilities,
+  characters,
+  timelines,
+  timelineIndexAtNow
+}) => {
+  if (operations.length === 0) {
+    return transformEmptyArray(players);
+  }
+  const abilityMap = new Map(allAbilities.map((ability) => [ability.id, ability]));
+  const characterMap = new Map(characters.map((character) => [character.id, character]));
+  const operationTimelineMap = /* @__PURE__ */ new Map();
+  timelines.forEach((timeline, idx) => timeline.operations?.forEach((op) => operationTimelineMap.set(op, idx)));
+  const playersWithStatus = copyPlayers(players);
+  const nowTimelineIndex = typeof timelineIndexAtNow === "number" ? timelineIndexAtNow : timelines.length - 1;
+  const operationsByTimeline = /* @__PURE__ */ new Map();
+  operations.forEach((operation) => {
+    const timelineIndex = operationTimelineMap.get(operation) ?? -1;
+    if (!operationsByTimeline.has(timelineIndex)) {
+      operationsByTimeline.set(timelineIndex, []);
+    }
+    operationsByTimeline.get(timelineIndex)?.push(operation);
+  });
+  const applyOps = (ops) => {
+    ops.forEach((operation) => {
+      const operationInTimelineIdx = operationTimelineMap.get(operation) ?? -1;
+      const ability = abilityMap.get(operation.abilityId);
+      if (!ability) {
+        console.warn("Ability not found for operation:", operation);
+        return;
+      }
+      const playerSeatMap = buildPlayerSeatMap(playersWithStatus);
+      const effector = playerSeatMap.get(operation.effector);
+      const payloads = operation.payloads || [];
+      const writableParts = ability.inputs.filter((part) => !part.readonly);
+      let snapshotSeatMap = null;
+      const getSnapshotSeatMap = () => {
+        if (!snapshotSeatMap) {
+          snapshotSeatMap = buildPlayerSeatMap(copyPlayers(playersWithStatus));
+        }
+        return snapshotSeatMap;
+      };
+      ability.effects.forEach((effect) => {
+        const makePlayersEffect = [];
+        if (effect.type === "GAME_CHANGE" || effect.type === "CHARACTER_COUNT_CHANGE") {
+          console.warn(effect.type + " effect handling not implemented yet.");
+          return;
+        }
+        if (effect.target.from === "EFFECTOR") {
+          if (!effector) {
+            console.warn("Effector player not found for operation:", operation, "effector index:", operation.effector);
+            return;
+          }
+          makePlayersEffect.push(effector);
+        } else if (effect.target.from === "PAYLOAD") {
+          const seatValue = getValueFromPayloads(payloads, effect.target.value);
+          if (typeof seatValue !== "number" && !Array.isArray(seatValue)) {
+            console.warn("Expected seat number or array of seat numbers from payloads, got:", seatValue);
+            return;
+          }
+          const seats = Array.isArray(seatValue) ? seatValue : [seatValue];
+          seats.forEach((seat) => {
+            const player = playerSeatMap.get(seat);
+            if (player) {
+              makePlayersEffect.push(player);
+            }
+          });
+        } else if (effect.target.from === "CUSTOM") {
+          console.warn("Custom target handling not implemented yet.");
+        }
+        switch (effect.type) {
+          case "ABILITY_CHANGE": {
+            console.warn("ABILITY_CHANGE effect handling not implemented yet.");
+            break;
+          }
+          case "ALIGNMENT_CHANGE": {
+            const resolved = resolveSourceValue(
+              effect.source,
+              writableParts,
+              payloads,
+              effector,
+              getSnapshotSeatMap(),
+              (player) => player.alignment
+            );
+            let alignment;
+            if (resolved === "GOOD" || resolved === "EVIL") {
+              alignment = resolved;
+            }
+            if (!alignment) {
+              console.warn("Alignment not found for ALIGNMENT_CHANGE effect:", effect.source);
+              return;
+            }
+            makePlayersEffect.forEach((player) => {
+              player.alignment = alignment;
+            });
+            break;
+          }
+          case "CHARACTER_CHANGE":
+          case "PERCEIVED_CHARACTER_CHANGE": {
+            const resolvedCharacterId = resolveSourceValue(
+              effect.source,
+              writableParts,
+              payloads,
+              effector,
+              getSnapshotSeatMap(),
+              (player) => player.characterId
+            );
+            let characterId;
+            if (typeof resolvedCharacterId === "string") {
+              characterId = resolvedCharacterId;
+            } else if (Array.isArray(resolvedCharacterId) && typeof resolvedCharacterId[0] === "string") {
+              characterId = resolvedCharacterId[0];
+            }
+            if (!characterId) {
+              console.warn("Character ID not found for " + effect.type + " effect:", effect.source);
+              return;
+            }
+            const newCharacter = characterMap.get(characterId);
+            if (!newCharacter) {
+              console.warn("Character not found for " + effect.type + " effect:", characterId);
+              return;
+            }
+            if (effect.type === "CHARACTER_CHANGE") {
+              const abilityIds = newCharacter.abilities.map((ability2) => ability2.id);
+              makePlayersEffect.forEach((player) => {
+                player.characterId = newCharacter.id;
+                player.abilities = abilityIds;
+              });
+            } else {
+              makePlayersEffect.forEach((player) => {
+                player.perceivedCharacter = {
+                  characterId: newCharacter.id,
+                  abilities: newCharacter.abilities.map((ability2) => ability2.id),
+                  asCharacter: effect.followPriority || false
+                };
+              });
+            }
+            break;
+          }
+          case "REMINDER_ADD": {
+            const maybeReminder = getSourceValue(effect.source, payloads);
+            if (!isReminder(maybeReminder)) {
+              console.warn("Invalid reminder data for REMINDER_ADD effect:", maybeReminder);
+              return;
+            }
+            const timelineDistance = nowTimelineIndex - operationInTimelineIdx;
+            if (typeof maybeReminder.duration === "number" && maybeReminder.duration > 0 && timelineDistance >= maybeReminder.duration) {
+              break;
+            }
+            makePlayersEffect.forEach((player) => {
+              if (!player.reminders) {
+                player.reminders = [];
+              }
+              player.reminders.push(maybeReminder);
+            });
+            break;
+          }
+          case "REMINDER_REMOVE": {
+            const maybeReminder = getSourceValue(effect.source, payloads);
+            if (!isPlayerReminderArray(maybeReminder)) {
+              console.warn("Invalid reminder data for REMINDER_REMOVE effect:", maybeReminder);
+              return;
+            }
+            maybeReminder.sort((left, right) => right.index - left.index).forEach((reminder) => {
+              const player = playerSeatMap.get(reminder.playerSeat);
+              if (!player) {
+                console.warn("Player not found for REMINDER_REMOVE effect:", reminder.playerSeat);
+                return;
+              }
+              if (!player.reminders) {
+                player.reminders = [];
+              }
+              player.reminders = player.reminders.filter((_value, index) => index !== reminder.index);
+            });
+            break;
+          }
+          case "SEAT_CHANGE": {
+            console.warn("SEAT_CHANGE effect handling not implemented yet.");
+            break;
+          }
+          case "STATUS_CHANGE": {
+            const maybeStatus = getSourceValue(effect.source, payloads);
+            if (maybeStatus === "DEAD") {
+              makePlayersEffect.forEach((player) => {
+                player.isDead = true;
+              });
+            } else if (maybeStatus === "ALIVE") {
+              makePlayersEffect.forEach((player) => {
+                player.isDead = false;
+              });
+            } else {
+              console.warn("Invalid status value for STATUS_CHANGE effect:", maybeStatus);
+            }
+            break;
+          }
+          default: {
+          }
+        }
+      });
+    });
+  };
+  const settingsOps = operationsByTimeline.get(-1);
+  if (settingsOps) {
+    applyOps(settingsOps);
+  }
+  for (let i = 0; i <= nowTimelineIndex; i += 1) {
+    const timeline = timelines[i];
+    if (!timeline) {
+      continue;
+    }
+    const nominations = timeline.nominations;
+    if (nominations && nominations.length > 0) {
+      const playerSeatMap = buildPlayerSeatMap(playersWithStatus);
+      nominations.forEach((nomination) => {
+        const voterSeats = nomination.voterSeats;
+        if (!voterSeats || voterSeats.length === 0) {
+          return;
+        }
+        voterSeats.forEach((seat) => {
+          const player = playerSeatMap.get(seat);
+          if (player && player.isDead && !player.hasUsedDeadVote) {
+            player.hasUsedDeadVote = true;
+          }
+        });
+      });
+    }
+    const timelineOps = operationsByTimeline.get(i);
+    if (timelineOps) {
+      applyOps(timelineOps);
+    }
+  }
+  return transformEmptyArray(playersWithStatus);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  adjustValueAsNumber,
+  adjustValueAsNumberArray,
+  applyOperationToPlayers,
+  buildPlayerSeatMap,
+  copyPlayers,
+  getSourceValue,
+  getValueFromPayloads,
+  isNumberOrNumberArray,
+  isPlayerReminderArray,
+  isReminder,
+  resolveSourceValue,
+  transformEmptyArray
+});

package/dist/index.mjs

@@ -0,0 +1,371 @@
+// src/guards.ts
+var isNumberOrNumberArray = (value) => {
+  if (typeof value === "number") {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.every((item) => typeof item === "number");
+  }
+  return false;
+};
+var isReminder = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  if (typeof candidate.mark !== "string") {
+    return false;
+  }
+  if (candidate.color !== void 0 && typeof candidate.color !== "string") {
+    return false;
+  }
+  if (candidate.duration !== void 0 && typeof candidate.duration !== "number") {
+    return false;
+  }
+  return true;
+};
+var isPlayerReminderArray = (value) => {
+  if (!Array.isArray(value)) {
+    return false;
+  }
+  return value.every((item) => {
+    if (!item || typeof item !== "object") {
+      return false;
+    }
+    const candidate = item;
+    return typeof candidate.playerSeat === "number" && typeof candidate.index === "number";
+  });
+};
+
+// src/player-utils.ts
+var transformEmptyArray = (arr) => {
+  return arr.length === 0 ? [] : arr;
+};
+var copyPlayers = (players) => {
+  return players.map((player) => ({
+    ...player,
+    abilities: [...player.abilities],
+    reminders: [...player.reminders || []]
+  }));
+};
+var buildPlayerSeatMap = (players) => {
+  const map = /* @__PURE__ */ new Map();
+  players.forEach((player) => map.set(player.seat, player));
+  return map;
+};
+var adjustValueAsNumberArray = (value) => {
+  if (isNumberOrNumberArray(value)) {
+    return typeof value === "number" ? [value] : value;
+  }
+  return [];
+};
+var adjustValueAsNumber = (value) => {
+  if (isNumberOrNumberArray(value)) {
+    return typeof value === "number" ? value : value[0] || void 0;
+  }
+  return void 0;
+};
+
+// src/source-utils.ts
+var getValueFromPayloads = (payloads, idx) => {
+  if (Array.isArray(idx)) {
+    if (idx.length < 2) {
+      return payloads[idx[0]];
+    }
+    const values = payloads[idx[0]];
+    const seatIdx = idx[1];
+    if (Array.isArray(values)) {
+      return values[seatIdx];
+    }
+    console.warn("Expected array in payloads for multiple indices, got:", values);
+    return values;
+  }
+  return payloads[idx];
+};
+var getSourceValue = (source, payloads) => {
+  if (source.from === "PAYLOAD") {
+    if (!isNumberOrNumberArray(source.value)) {
+      return void 0;
+    }
+    return getValueFromPayloads(payloads, source.value);
+  }
+  if (source.from === "CONSTANT") {
+    return source.value;
+  }
+  return null;
+};
+var resolveSourceValue = (source, writableParts, payloads, effector, snapshotSeatMap, resolveFromPlayer) => {
+  if (source.from === "PAYLOAD") {
+    const payloadValue = getSourceValue(source, payloads);
+    const idx = adjustValueAsNumberArray(source.value);
+    const part = writableParts[idx[0]];
+    if (part?.type === "PLAYER") {
+      const seat = adjustValueAsNumber(payloadValue);
+      const player = typeof seat === "number" ? snapshotSeatMap.get(seat) : void 0;
+      return player ? resolveFromPlayer(player) : void 0;
+    }
+    return payloadValue;
+  }
+  if (source.from === "CONSTANT") {
+    return source.value;
+  }
+  if (source.from === "EFFECTOR") {
+    if (!effector) {
+      return void 0;
+    }
+    const player = snapshotSeatMap.get(effector.seat);
+    return player ? resolveFromPlayer(player) : void 0;
+  }
+  return void 0;
+};
+
+// src/apply-operation.ts
+var applyOperationToPlayers = ({
+  players,
+  operations,
+  allAbilities,
+  characters,
+  timelines,
+  timelineIndexAtNow
+}) => {
+  if (operations.length === 0) {
+    return transformEmptyArray(players);
+  }
+  const abilityMap = new Map(allAbilities.map((ability) => [ability.id, ability]));
+  const characterMap = new Map(characters.map((character) => [character.id, character]));
+  const operationTimelineMap = /* @__PURE__ */ new Map();
+  timelines.forEach((timeline, idx) => timeline.operations?.forEach((op) => operationTimelineMap.set(op, idx)));
+  const playersWithStatus = copyPlayers(players);
+  const nowTimelineIndex = typeof timelineIndexAtNow === "number" ? timelineIndexAtNow : timelines.length - 1;
+  const operationsByTimeline = /* @__PURE__ */ new Map();
+  operations.forEach((operation) => {
+    const timelineIndex = operationTimelineMap.get(operation) ?? -1;
+    if (!operationsByTimeline.has(timelineIndex)) {
+      operationsByTimeline.set(timelineIndex, []);
+    }
+    operationsByTimeline.get(timelineIndex)?.push(operation);
+  });
+  const applyOps = (ops) => {
+    ops.forEach((operation) => {
+      const operationInTimelineIdx = operationTimelineMap.get(operation) ?? -1;
+      const ability = abilityMap.get(operation.abilityId);
+      if (!ability) {
+        console.warn("Ability not found for operation:", operation);
+        return;
+      }
+      const playerSeatMap = buildPlayerSeatMap(playersWithStatus);
+      const effector = playerSeatMap.get(operation.effector);
+      const payloads = operation.payloads || [];
+      const writableParts = ability.inputs.filter((part) => !part.readonly);
+      let snapshotSeatMap = null;
+      const getSnapshotSeatMap = () => {
+        if (!snapshotSeatMap) {
+          snapshotSeatMap = buildPlayerSeatMap(copyPlayers(playersWithStatus));
+        }
+        return snapshotSeatMap;
+      };
+      ability.effects.forEach((effect) => {
+        const makePlayersEffect = [];
+        if (effect.type === "GAME_CHANGE" || effect.type === "CHARACTER_COUNT_CHANGE") {
+          console.warn(effect.type + " effect handling not implemented yet.");
+          return;
+        }
+        if (effect.target.from === "EFFECTOR") {
+          if (!effector) {
+            console.warn("Effector player not found for operation:", operation, "effector index:", operation.effector);
+            return;
+          }
+          makePlayersEffect.push(effector);
+        } else if (effect.target.from === "PAYLOAD") {
+          const seatValue = getValueFromPayloads(payloads, effect.target.value);
+          if (typeof seatValue !== "number" && !Array.isArray(seatValue)) {
+            console.warn("Expected seat number or array of seat numbers from payloads, got:", seatValue);
+            return;
+          }
+          const seats = Array.isArray(seatValue) ? seatValue : [seatValue];
+          seats.forEach((seat) => {
+            const player = playerSeatMap.get(seat);
+            if (player) {
+              makePlayersEffect.push(player);
+            }
+          });
+        } else if (effect.target.from === "CUSTOM") {
+          console.warn("Custom target handling not implemented yet.");
+        }
+        switch (effect.type) {
+          case "ABILITY_CHANGE": {
+            console.warn("ABILITY_CHANGE effect handling not implemented yet.");
+            break;
+          }
+          case "ALIGNMENT_CHANGE": {
+            const resolved = resolveSourceValue(
+              effect.source,
+              writableParts,
+              payloads,
+              effector,
+              getSnapshotSeatMap(),
+              (player) => player.alignment
+            );
+            let alignment;
+            if (resolved === "GOOD" || resolved === "EVIL") {
+              alignment = resolved;
+            }
+            if (!alignment) {
+              console.warn("Alignment not found for ALIGNMENT_CHANGE effect:", effect.source);
+              return;
+            }
+            makePlayersEffect.forEach((player) => {
+              player.alignment = alignment;
+            });
+            break;
+          }
+          case "CHARACTER_CHANGE":
+          case "PERCEIVED_CHARACTER_CHANGE": {
+            const resolvedCharacterId = resolveSourceValue(
+              effect.source,
+              writableParts,
+              payloads,
+              effector,
+              getSnapshotSeatMap(),
+              (player) => player.characterId
+            );
+            let characterId;
+            if (typeof resolvedCharacterId === "string") {
+              characterId = resolvedCharacterId;
+            } else if (Array.isArray(resolvedCharacterId) && typeof resolvedCharacterId[0] === "string") {
+              characterId = resolvedCharacterId[0];
+            }
+            if (!characterId) {
+              console.warn("Character ID not found for " + effect.type + " effect:", effect.source);
+              return;
+            }
+            const newCharacter = characterMap.get(characterId);
+            if (!newCharacter) {
+              console.warn("Character not found for " + effect.type + " effect:", characterId);
+              return;
+            }
+            if (effect.type === "CHARACTER_CHANGE") {
+              const abilityIds = newCharacter.abilities.map((ability2) => ability2.id);
+              makePlayersEffect.forEach((player) => {
+                player.characterId = newCharacter.id;
+                player.abilities = abilityIds;
+              });
+            } else {
+              makePlayersEffect.forEach((player) => {
+                player.perceivedCharacter = {
+                  characterId: newCharacter.id,
+                  abilities: newCharacter.abilities.map((ability2) => ability2.id),
+                  asCharacter: effect.followPriority || false
+                };
+              });
+            }
+            break;
+          }
+          case "REMINDER_ADD": {
+            const maybeReminder = getSourceValue(effect.source, payloads);
+            if (!isReminder(maybeReminder)) {
+              console.warn("Invalid reminder data for REMINDER_ADD effect:", maybeReminder);
+              return;
+            }
+            const timelineDistance = nowTimelineIndex - operationInTimelineIdx;
+            if (typeof maybeReminder.duration === "number" && maybeReminder.duration > 0 && timelineDistance >= maybeReminder.duration) {
+              break;
+            }
+            makePlayersEffect.forEach((player) => {
+              if (!player.reminders) {
+                player.reminders = [];
+              }
+              player.reminders.push(maybeReminder);
+            });
+            break;
+          }
+          case "REMINDER_REMOVE": {
+            const maybeReminder = getSourceValue(effect.source, payloads);
+            if (!isPlayerReminderArray(maybeReminder)) {
+              console.warn("Invalid reminder data for REMINDER_REMOVE effect:", maybeReminder);
+              return;
+            }
+            maybeReminder.sort((left, right) => right.index - left.index).forEach((reminder) => {
+              const player = playerSeatMap.get(reminder.playerSeat);
+              if (!player) {
+                console.warn("Player not found for REMINDER_REMOVE effect:", reminder.playerSeat);
+                return;
+              }
+              if (!player.reminders) {
+                player.reminders = [];
+              }
+              player.reminders = player.reminders.filter((_value, index) => index !== reminder.index);
+            });
+            break;
+          }
+          case "SEAT_CHANGE": {
+            console.warn("SEAT_CHANGE effect handling not implemented yet.");
+            break;
+          }
+          case "STATUS_CHANGE": {
+            const maybeStatus = getSourceValue(effect.source, payloads);
+            if (maybeStatus === "DEAD") {
+              makePlayersEffect.forEach((player) => {
+                player.isDead = true;
+              });
+            } else if (maybeStatus === "ALIVE") {
+              makePlayersEffect.forEach((player) => {
+                player.isDead = false;
+              });
+            } else {
+              console.warn("Invalid status value for STATUS_CHANGE effect:", maybeStatus);
+            }
+            break;
+          }
+          default: {
+          }
+        }
+      });
+    });
+  };
+  const settingsOps = operationsByTimeline.get(-1);
+  if (settingsOps) {
+    applyOps(settingsOps);
+  }
+  for (let i = 0; i <= nowTimelineIndex; i += 1) {
+    const timeline = timelines[i];
+    if (!timeline) {
+      continue;
+    }
+    const nominations = timeline.nominations;
+    if (nominations && nominations.length > 0) {
+      const playerSeatMap = buildPlayerSeatMap(playersWithStatus);
+      nominations.forEach((nomination) => {
+        const voterSeats = nomination.voterSeats;
+        if (!voterSeats || voterSeats.length === 0) {
+          return;
+        }
+        voterSeats.forEach((seat) => {
+          const player = playerSeatMap.get(seat);
+          if (player && player.isDead && !player.hasUsedDeadVote) {
+            player.hasUsedDeadVote = true;
+          }
+        });
+      });
+    }
+    const timelineOps = operationsByTimeline.get(i);
+    if (timelineOps) {
+      applyOps(timelineOps);
+    }
+  }
+  return transformEmptyArray(playersWithStatus);
+};
+export {
+  adjustValueAsNumber,
+  adjustValueAsNumberArray,
+  applyOperationToPlayers,
+  buildPlayerSeatMap,
+  copyPlayers,
+  getSourceValue,
+  getValueFromPayloads,
+  isNumberOrNumberArray,
+  isPlayerReminderArray,
+  isReminder,
+  resolveSourceValue,
+  transformEmptyArray
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@bct-app/game-engine",
+  "version": "0.1.1",
+  "description": "Game engine utilities for BCT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "tsup src/index.ts --dts --format cjs,esm",
+    "dev": "tsup src/index.ts --dts --format cjs,esm --watch"
+  },
+  "keywords": [
+    "game-engine",
+    "bct"
+  ],
+  "author": "BCT-YH",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.2",
+    "typescript": "^5.9.3"
+  }
+}