@bct-app/game-engine 0.1.2 → 0.1.4

package/dist/index.js

@@ -35,6 +35,25 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/effects/handler-types.ts
+var createEffectHandler = (type, handler) => {
+  return (context) => {
+    if (context.effect.type !== type) {
+      console.warn("Invalid effect type for handler:", context.effect.type, "expected:", type);
+      return;
+    }
+    handler({
+      ...context,
+      effect: context.effect
+    });
+  };
+};
+
+// src/effects/handlers/ability-change.ts
+var applyAbilityChange = createEffectHandler("ABILITY_CHANGE", () => {
+  console.warn("ABILITY_CHANGE effect handling not implemented yet.");
+});
+
 // src/guards.ts
 var isNumberOrNumberArray = (value) => {
   if (typeof value === "number") {
@@ -121,33 +140,39 @@ var getValueFromPayloads = (payloads, idx) => {
   return payloads[idx];
 };
 var getSourceValue = (source, payloads) => {
-  if (source.from === "PAYLOAD") {
+  if (source?.from === "PAYLOAD") {
     if (!isNumberOrNumberArray(source.value)) {
       return void 0;
     }
     return getValueFromPayloads(payloads, source.value);
   }
-  if (source.from === "CONSTANT") {
+  if (source?.from === "CONSTANT") {
     return source.value;
   }
   return null;
 };
-var resolveSourceValue = (source, writableParts, payloads, effector, snapshotSeatMap, resolveFromPlayer) => {
-  if (source.from === "PAYLOAD") {
+var resolveSourceValue = (source, writableInputs, payloads, effector, snapshotSeatMap, resolveFromPlayer, isResolvedValue) => {
+  const castOrValidate = (value) => {
+    if (!isResolvedValue) {
+      return value;
+    }
+    return isResolvedValue(value) ? value : void 0;
+  };
+  if (source?.from === "PAYLOAD") {
     const payloadValue = getSourceValue(source, payloads);
     const idx = adjustValueAsNumberArray(source.value);
-    const part = writableParts[idx[0]];
-    if (part?.type === "PLAYER") {
+    const input = writableInputs[idx[0]];
+    if (input?.type === "PLAYER") {
       const seat = adjustValueAsNumber(payloadValue);
       const player = typeof seat === "number" ? snapshotSeatMap.get(seat) : void 0;
       return player ? resolveFromPlayer(player) : void 0;
     }
-    return payloadValue;
+    return castOrValidate(payloadValue);
   }
-  if (source.from === "CONSTANT") {
-    return source.value;
+  if (source?.from === "CONSTANT") {
+    return castOrValidate(source.value);
   }
-  if (source.from === "EFFECTOR") {
+  if (source?.from === "EFFECTOR") {
     if (!effector) {
       return void 0;
     }
@@ -157,7 +182,423 @@ var resolveSourceValue = (source, writableParts, payloads, effector, snapshotSea
   return void 0;
 };
 
+// src/effects/handlers/alignment-change.ts
+var applyAlignmentChange = createEffectHandler("ALIGNMENT_CHANGE", ({
+  effect,
+  payloads,
+  effector,
+  writableInputs,
+  getSnapshotSeatMap,
+  makePlayersEffect
+}) => {
+  const alignment = resolveSourceValue(
+    effect.source,
+    writableInputs,
+    payloads,
+    effector,
+    getSnapshotSeatMap(),
+    (player) => player.alignment,
+    (isResolvedValue) => typeof isResolvedValue === "string" && (isResolvedValue === "GOOD" || isResolvedValue === "EVIL")
+  );
+  if (!alignment) {
+    console.warn("Alignment not found for ALIGNMENT_CHANGE effect:", effect.source);
+    return;
+  }
+  makePlayersEffect.forEach((player) => {
+    player.alignment = alignment;
+  });
+});
+
+// src/effects/handlers/character-change.ts
+var resolveCharacterId = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value) && typeof value[0] === "string") {
+    return value[0];
+  }
+  return void 0;
+};
+var applyCharacterChange = createEffectHandler("CHARACTER_CHANGE", ({
+  effect,
+  payloads,
+  effector,
+  writableInputs,
+  getSnapshotSeatMap,
+  characterMap,
+  makePlayersEffect
+}) => {
+  const resolvedCharacterId = resolveSourceValue(
+    effect.source,
+    writableInputs,
+    payloads,
+    effector,
+    getSnapshotSeatMap(),
+    (player) => player.characterId
+  );
+  const characterId = resolveCharacterId(resolvedCharacterId);
+  if (!characterId) {
+    console.warn("Character ID not found for CHARACTER_CHANGE effect:", effect.source);
+    return;
+  }
+  const newCharacter = characterMap.get(characterId);
+  if (!newCharacter) {
+    console.warn("Character not found for CHARACTER_CHANGE effect:", characterId);
+    return;
+  }
+  const abilityIds = newCharacter.abilities.map((ability) => ability.id);
+  makePlayersEffect.forEach((player) => {
+    player.characterId = newCharacter.id;
+    player.abilities = abilityIds;
+  });
+});
+
+// src/effects/handlers/character-count-change.ts
+var applyCharacterCountChange = createEffectHandler("CHARACTER_COUNT_CHANGE", () => {
+  console.warn("CHARACTER_COUNT_CHANGE effect handling not implemented yet.");
+});
+
+// src/effects/handlers/game-change.ts
+var applyGameChange = createEffectHandler("GAME_CHANGE", () => {
+  console.warn("GAME_CHANGE effect handling not implemented yet.");
+});
+
+// src/effects/handlers/perceived-character-change.ts
+var resolveCharacterId2 = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value) && typeof value[0] === "string") {
+    return value[0];
+  }
+  return void 0;
+};
+var applyPerceivedCharacterChange = createEffectHandler("PERCEIVED_CHARACTER_CHANGE", ({
+  effect,
+  payloads,
+  effector,
+  writableInputs,
+  getSnapshotSeatMap,
+  characterMap,
+  makePlayersEffect
+}) => {
+  const resolvedCharacterId = resolveSourceValue(
+    effect.source,
+    writableInputs,
+    payloads,
+    effector,
+    getSnapshotSeatMap(),
+    (player) => player.characterId
+  );
+  const characterId = resolveCharacterId2(resolvedCharacterId);
+  if (!characterId) {
+    console.warn("Character ID not found for PERCEIVED_CHARACTER_CHANGE effect:", effect.source);
+    return;
+  }
+  const newCharacter = characterMap.get(characterId);
+  if (!newCharacter) {
+    console.warn("Character not found for PERCEIVED_CHARACTER_CHANGE effect:", characterId);
+    return;
+  }
+  makePlayersEffect.forEach((player) => {
+    player.perceivedCharacter = {
+      characterId: newCharacter.id,
+      abilities: newCharacter.abilities.map((ability) => ability.id),
+      asCharacter: effect.followPriority || false
+    };
+  });
+});
+
+// src/effects/handlers/reminder-add.ts
+var applyReminderAdd = createEffectHandler("REMINDER_ADD", ({
+  effect,
+  payloads,
+  nowTimelineIndex,
+  operationInTimelineIdx,
+  makePlayersEffect
+}) => {
+  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) {
+    return;
+  }
+  makePlayersEffect.forEach((player) => {
+    if (!player.reminders) {
+      player.reminders = [];
+    }
+    player.reminders.push(maybeReminder);
+  });
+});
+
+// src/effects/handlers/reminder-remove.ts
+var applyReminderRemove = createEffectHandler("REMINDER_REMOVE", ({ effect, payloads, playerSeatMap }) => {
+  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);
+  });
+});
+
+// src/effects/handlers/seat-change.ts
+var applySeatChange = createEffectHandler("SEAT_CHANGE", () => {
+  console.warn("SEAT_CHANGE effect handling not implemented yet.");
+});
+
+// src/effects/handlers/status-change.ts
+var applyStatusChange = createEffectHandler("STATUS_CHANGE", ({ effect, payloads, makePlayersEffect }) => {
+  const maybeStatus = getSourceValue(effect.source, payloads);
+  if (maybeStatus === "DEAD") {
+    makePlayersEffect.forEach((player) => {
+      player.isDead = true;
+    });
+    return;
+  }
+  if (maybeStatus === "ALIVE") {
+    makePlayersEffect.forEach((player) => {
+      player.isDead = false;
+    });
+    return;
+  }
+  console.warn("Invalid status value for STATUS_CHANGE effect:", maybeStatus);
+});
+
+// src/effects/registry.ts
+var effectHandlers = {
+  ABILITY_CHANGE: applyAbilityChange,
+  ALIGNMENT_CHANGE: applyAlignmentChange,
+  CHARACTER_CHANGE: applyCharacterChange,
+  CHARACTER_COUNT_CHANGE: applyCharacterCountChange,
+  GAME_CHANGE: applyGameChange,
+  PERCEIVED_CHARACTER_CHANGE: applyPerceivedCharacterChange,
+  REMINDER_ADD: applyReminderAdd,
+  REMINDER_REMOVE: applyReminderRemove,
+  SEAT_CHANGE: applySeatChange,
+  STATUS_CHANGE: applyStatusChange
+};
+
+// src/effects/resolve-targets.ts
+var isPayloadRef = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  if (candidate.from !== "PAYLOAD") {
+    return false;
+  }
+  return typeof candidate.value === "number" || Array.isArray(candidate.value);
+};
+var resolveDynamicValue = (value, payloads, isExpected) => {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (!isPayloadRef(value)) {
+    return isExpected(value) ? value : void 0;
+  }
+  const resolved = getValueFromPayloads(payloads, value.value);
+  if (!isExpected(resolved)) {
+    return void 0;
+  }
+  return resolved;
+};
+var getSortedPlayers = (playerSeatMap) => {
+  return [...playerSeatMap.values()].sort((left, right) => left.seat - right.seat);
+};
+var getCircularDistance = (anchorIdx, targetIdx, total) => {
+  const clockwise = (targetIdx - anchorIdx + total) % total;
+  const anticlockwise = (anchorIdx - targetIdx + total) % total;
+  return Math.min(clockwise, anticlockwise);
+};
+var getAnchorSeat = (dynamicTarget, payloads, effector) => {
+  const anchor = dynamicTarget.anchor;
+  if (!anchor || anchor.from === "EFFECTOR") {
+    return effector?.seat;
+  }
+  if (anchor.from === "STATIC") {
+    return anchor.value;
+  }
+  const payloadSeat = getValueFromPayloads(payloads, anchor.value);
+  return typeof payloadSeat === "number" ? payloadSeat : void 0;
+};
+var resolveSelectorScope = (dynamicTarget, payloads) => {
+  return resolveDynamicValue(
+    dynamicTarget.selector?.scope,
+    payloads,
+    (value) => value === "BOTH_SIDES" || value === "LEFT_SIDE" || value === "RIGHT_SIDE"
+  ) ?? "BOTH_SIDES";
+};
+var getCandidatesBySelector = (dynamicTarget, sortedPlayers, anchorSeat, payloads) => {
+  const selector = dynamicTarget.selector;
+  if (!selector) {
+    return sortedPlayers;
+  }
+  const scope = resolveSelectorScope(dynamicTarget, payloads);
+  if (!anchorSeat) {
+    return [];
+  }
+  const anchorIdx = sortedPlayers.findIndex((player) => player.seat === anchorSeat);
+  if (anchorIdx < 0) {
+    return [];
+  }
+  const total = sortedPlayers.length;
+  if (scope === "LEFT_SIDE") {
+    const left2 = [];
+    for (let step = 1; step < total; step += 1) {
+      left2.push(sortedPlayers[(anchorIdx - step + total) % total]);
+    }
+    return left2;
+  }
+  if (scope === "RIGHT_SIDE") {
+    const right2 = [];
+    for (let step = 1; step < total; step += 1) {
+      right2.push(sortedPlayers[(anchorIdx + step) % total]);
+    }
+    return right2;
+  }
+  const left = [];
+  const right = [];
+  for (let step = 1; step < total; step += 1) {
+    left.push(sortedPlayers[(anchorIdx - step + total) % total]);
+    right.push(sortedPlayers[(anchorIdx + step) % total]);
+  }
+  return [...left, ...right];
+};
+var matchesCondition = (player, condition, payloads, characterMap) => {
+  if (condition.field === "IS_DEAD") {
+    const expected = resolveDynamicValue(condition.value, payloads, (value) => typeof value === "boolean");
+    if (typeof expected !== "boolean") {
+      return false;
+    }
+    return Boolean(player.isDead) === expected;
+  }
+  if (condition.field === "SEAT") {
+    if (condition.operator === "IN") {
+      const expectedSeats = resolveDynamicValue(condition.value, payloads, (value) => Array.isArray(value) && value.every((item) => typeof item === "number"));
+      return Array.isArray(expectedSeats) && expectedSeats.includes(player.seat);
+    }
+    const expectedSeat = resolveDynamicValue(condition.value, payloads, (value) => typeof value === "number");
+    return typeof expectedSeat === "number" && player.seat === expectedSeat;
+  }
+  const character = characterMap.get(player.characterId);
+  const kind = character?.kind;
+  if (!kind) {
+    return false;
+  }
+  if (condition.operator === "IN") {
+    const expectedKinds = resolveDynamicValue(condition.value, payloads, (value) => Array.isArray(value) && value.every((item) => typeof item === "string"));
+    return Array.isArray(expectedKinds) && expectedKinds.includes(kind);
+  }
+  const expectedKind = resolveDynamicValue(condition.value, payloads, (value) => typeof value === "string");
+  return typeof expectedKind === "string" && kind === expectedKind;
+};
+var filterByWhere = (candidates, dynamicTarget, payloads, characterMap) => {
+  const where = dynamicTarget.where;
+  const conditions = where?.conditions ?? [];
+  if (conditions.length === 0) {
+    return candidates;
+  }
+  const isAllMode = where?.mode !== "ANY";
+  return candidates.filter((player) => {
+    const results = conditions.map((condition) => matchesCondition(player, condition, payloads, characterMap));
+    return isAllMode ? results.every(Boolean) : results.some(Boolean);
+  });
+};
+var applySort = (candidates, dynamicTarget, payloads, sortedPlayers, anchorSeat) => {
+  const scope = resolveSelectorScope(dynamicTarget, payloads);
+  if (scope !== "BOTH_SIDES") {
+    return [...candidates];
+  }
+  if (!anchorSeat || sortedPlayers.length <= 1) {
+    return [...candidates].sort((left, right) => left.seat - right.seat);
+  }
+  const seatIndexMap = new Map(sortedPlayers.map((player, idx) => [player.seat, idx]));
+  const anchorIdx = seatIndexMap.get(anchorSeat);
+  if (typeof anchorIdx !== "number") {
+    return [...candidates].sort((left, right) => left.seat - right.seat);
+  }
+  return [...candidates].sort((left, right) => {
+    const leftIdx = seatIndexMap.get(left.seat);
+    const rightIdx = seatIndexMap.get(right.seat);
+    if (typeof leftIdx !== "number" || typeof rightIdx !== "number") {
+      return left.seat - right.seat;
+    }
+    const leftDistance = getCircularDistance(anchorIdx, leftIdx, sortedPlayers.length);
+    const rightDistance = getCircularDistance(anchorIdx, rightIdx, sortedPlayers.length);
+    if (leftDistance !== rightDistance) {
+      return leftDistance - rightDistance;
+    }
+    return left.seat - right.seat;
+  });
+};
+var pickTargets = (sortedCandidates, dynamicTarget, payloads) => {
+  const dedupedCandidates = [...new Map(sortedCandidates.map((player) => [player.seat, player])).values()];
+  const configuredLimit = resolveDynamicValue(dynamicTarget.limit, payloads, (value) => typeof value === "number");
+  if (typeof configuredLimit === "undefined") {
+    return dedupedCandidates;
+  }
+  if (configuredLimit <= 0) {
+    return [];
+  }
+  return dedupedCandidates.slice(0, configuredLimit);
+};
+var resolveEffectTargets = ({
+  effect,
+  operation,
+  payloads,
+  effector,
+  playerSeatMap,
+  characterMap
+}) => {
+  if (!("target" in effect)) {
+    return [];
+  }
+  if (effect.target.from === "EFFECTOR") {
+    if (!effector) {
+      console.warn("Effector player not found for operation:", operation, "effector index:", operation.effector);
+      return null;
+    }
+    return [effector];
+  }
+  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 null;
+    }
+    const seats = Array.isArray(seatValue) ? seatValue : [seatValue];
+    return seats.map((seat) => playerSeatMap.get(seat)).filter((player) => Boolean(player));
+  }
+  if (effect.target.from === "DYNAMIC") {
+    const dynamicTarget = effect.target;
+    const sortedPlayers = getSortedPlayers(playerSeatMap);
+    const anchorSeat = getAnchorSeat(dynamicTarget, payloads, effector);
+    const candidates = getCandidatesBySelector(dynamicTarget, sortedPlayers, anchorSeat, payloads);
+    const filtered = filterByWhere(candidates, dynamicTarget, payloads, characterMap);
+    const ordered = applySort(filtered, dynamicTarget, payloads, sortedPlayers, anchorSeat);
+    return pickTargets(ordered, dynamicTarget, payloads);
+  }
+  return [];
+};
+
 // src/apply-operation.ts
+var isDeferredOperation = (operation, abilityMap) => {
+  const ability = abilityMap.get(operation.abilityId);
+  return ability?.executionTiming === "DEFER_TO_END";
+};
 var applyOperationToPlayers = ({
   players,
   operations,
@@ -183,7 +624,7 @@ var applyOperationToPlayers = ({
     }
     operationsByTimeline.get(timelineIndex)?.push(operation);
   });
-  const applyOps = (ops) => {
+  const applyOpsSequence = (ops) => {
     ops.forEach((operation) => {
       const operationInTimelineIdx = operationTimelineMap.get(operation) ?? -1;
       const ability = abilityMap.get(operation.abilityId);
@@ -194,7 +635,7 @@ var applyOperationToPlayers = ({
       const playerSeatMap = buildPlayerSeatMap(playersWithStatus);
       const effector = playerSeatMap.get(operation.effector);
       const payloads = operation.payloads || [];
-      const writableParts = ability.inputs.filter((part) => !part.readonly);
+      const writableInputs = ability.inputs.filter((part) => !part.readonly);
       let snapshotSeatMap = null;
       const getSnapshotSeatMap = () => {
         if (!snapshotSeatMap) {
@@ -203,165 +644,52 @@ var applyOperationToPlayers = ({
         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.");
+        const makePlayersEffect = resolveEffectTargets({
+          effect,
+          operation,
+          payloads,
+          effector,
+          playerSeatMap,
+          characterMap
+        });
+        if (!makePlayersEffect) {
           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: {
-            console.warn("Unknown effect type:", effect.type);
-          }
+        const handler = effectHandlers[effect.type];
+        if (!handler) {
+          console.warn("Unknown effect type:", effect.type);
+          return;
         }
+        const context = {
+          effect,
+          operation,
+          payloads,
+          effector,
+          writableInputs,
+          playerSeatMap,
+          getSnapshotSeatMap,
+          characterMap,
+          nowTimelineIndex,
+          operationInTimelineIdx,
+          makePlayersEffect
+        };
+        handler(context);
       });
     });
   };
+  const applyOps = (ops) => {
+    const normalOps = [];
+    const deferredOps = [];
+    ops.forEach((operation) => {
+      if (isDeferredOperation(operation, abilityMap)) {
+        deferredOps.push(operation);
+        return;
+      }
+      normalOps.push(operation);
+    });
+    applyOpsSequence(normalOps);
+    applyOpsSequence(deferredOps);
+  };
   const settingsOps = operationsByTimeline.get(-1);
   if (settingsOps) {
     applyOps(settingsOps);