test: refactor slay-the-spire-like combat tests

Update combat effect tests to use the new transform offset structure and fix type mismatches in entity and inventory creation.
chore: add @types/node and update tsconfig
2026-04-20 11:37:18 +08:00 · 2026-04-20 11:34:40 +08:00 · 2026-04-20 11:25:52 +08:00 · 2026-04-20 11:03:44 +08:00 · 2026-04-20 10:28:58 +08:00
14 changed files with 381 additions and 263 deletions
--- a/package-lock.json
+++ b/package-lock.json
@ -10,6 +10,7 @@
      "license": "MIT",
      "devDependencies": {
        "@preact/signals-core": "^1.5.1",
+        "@types/node": "^25.6.0",
        "inline-schema": "file:../inline-schema",
        "mutative": "^1.3.0",
        "tsup": "^8.0.2",
@ -958,6 +959,16 @@
      "dev": true,
      "license": "MIT"
    },
+    "node_modules/@types/node": {
+      "version": "25.6.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.6.0.tgz",
+      "integrity": "sha512-+qIYRKdNYJwY3vRCZMdJbPLJAtGjQBudzZzdzwQYkEPQd+PJGixUL5QfvCLDaULoLv+RhT3LDkwEfKaAkgSmNQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.19.0"
+      }
+    },
    "node_modules/@vitest/expect": {
      "version": "1.6.1",
      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-1.6.1.tgz",
@ -2469,6 +2480,13 @@
      "dev": true,
      "license": "MIT"
    },
+    "node_modules/undici-types": {
+      "version": "7.19.2",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.19.2.tgz",
+      "integrity": "sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg==",
+      "dev": true,
+      "license": "MIT"
+    },
    "node_modules/vite": {
      "version": "5.4.21",
      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
--- a/package.json
+++ b/package.json
@ -30,6 +30,7 @@
  },
  "devDependencies": {
    "@preact/signals-core": "^1.5.1",
+    "@types/node": "^25.6.0",
    "inline-schema": "file:../inline-schema",
    "mutative": "^1.3.0",
    "tsup": "^8.0.2",
--- a/src/samples/slay-the-spire-like/data/desert/triggers/card-events.ts
+++ b/src/samples/slay-the-spire-like/data/desert/triggers/card-events.ts
@ -1,11 +1,10 @@
 import { Triggers } from "@/samples/slay-the-spire-like/system/combat/triggers";
 import { getCombatEntity } from "@/samples/slay-the-spire-like/system/combat/effects";
-import { getAdjacentItems } from "@/samples/slay-the-spire-like/system/grid-inventory";
-import { GameItemMeta } from "@/samples/slay-the-spire-like/system/progress";
 import { EffectData } from "@/samples/slay-the-spire-like/system/types";
 import getEffects from "../effect.csv";
+import { IRunContext } from "@/samples/slay-the-spire-like/system/combat/types";

-export function addCardEventTriggers(triggers: Triggers) {
+export function addCardEventTriggers(triggers: Triggers, run: IRunContext) {
  const effects = getEffects();

  function findEffect(id: string): EffectData {
@ -67,21 +66,21 @@ export function addCardEventTriggers(triggers: Triggers) {
    if (!card) return;
    const playedItemId = card.itemId;

-    const adjacent = getAdjacentItems<GameItemMeta>(
-      ctx.game.value.inventory,
-      playedItemId,
-    );
-    for (const [adjItemId] of adjacent) {
+    const adjacent = run.getNeighborItems(playedItemId);
+    for (const adjItemId of adjacent) {
      const adjEffects = ctx.game.value.player.itemEffects[adjItemId];
      if (!adjEffects) continue;
      const burn = adjEffects.burnForEnergy;
      if (!burn || burn.stacks <= 0) continue;

+      const item = run.getItemData(adjItemId);
+      const maxUses =
+        item?.card.costType === "energy" ? item.card.costCount : 0;
+      const consumed = run.getConsumedUses(adjItemId);
+      const toConsume = Math.min(maxUses - consumed, burn.stacks);
+
+      await run.setConsumedUsesAsync(adjItemId, consumed + toConsume);
      await ctx.game.produceAsync((draft) => {
-        const item = draft.inventory.items.get(adjItemId);
-        if (item) {
-          draft.inventory.items.delete(adjItemId);
-        }
        draft.player.energy += burn.stacks;
        delete draft.player.itemEffects[adjItemId];
      });
--- a/src/samples/slay-the-spire-like/data/desert/triggers/effect.ts
+++ b/src/samples/slay-the-spire-like/data/desert/triggers/effect.ts
@ -1,12 +1,13 @@
+import { IRunContext } from "@/samples/slay-the-spire-like/system/combat/types";
 import { Triggers } from "@/samples/slay-the-spire-like/system/combat/triggers";
 import { addInstantEffectTriggers } from "./instant";
 import { addDamageTriggers } from "./damage";
 import { addTurnStartTriggers } from "./turn-start";
 import { addCardEventTriggers } from "./card-events";

-export function addDesertTriggers(triggers: Triggers) {
+export function addDesertTriggers(triggers: Triggers, run: IRunContext) {
  addInstantEffectTriggers(triggers);
  addDamageTriggers(triggers);
  addTurnStartTriggers(triggers);
-    addCardEventTriggers(triggers);
+  addCardEventTriggers(triggers, run);
 }
--- a/src/samples/slay-the-spire-like/system/combat/effects.ts
+++ b/src/samples/slay-the-spire-like/system/combat/effects.ts
@ -1,78 +1,95 @@
-import {CombatEntity, CombatGameContext, CombatState, EffectTable, PlayerEntity} from "./types";
+import {
+  CombatEntity,
+  CombatGameContext,
+  CombatState,
+  EffectTable,
+  IRunContext,
+  PlayerEntity,
+} from "./types";
 import {
  CardData,
  CardEffectTarget,
  CardTargetType,
  EffectData,
-    EffectTarget
+  EffectTarget,
 } from "@/samples/slay-the-spire-like/system/types";
-import {GameItemMeta} from "@/samples/slay-the-spire-like/system/progress/types";
-import {GridInventory} from "@/samples/slay-the-spire-like/system/grid-inventory/types";

-export function addEffect(effects: EffectTable, effect: EffectData, stacks: number){
+export function addEffect(
+  effects: EffectTable,
+  effect: EffectData,
+  stacks: number,
+) {
  let current = effects[effect.id];

-    if(!current) current = {data: effect, stacks};
+  if (!current) current = { data: effect, stacks };
  else current.stacks += stacks;

-    if(current.stacks === 0 && effects[effect.id])
-        delete effects[effect.id];
-    else if(current.stacks !== 0 && !effects[effect.id])
+  if (current.stacks === 0 && effects[effect.id]) delete effects[effect.id];
+  else if (current.stacks !== 0 && !effects[effect.id])
    effects[effect.id] = current;
 }

-export function addEntityEffect(entity: CombatEntity, effect: EffectData, stacks: number){
+export function addEntityEffect(
+  entity: CombatEntity,
+  effect: EffectData,
+  stacks: number,
+) {
  addEffect(entity.effects, effect, stacks);
 }

-export function addItemEffect(entity: PlayerEntity, itemKey: string, effect: EffectData, stacks: number){
+export function addItemEffect(
+  entity: PlayerEntity,
+  itemKey: string,
+  effect: EffectData,
+  stacks: number,
+) {
  entity.itemEffects[itemKey] = entity.itemEffects[itemKey] || {};
  addEffect(entity.itemEffects[itemKey], effect, stacks);
 }

-export function onEntityEffectUpkeep(entity: CombatEntity){
-    for(const effect of Object.values(entity.effects)){
+export function onEntityEffectUpkeep(entity: CombatEntity) {
+  for (const effect of Object.values(entity.effects)) {
    const lifecycle = effect.data.lifecycle;
-        if(lifecycle === 'temporary')
+    if (lifecycle === "temporary")
      addEntityEffect(entity, effect.data, -effect.stacks);
-        else if(lifecycle === 'lingering')
+    else if (lifecycle === "lingering")
      addEntityEffect(entity, effect.data, effect.stacks >= 0 ? -1 : 1);
  }
 }

-export function onEntityPostureDamage(entity: CombatEntity, damage: number){
-    for(const effect of Object.values(entity.effects)){
+export function onEntityPostureDamage(entity: CombatEntity, damage: number) {
+  for (const effect of Object.values(entity.effects)) {
    const lifecycle = effect.data.lifecycle;
-        if(lifecycle === 'posture')
+    if (lifecycle === "posture")
      addEntityEffect(entity, effect.data, -Math.min(damage, effect.stacks));
  }
 }

-export function onPlayerItemEffectUpkeep(entity: PlayerEntity){
-    for(const [itemKey, itemEffects] of Object.entries(entity.itemEffects)){
-        for(const effect of Object.values(itemEffects)){
+export function onPlayerItemEffectUpkeep(entity: PlayerEntity) {
+  for (const [itemKey, itemEffects] of Object.entries(entity.itemEffects)) {
+    for (const effect of Object.values(itemEffects)) {
      const lifecycle = effect.data.lifecycle;
-            if(lifecycle === 'itemTemporary')
+      if (lifecycle === "itemTemporary")
        addItemEffect(entity, itemKey, effect.data, -effect.stacks);
    }
  }
 }

-export function onItemPlay(entity: PlayerEntity, itemKey: string){
+export function onItemPlay(entity: PlayerEntity, itemKey: string) {
  const effects = entity.itemEffects[itemKey];
-    if(!effects)return;
-    for(const effect of Object.values(effects)){
-        if(effect.data.lifecycle === 'itemUntilPlay'){
+  if (!effects) return;
+  for (const effect of Object.values(effects)) {
+    if (effect.data.lifecycle === "itemUntilPlay") {
      addItemEffect(entity, itemKey, effect.data, -effect.stacks);
    }
  }
 }

-export function onItemDiscard(entity: PlayerEntity, itemKey: string){
+export function onItemDiscard(entity: PlayerEntity, itemKey: string) {
  const effects = entity.itemEffects[itemKey];
-    if(!effects)return;
-    for(const effect of Object.values(effects)){
-        if(effect.data.lifecycle === 'itemUntilDiscard'){
+  if (!effects) return;
+  for (const effect of Object.values(effects)) {
+    if (effect.data.lifecycle === "itemUntilDiscard") {
      addItemEffect(entity, itemKey, effect.data, -effect.stacks);
    }
  }
@ -86,49 +103,66 @@ export function* getAliveEnemies(state: CombatState) {
  }
 }

-export function* getEffectTargets(target: CardEffectTarget | EffectTarget, game: CombatGameContext, targetId?: string){
-    if(target === 'all' || target === 'team'){
-        for(const enemy of getAliveEnemies(game.value)){
+export function* getEffectTargets(
+  target: CardEffectTarget | EffectTarget,
+  game: CombatGameContext,
+  targetId?: string,
+) {
+  if (target === "all" || target === "team") {
+    for (const enemy of getAliveEnemies(game.value)) {
      yield enemy;
    }
-    } else if(target === 'self') {
+  } else if (target === "self") {
    yield game.value.player;
-    } else if(target === 'target'){
-        if(!targetId) return;
+  } else if (target === "target") {
+    if (!targetId) return;
    const entity = getCombatEntity(game.value, targetId);
-        if(entity) yield entity;
-    } else if(target === 'random'){
+    if (entity) yield entity;
+  } else if (target === "random") {
    const aliveEnemies = [...getAliveEnemies(game.value)];
-        if(aliveEnemies.length === 0) return;
+    if (aliveEnemies.length === 0) return;
    const index = game.rng.nextInt(aliveEnemies.length);
    yield aliveEnemies[index];
  }
 }

-export function getCombatEntity(state: CombatState, entityKey: string){
-    return entityKey === 'player' ? state.player : state.enemies.find(e => e.id === entityKey);
+export function getCombatEntity(state: CombatState, entityKey: string) {
+  return entityKey === "player"
+    ? state.player
+    : state.enemies.find((e) => e.id === entityKey);
 }

-export function canPlayCard(player: PlayerEntity, costType: CardData['costType'], costCount: number, itemId: string, inventory: GridInventory<GameItemMeta>): boolean {
-    if (costType === 'energy') {
+export function canPlayCard(
+  player: PlayerEntity,
+  costType: CardData["costType"],
+  costCount: number,
+  itemId: string,
+  run: IRunContext,
+): boolean {
+  if (costType === "energy") {
    return player.energy >= costCount;
  }
-    if (costType === 'uses') {
-        const item = inventory.items.get(itemId);
-        if (!item || !item.meta) return false;
-        const depletion = item.meta.depletion ?? 0;
-        return depletion < costCount;
+  if (costType === "uses") {
+    const item = run.getItemData(itemId);
+    if (!item) return false;
+    const maxUses = item?.card.costType === "uses" ? item.card.costCount : 0;
+    const consumed = run.getConsumedUses(itemId);
+    return consumed < maxUses;
  }
  return true;
 }

-export function payCardCost(player: PlayerEntity, costType: CardData['costType'], costCount: number, itemId: string, inventory: GridInventory<GameItemMeta>): void {
-    if (costType === 'energy') {
+export async function payCardCost(
+  player: PlayerEntity,
+  costType: CardData["costType"],
+  costCount: number,
+  itemId: string,
+  run: IRunContext,
+): Promise<void> {
+  if (costType === "energy") {
    player.energy -= costCount;
-    } else if (costType === 'uses') {
-        const item = inventory.items.get(itemId);
-        if (item && item.meta) {
-            item.meta.depletion = (item.meta.depletion ?? 0) + costCount;
-        }
+  } else if (costType === "uses") {
+    const consumed = run.getConsumedUses(itemId);
+    await run.setConsumedUsesAsync(itemId, consumed + costCount);
  }
 }
--- a/src/samples/slay-the-spire-like/system/combat/prompts.ts
+++ b/src/samples/slay-the-spire-like/system/combat/prompts.ts
@ -1,43 +1,56 @@
 import { createPromptDef } from "@/core/game";
-import {CombatGameContext} from "./types";
-import {canPlayCard} from "@/samples/slay-the-spire-like/system/combat/effects";
+import { CombatGameContext, IRunContext } from "./types";
+import { canPlayCard } from "@/samples/slay-the-spire-like/system/combat/effects";

 export const prompts = {
  mainAction: createPromptDef<[string, string?]>(
    "main-action <cardId:string> [targetId:string]",
-        "选择卡牌并指定目标"
+    "选择卡牌并指定目标",
  ),
 };

-export async function promptMainAction(game: CombatGameContext){
+export async function promptMainAction(
+  game: CombatGameContext,
+  run: IRunContext,
+) {
  return await game.prompt(prompts.mainAction, (cardId, targetId) => {
-        if(cardId === 'end-turn') return {
-            action: 'end-turn' as 'end-turn'
+    if (cardId === "end-turn")
+      return {
+        action: "end-turn" as "end-turn",
      };

-        const exists = game.value.player.deck.regions.hand.childIds.includes(cardId);
-        if(!exists) throw `卡牌"${cardId}"不在手牌中`;
+    const exists =
+      game.value.player.deck.regions.hand.childIds.includes(cardId);
+    if (!exists) throw `卡牌"${cardId}"不在手牌中`;

    const card = game.value.player.deck.cards[cardId];
-        const {cardData, itemId} = card;
-        if(!canPlayCard(game.value.player, cardData.costType, cardData.costCount, itemId, game.value.inventory)){
+    const { cardData, itemId } = card;
+    if (
+      !canPlayCard(
+        game.value.player,
+        cardData.costType,
+        cardData.costCount,
+        itemId,
+        run,
+      )
+    ) {
      throw `无法支付卡牌"${cardId}"的费用`;
    }

-        const {targetType} = cardData;
-        if(targetType === 'single'){
-            if(!targetId) throw `请指定目标`;
-            const target = game.value.enemies.find(e => e.id === targetId);
-            if(!target) throw `目标"${targetId}"不存在`;
-            if(!target.isAlive) throw `目标"${targetId}"已死亡`;
-        }else if(targetType === 'none'){
-            if(targetId) throw `目标"${targetId}"无效`;
+    const { targetType } = cardData;
+    if (targetType === "single") {
+      if (!targetId) throw `请指定目标`;
+      const target = game.value.enemies.find((e) => e.id === targetId);
+      if (!target) throw `目标"${targetId}"不存在`;
+      if (!target.isAlive) throw `目标"${targetId}"已死亡`;
+    } else if (targetType === "none") {
+      if (targetId) throw `目标"${targetId}"无效`;
    }

    return {
-            action: 'play' as 'play',
+      action: "play" as "play",
      cardId,
-            targetId
+      targetId,
    };
  });
 }
--- a/src/samples/slay-the-spire-like/system/combat/triggers.ts
+++ b/src/samples/slay-the-spire-like/system/combat/triggers.ts
@ -1,4 +1,4 @@
-import { CombatGameContext } from "./types";
+import { CombatGameContext, IRunContext } from "./types";
 import {
  addEntityEffect,
  addItemEffect,
@ -51,7 +51,7 @@ type TriggerTypes = {
  onIntentUpdate: { enemyId: string };
 };

-export function createTriggers() {
+export function createTriggers(run: IRunContext) {
  const triggers = {
    onCombatStart: createTrigger("onCombatStart"),
    onTurnStart: createTrigger("onTurnStart", async (ctx) => {
@ -89,7 +89,7 @@ export function createTriggers() {
          card.cardData.costType,
          card.cardData.costCount,
          card.itemId,
-          draft.inventory,
+          run,
        );
        moveToRegion(card, regions.hand, regions.discardPile);
        onItemPlay(draft.player, card.itemId);
@ -176,11 +176,8 @@ export function createTriggers() {
      if (ctx.effect.lifecycle.startsWith("item")) {
        if (ctx.cardId) {
          const card = ctx.game.value.player.deck.cards[ctx.cardId];
-          const nearby = getAdjacentItems<GameItemMeta>(
-            ctx.game.value.inventory,
-            card.itemId,
-          );
-          for (const itemId of nearby.keys()) {
+          const nearby = run.getNeighborItems(card.itemId);
+          for (const itemId of nearby) {
            await ctx.game.produceAsync((draft) => {
              addItemEffect(draft.player, itemId, ctx.effect, ctx.stacks);
            });
@ -269,9 +266,12 @@ export function createTriggers() {
  return triggers;
 }
 export type Triggers = ReturnType<typeof createTriggers>;
-export function createStartWith(build: (triggers: Triggers) => void) {
-  const triggers = createTriggers();
-  build(triggers);
+export function createStartWith(
+  build: (triggers: Triggers, run: IRunContext) => void,
+  run: IRunContext,
+) {
+  const triggers = createTriggers(run);
+  build(triggers, run);
  return async function (game: CombatGameContext) {
    await triggers.onCombatStart.execute(game, {});

@ -279,7 +279,7 @@ export function createStartWith(build: (triggers: Triggers) => void) {
      while (true) {
        await triggers.onTurnStart.execute(game, { entityKey: "player" });
        while (true) {
-          const action = await promptMainAction(game);
+          const action = await promptMainAction(game, run);
          if (action.action === "end-turn") break;
          if (action.action === "play") {
            await triggers.onCardPlayed.execute(game, action);
--- a/src/samples/slay-the-spire-like/system/combat/types.ts
+++ b/src/samples/slay-the-spire-like/system/combat/types.ts
@ -2,10 +2,9 @@ import type { PlayerDeck } from "../deck/types";
 import {
  EnemyData,
  IntentData,
+  ItemData,
 } from "@/samples/slay-the-spire-like/system/types";
 import { EffectData } from "@/samples/slay-the-spire-like/system/types";
-import { GridInventory } from "@/samples/slay-the-spire-like/system/grid-inventory";
-import { GameItemMeta } from "@/samples/slay-the-spire-like/system/progress";

 export type EffectTable = Record<string, { data: EffectData; stacks: number }>;

@ -46,7 +45,6 @@ export type LootEntry =
 export type CombatState = {
  enemies: EnemyEntity[];
  player: PlayerEntity;
-  inventory: GridInventory<GameItemMeta>;

  phase: CombatPhase;
  turnNumber: number;
@ -55,5 +53,13 @@ export type CombatState = {
  loot: LootEntry[];
 };

+export interface IRunContext {
+  getItemData(id: string): ItemData | null;
+  getNeighborItems(id: string): Iterable<string>;
+
+  getConsumedUses(id: string): number;
+  setConsumedUsesAsync(id: string, uses: number): Promise<void>;
+}
+
 export type CombatGameContext =
  import("@/core/game").IGameContextExport<CombatState>;
--- a/src/samples/slay-the-spire-like/system/progress/encounter.ts
+++ b/src/samples/slay-the-spire-like/system/progress/encounter.ts
@ -94,7 +94,6 @@ export function buildCombatState(runState: RunState): CombatState {
  return {
    enemies,
    player,
-    inventory: runState.inventory,
    phase: "playerTurn",
    turnNumber: 1,
    result: null,
--- a/src/samples/slay-the-spire-like/system/progress/types.ts
+++ b/src/samples/slay-the-spire-like/system/progress/types.ts
@ -1,7 +1,7 @@
-import type { PointCrawlMap } from '../map/types';
-import type { GridInventory, InventoryItem } from '../grid-inventory/types';
-import type { ParsedShape } from '../utils/parse-shape';
-import {ItemData} from "@/samples/slay-the-spire-like/system/types";
+import type { PointCrawlMap } from "../map/types";
+import type { GridInventory, InventoryItem } from "../grid-inventory/types";
+import type { ParsedShape } from "../utils/parse-shape";
+import { ItemData } from "@/samples/slay-the-spire-like/system/types";

 /**
 * Result of an encounter (combat, event, etc.).
@ -39,7 +39,9 @@ export interface GameItemMeta {
  /** Parsed shape for grid placement */
  shape: ParsedShape;
  /** Consumed uses, if card cost type is uses**/
-    depletion?: number;
+  consumedUses?: number;
+  /** Effects applied to the item */
+  effects?: Record<string, number>;
 }

 /**
@ -84,4 +86,6 @@ export interface RunState {
 /**
 * Result of a mutation operation on the run state.
 */
-export type RunMutationResult = { success: true } | { success: false; reason: string };
+export type RunMutationResult =
+  | { success: true }
+  | { success: false; reason: string };
--- a/tests/samples/slay-the-spire-like/combat/effects.test.ts
+++ b/tests/samples/slay-the-spire-like/combat/effects.test.ts
@ -17,10 +17,14 @@ import type {
  CombatEntity,
  CombatState,
  EffectTable,
+  IRunContext,
  PlayerEntity,
  EnemyEntity,
 } from "@/samples/slay-the-spire-like/system/combat/types";
-import type { EffectData } from "@/samples/slay-the-spire-like/system/types";
+import type {
+  EffectData,
+  ItemData,
+} from "@/samples/slay-the-spire-like/system/types";
 import type {
  CellKey,
  GridInventory,
@ -30,6 +34,31 @@ import type { GameItemMeta } from "@/samples/slay-the-spire-like/system/progress
 import type { ParsedShape } from "@/samples/slay-the-spire-like/system/utils/parse-shape";
 import type { Transform2D } from "@/samples/slay-the-spire-like/system/utils/shape-collision";

+function createRunContext(
+  items: Map<string, InventoryItem<GameItemMeta>>,
+): IRunContext {
+  return {
+    getItemData(id: string): ItemData | null {
+      const item = items.get(id);
+      return item?.meta?.itemData ?? null;
+    },
+    getNeighborItems(_id: string): Iterable<string> {
+      return [];
+    },
+    getConsumedUses(id: string): number {
+      const item = items.get(id);
+      return item?.meta?.consumedUses ?? 0;
+    },
+    setConsumedUsesAsync(id: string, uses: number): Promise<void> {
+      const item = items.get(id);
+      if (item?.meta) {
+        item.meta.consumedUses = uses;
+      }
+      return Promise.resolve();
+    },
+  };
+}
+
 function createEffect(
  id: string,
  lifecycle: EffectData["lifecycle"],
@ -65,9 +94,7 @@ function createItem(
    id: itemId,
    shape: { id: "1x1", cells: [{ x: 0, y: 0 }] } as unknown as ParsedShape,
    transform: {
-      x: 0,
-      y: 0,
-      rotation: 0,
+      offset: { x: 0, y: 0 },
      flipX: false,
      flipY: false,
    } as unknown as Transform2D,
@ -82,7 +109,7 @@ function createItem(
        description: "",
      },
      shape: { id: "1x1", cells: [{ x: 0, y: 0 }] } as unknown as ParsedShape,
-      depletion: costType === "uses" ? depletion : undefined,
+      consumedUses: costType === "uses" ? depletion : undefined,
    },
  };
 }
@ -94,13 +121,14 @@ function createInventory(
  const occupied = new Set<CellKey>();
  for (const item of items) {
    map.set(item.id, item);
-    occupied.add(`${item.transform.x},${item.transform.y}`);
+    occupied.add(`${item.transform.offset.x},${item.transform.offset.y}`);
  }
  return { width: 6, height: 4, items: map, occupiedCells: occupied };
 }

 function createCombatEntity(hp = 10, maxHp = 10): CombatEntity {
  return {
+    id: "",
    effects: {},
    hp,
    maxHp,
@ -130,9 +158,9 @@ function createEnemyEntity(id: string, hp = 10, maxHp = 10): EnemyEntity {
  return {
    ...createCombatEntity(hp, maxHp),
    id,
-    enemy: { id, name: id, description: "" },
+    enemy: { id, name: id, description: "", intents: null! },
    intents: {},
-    currentIntentId: "",
+    currentIntent: null!,
  };
 }

@ -143,12 +171,6 @@ function createCombatState(
  return {
    player: createPlayerEntity(playerHp),
    enemies,
-    inventory: {
-      width: 6,
-      height: 4,
-      items: new Map(),
-      occupiedCells: new Set(),
-    },
    phase: "playerTurn",
    turnNumber: 1,
    result: null,
@ -517,8 +539,9 @@ describe("combat/effects", () => {
      const player = createPlayerEntity();
      player.energy = 3;
      const inventory = createInventory([]);
+      const run = createRunContext(inventory.items);

-      const result = canPlayCard(player, "energy", 2, "any", inventory);
+      const result = canPlayCard(player, "energy", 2, "any", run);

      expect(result).toBe(true);
    });
@ -527,8 +550,9 @@ describe("combat/effects", () => {
      const player = createPlayerEntity();
      player.energy = 1;
      const inventory = createInventory([]);
+      const run = createRunContext(inventory.items);

-      const result = canPlayCard(player, "energy", 2, "any", inventory);
+      const result = canPlayCard(player, "energy", 2, "any", run);

      expect(result).toBe(false);
    });
@ -537,8 +561,9 @@ describe("combat/effects", () => {
      const player = createPlayerEntity();
      const item = createItem("potion-1", "potion-card", "uses", 3, 1);
      const inventory = createInventory([item]);
+      const run = createRunContext(inventory.items);

-      const result = canPlayCard(player, "uses", 3, "potion-1", inventory);
+      const result = canPlayCard(player, "uses", 3, "potion-1", run);

      expect(result).toBe(true);
    });
@ -547,8 +572,9 @@ describe("combat/effects", () => {
      const player = createPlayerEntity();
      const item = createItem("potion-1", "potion-card", "uses", 3, 3);
      const inventory = createInventory([item]);
+      const run = createRunContext(inventory.items);

-      const result = canPlayCard(player, "uses", 3, "potion-1", inventory);
+      const result = canPlayCard(player, "uses", 3, "potion-1", run);

      expect(result).toBe(false);
    });
@ -556,8 +582,9 @@ describe("combat/effects", () => {
    it("should reject playing uses card when item not in inventory", () => {
      const player = createPlayerEntity();
      const inventory = createInventory([]);
+      const run = createRunContext(inventory.items);

-      const result = canPlayCard(player, "uses", 1, "missing", inventory);
+      const result = canPlayCard(player, "uses", 1, "missing", run);

      expect(result).toBe(false);
    });
@ -566,51 +593,56 @@ describe("combat/effects", () => {
      const player = createPlayerEntity();
      player.energy = 0;
      const inventory = createInventory([]);
+      const run = createRunContext(inventory.items);

-      const result = canPlayCard(player, "none", 0, "any", inventory);
+      const result = canPlayCard(player, "none", 0, "any", run);

      expect(result).toBe(true);
    });
  });

  describe("payCardCost", () => {
-    it("should deduct energy for energy cost card", () => {
+    it("should deduct energy for energy cost card", async () => {
      const player = createPlayerEntity();
      player.energy = 3;
      const inventory = createInventory([]);
+      const run = createRunContext(inventory.items);

-      payCardCost(player, "energy", 2, "any", inventory);
+      await payCardCost(player, "energy", 2, "any", run);

      expect(player.energy).toBe(1);
    });

-    it("should increment depletion for uses cost card", () => {
+    it("should increment depletion for uses cost card", async () => {
      const player = createPlayerEntity();
      const item = createItem("potion-1", "potion-card", "uses", 3, 1);
      const inventory = createInventory([item]);
+      const run = createRunContext(inventory.items);

-      payCardCost(player, "uses", 3, "potion-1", inventory);
+      await payCardCost(player, "uses", 3, "potion-1", run);

-      expect(item.meta?.depletion).toBe(4);
+      expect(item.meta?.consumedUses).toBe(4);
    });

-    it("should do nothing for none cost card", () => {
+    it("should do nothing for none cost card", async () => {
      const player = createPlayerEntity();
      player.energy = 3;
      const inventory = createInventory([]);
+      const run = createRunContext(inventory.items);

-      payCardCost(player, "none", 0, "any", inventory);
+      await payCardCost(player, "none", 0, "any", run);

      expect(player.energy).toBe(3);
    });

-    it("should handle missing item gracefully for uses cost", () => {
+    it("should handle missing item gracefully for uses cost", async () => {
      const player = createPlayerEntity();
      const inventory = createInventory([]);
+      const run = createRunContext(inventory.items);

-      expect(() =>
-        payCardCost(player, "uses", 1, "missing", inventory),
-      ).not.toThrow();
+      await expect(
+        payCardCost(player, "uses", 1, "missing", run),
+      ).resolves.not.toThrow();
    });
  });
 });
--- a/tests/samples/slay-the-spire-like/combat/triggers.test.ts
+++ b/tests/samples/slay-the-spire-like/combat/triggers.test.ts
@ -14,6 +14,7 @@ import { addTriggers } from "@/samples/slay-the-spire-like/data/desert/triggers"
 import {
  CombatState,
  EnemyEntity,
+  IRunContext,
 } from "@/samples/slay-the-spire-like/system/combat/types";
 import { EffectData } from "@/samples/slay-the-spire-like/system/types";
 import {
@ -138,7 +139,6 @@ function createCombatState(overrides: Partial<CombatState> = {}): CombatState {
      itemEffects: {},
    },
    enemies: [],
-    inventory: createInventory([]),
    phase: "playerTurn",
    turnNumber: 1,
    result: null,
@ -155,8 +155,18 @@ function createTestContext(state?: CombatState): IGameContext<CombatState> {
 }

 function getTriggers(): Triggers {
-  const triggers = createTriggers();
-  addTriggers(triggers);
+  const run: IRunContext = {
+    getConsumedUses() {
+      return 0;
+    },
+    getItemData() {
+      return null;
+    },
+    *getNeighborItems() {},
+    async setConsumedUsesAsync() {},
+  };
+  const triggers = createTriggers(run);
+  addTriggers(triggers, run);
  return triggers;
 }

--- a/tsconfig.json
+++ b/tsconfig.json
@ -5,6 +5,7 @@
    "lib": ["ES2020"],
    "moduleResolution": "bundler",
    "strict": true,
+    "types": ["node"],
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
@ -18,6 +19,6 @@
      "@/*": ["src/*"],
    },
  },
-  "include": ["src/**/*", "tests/**/*"],
+  "include": ["src/**/*", "tests/**/*", "*.config.ts"],
  "exclude": ["node_modules", "dist"],
 }
--- a/tsup.config.ts
+++ b/tsup.config.ts
@ -1,20 +1,20 @@
-import { defineConfig } from 'tsup';
-import { fileURLToPath } from 'url';
-import { csvLoader } from 'inline-schema/csv-loader/rollup';
+import { defineConfig } from "tsup";
+import { fileURLToPath } from "url";
+import { csvLoader } from "inline-schema/csv-loader/rollup";

-const srcDir = fileURLToPath(new URL('./src', import.meta.url));
+const srcDir = fileURLToPath(new URL("./src", import.meta.url));

 export default defineConfig({
-  entry: ['src/index.ts'],
-  format: ['esm'],
+  entry: ["src/index.ts"],
+  format: ["esm"],
  dts: true,
  clean: true,
  sourcemap: true,
-  external: ['@preact/signals-core', 'mutative', 'inline-schema'],
+  external: ["@preact/signals-core", "mutative", "inline-schema"],
  plugins: [csvLoader()],
  esbuildOptions(options) {
    options.alias = {
-      '@': srcDir,
+      "@": srcDir,
    };
  },
 });
Author	SHA1	Message	Date
hypercross	88d31430a6	test: refactor slay-the-spire-like combat tests Update combat effect tests to use the new transform offset structure and fix type mismatches in entity and inventory creation.	2026-04-20 11:37:18 +08:00
hypercross	90cb97e0ae	chore: add @types/node and update tsconfig Add @types/node as a dev dependency and include it in tsconfig types to support Node.js globals. Also expand tsconfig include to cover configuration files.	2026-04-20 11:34:40 +08:00
hypercross	5e172c61bb	refactor(slay-the-spire-like): use IRunContext in combat system Update the combat system to use `IRunContext` instead of passing raw inventory objects. This provides a cleaner abstraction for accessing item data and managing consumed uses. - Update `canPlayCard` and `payCardCost` to use `IRunContext` - Pass `IRunContext` through the trigger registration chain - Fix logic in `canPlayCard` for "uses" cost validation - Update combat effect tests to use a mock `IRunContext`	2026-04-20 11:25:52 +08:00
hypercross	5019bc6324	refactor(slay-the-spire-like): use IRunContext for combat logic Decouple combat systems from the inventory and progress state by introducing `IRunContext`. This replaces direct access to `GridInventory` and `GameItemMeta` with abstract methods for retrieving item data, neighbors, and managing consumed uses.	2026-04-20 11:03:44 +08:00
hypercross	9bed2ca13e	refactor(slay-the-spire-like): rename depletion to consumedUses Rename `depletion` to `consumedUses` in `GameItemMeta` to better reflect its purpose. Update combat effect logic and tests to use the new field name. Also apply consistent formatting and import organization to combat effect modules.	2026-04-20 10:28:58 +08:00