package-lock.json

@@ -10,7 +10,6 @@
       "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",
@@ -959,16 +958,6 @@
       "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",
@@ -2480,13 +2469,6 @@
       "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",

package.json

@@ -30,7 +30,6 @@
   },
   "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",

src/samples/slay-the-spire-like/data/desert/triggers/card-events.ts

@@ -1,10 +1,11 @@
 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, run: IRunContext) {
+export function addCardEventTriggers(triggers: Triggers) {
   const effects = getEffects();
 
   function findEffect(id: string): EffectData {
@@ -66,21 +67,21 @@ export function addCardEventTriggers(triggers: Triggers, run: IRunContext) {
     if (!card) return;
     const playedItemId = card.itemId;
 
-    const adjacent = run.getNeighborItems(playedItemId);
-    for (const adjItemId of adjacent) {
+    const adjacent = getAdjacentItems<GameItemMeta>(
+      ctx.game.value.inventory,
+      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];
       });

src/samples/slay-the-spire-like/data/desert/triggers/effect.ts

@@ -1,13 +1,12 @@
-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, run: IRunContext) {
-  addInstantEffectTriggers(triggers);
-  addDamageTriggers(triggers);
-  addTurnStartTriggers(triggers);
-  addCardEventTriggers(triggers, run);
+export function addDesertTriggers(triggers: Triggers) {
+    addInstantEffectTriggers(triggers);
+    addDamageTriggers(triggers);
+    addTurnStartTriggers(triggers);
+    addCardEventTriggers(triggers);
 }

src/samples/slay-the-spire-like/system/combat/effects.ts

@@ -1,168 +1,134 @@
+import {CombatEntity, CombatGameContext, CombatState, EffectTable, PlayerEntity} from "./types";
 import {
-  CombatEntity,
-  CombatGameContext,
-  CombatState,
-  EffectTable,
-  IRunContext,
-  PlayerEntity,
-} from "./types";
-import {
-  CardData,
-  CardEffectTarget,
-  CardTargetType,
-  EffectData,
-  EffectTarget,
+    CardData,
+    CardEffectTarget,
+    CardTargetType,
+    EffectData,
+    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,
-) {
-  let current = effects[effect.id];
-
-  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])
-    effects[effect.id] = current;
+export function addEffect(effects: EffectTable, effect: EffectData, stacks: number){
+    let current = effects[effect.id];
+    
+    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])
+        effects[effect.id] = current;
 }
 
-export function addEntityEffect(
-  entity: CombatEntity,
-  effect: EffectData,
-  stacks: number,
-) {
-  addEffect(entity.effects, effect, stacks);
+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,
-) {
-  entity.itemEffects[itemKey] = entity.itemEffects[itemKey] || {};
-  addEffect(entity.itemEffects[itemKey], effect, stacks);
+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)) {
-    const lifecycle = effect.data.lifecycle;
-    if (lifecycle === "temporary")
-      addEntityEffect(entity, effect.data, -effect.stacks);
-    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)) {
-    const lifecycle = effect.data.lifecycle;
-    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)) {
-      const lifecycle = effect.data.lifecycle;
-      if (lifecycle === "itemTemporary")
-        addItemEffect(entity, itemKey, effect.data, -effect.stacks);
+export function onEntityEffectUpkeep(entity: CombatEntity){
+    for(const effect of Object.values(entity.effects)){
+        const lifecycle = effect.data.lifecycle;
+        if(lifecycle === 'temporary')
+            addEntityEffect(entity, effect.data, -effect.stacks);
+        else if(lifecycle === 'lingering')
+            addEntityEffect(entity, effect.data, effect.stacks >= 0 ? -1 : 1);
     }
-  }
 }
 
-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") {
-      addItemEffect(entity, itemKey, effect.data, -effect.stacks);
+export function onEntityPostureDamage(entity: CombatEntity, damage: number){
+    for(const effect of Object.values(entity.effects)){
+        const lifecycle = effect.data.lifecycle;
+        if(lifecycle === 'posture')
+            addEntityEffect(entity, effect.data, -Math.min(damage, effect.stacks));
     }
-  }
 }
 
-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") {
-      addItemEffect(entity, itemKey, effect.data, -effect.stacks);
+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')
+                addItemEffect(entity, itemKey, effect.data, -effect.stacks);
+        }
+    }
+}
+
+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'){
+            addItemEffect(entity, itemKey, effect.data, -effect.stacks);
+        }
+    }
+}
+
+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'){
+            addItemEffect(entity, itemKey, effect.data, -effect.stacks);
+        }
     }
-  }
 }
 
 export function* getAliveEnemies(state: CombatState) {
-  for (let enemy of state.enemies) {
-    if (enemy.isAlive) {
-      yield enemy;
+    for (let enemy of state.enemies) {
+        if (enemy.isAlive) {
+            yield enemy;
+        }
     }
-  }
 }
 
-export function* getEffectTargets(
-  target: CardEffectTarget | EffectTarget,
-  game: CombatGameContext,
-  targetId?: string,
-) {
-  if (target === "all" || target === "team") {
-    for (const enemy of getAliveEnemies(game.value)) {
-      yield enemy;
+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') {
+        yield game.value.player;
+    } else if(target === 'target'){
+        if(!targetId) return;
+        const entity = getCombatEntity(game.value, targetId);
+        if(entity) yield entity;
+    } else if(target === 'random'){
+        const aliveEnemies = [...getAliveEnemies(game.value)];
+        if(aliveEnemies.length === 0) return;
+        const index = game.rng.nextInt(aliveEnemies.length);
+        yield aliveEnemies[index];
     }
-  } else if (target === "self") {
-    yield game.value.player;
-  } else if (target === "target") {
-    if (!targetId) return;
-    const entity = getCombatEntity(game.value, targetId);
-    if (entity) yield entity;
-  } else if (target === "random") {
-    const aliveEnemies = [...getAliveEnemies(game.value)];
-    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,
-  run: IRunContext,
-): boolean {
-  if (costType === "energy") {
-    return player.energy >= 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 canPlayCard(player: PlayerEntity, costType: CardData['costType'], costCount: number, itemId: string, inventory: GridInventory<GameItemMeta>): 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;
+    }
+    return true;
 }
 
-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 consumed = run.getConsumedUses(itemId);
-    await run.setConsumedUsesAsync(itemId, consumed + costCount);
-  }
+export function payCardCost(player: PlayerEntity, costType: CardData['costType'], costCount: number, itemId: string, inventory: GridInventory<GameItemMeta>): 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;
+        }
+    }
 }

src/samples/slay-the-spire-like/system/combat/prompts.ts

@@ -1,56 +1,43 @@
 import { createPromptDef } from "@/core/game";
-import { CombatGameContext, IRunContext } from "./types";
-import { canPlayCard } from "@/samples/slay-the-spire-like/system/combat/effects";
+import {CombatGameContext} 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]",
-    "选择卡牌并指定目标",
-  ),
+    mainAction: createPromptDef<[string, string?]>(
+        "main-action <cardId:string> [targetId:string]",
+        "选择卡牌并指定目标"
+    ),
 };
 
-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",
-      };
-
-    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,
-        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}"无效`;
-    }
-
-    return {
-      action: "play" as "play",
-      cardId,
-      targetId,
-    };
-  });
-}
+export async function promptMainAction(game: CombatGameContext){
+    return await game.prompt(prompts.mainAction, (cardId, targetId) => {
+        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 card = game.value.player.deck.cards[cardId];
+        const {cardData, itemId} = card;
+        if(!canPlayCard(game.value.player, cardData.costType, cardData.costCount, itemId, game.value.inventory)){
+            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}"无效`;
+        }
+        
+        return {
+            action: 'play' as 'play',
+            cardId,
+            targetId
+        };
+    });
+}

src/samples/slay-the-spire-like/system/combat/triggers.ts

@@ -1,4 +1,4 @@
-import { CombatGameContext, IRunContext } from "./types";
+import { CombatGameContext } from "./types";
 import {
   addEntityEffect,
   addItemEffect,
@@ -51,7 +51,7 @@ type TriggerTypes = {
   onIntentUpdate: { enemyId: string };
 };
 
-export function createTriggers(run: IRunContext) {
+export function createTriggers() {
   const triggers = {
     onCombatStart: createTrigger("onCombatStart"),
     onTurnStart: createTrigger("onTurnStart", async (ctx) => {
@@ -89,7 +89,7 @@ export function createTriggers(run: IRunContext) {
           card.cardData.costType,
           card.cardData.costCount,
           card.itemId,
-          run,
+          draft.inventory,
         );
         moveToRegion(card, regions.hand, regions.discardPile);
         onItemPlay(draft.player, card.itemId);
@@ -176,8 +176,11 @@ export function createTriggers(run: IRunContext) {
       if (ctx.effect.lifecycle.startsWith("item")) {
         if (ctx.cardId) {
           const card = ctx.game.value.player.deck.cards[ctx.cardId];
-          const nearby = run.getNeighborItems(card.itemId);
-          for (const itemId of nearby) {
+          const nearby = getAdjacentItems<GameItemMeta>(
+            ctx.game.value.inventory,
+            card.itemId,
+          );
+          for (const itemId of nearby.keys()) {
             await ctx.game.produceAsync((draft) => {
               addItemEffect(draft.player, itemId, ctx.effect, ctx.stacks);
             });
@@ -266,12 +269,9 @@ export function createTriggers(run: IRunContext) {
   return triggers;
 }
 export type Triggers = ReturnType<typeof createTriggers>;
-export function createStartWith(
-  build: (triggers: Triggers, run: IRunContext) => void,
-  run: IRunContext,
-) {
-  const triggers = createTriggers(run);
-  build(triggers, run);
+export function createStartWith(build: (triggers: Triggers) => void) {
+  const triggers = createTriggers();
+  build(triggers);
   return async function (game: CombatGameContext) {
     await triggers.onCombatStart.execute(game, {});
 
@@ -279,7 +279,7 @@ export function createStartWith(
       while (true) {
         await triggers.onTurnStart.execute(game, { entityKey: "player" });
         while (true) {
-          const action = await promptMainAction(game, run);
+          const action = await promptMainAction(game);
           if (action.action === "end-turn") break;
           if (action.action === "play") {
             await triggers.onCardPlayed.execute(game, action);

src/samples/slay-the-spire-like/system/combat/types.ts

@@ -2,9 +2,10 @@ 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 }>;
 
@@ -45,6 +46,7 @@ export type LootEntry =
 export type CombatState = {
   enemies: EnemyEntity[];
   player: PlayerEntity;
+  inventory: GridInventory<GameItemMeta>;
 
   phase: CombatPhase;
   turnNumber: number;
@@ -53,13 +55,5 @@ 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>;

src/samples/slay-the-spire-like/system/progress/encounter.ts

@@ -94,6 +94,7 @@ export function buildCombatState(runState: RunState): CombatState {
   return {
     enemies,
     player,
+    inventory: runState.inventory,
     phase: "playerTurn",
     turnNumber: 1,
     result: null,

src/samples/slay-the-spire-like/system/progress/types.ts

@@ -1,32 +1,32 @@
-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.).
  */
 export interface EncounterResult {
-  /** Gold earned from the encounter */
-  goldEarned?: number;
-  /** HP lost during the encounter */
-  hpLost?: number;
-  /** HP gained (e.g., from camp heal) */
-  hpGained?: number;
-  /** Item IDs rewarded */
-  itemRewards?: string[];
+    /** Gold earned from the encounter */
+    goldEarned?: number;
+    /** HP lost during the encounter */
+    hpLost?: number;
+    /** HP gained (e.g., from camp heal) */
+    hpGained?: number;
+    /** Item IDs rewarded */
+    itemRewards?: string[];
 }
 
 /**
  * Runtime state of an encounter at a specific node.
  */
 export interface EncounterState {
-  /** The node ID where this encounter is located */
-  nodeId: string;
-  /** Whether the encounter has been resolved */
-  resolved: boolean;
-  /** Optional result data after resolution */
-  result?: EncounterResult;
+    /** The node ID where this encounter is located */
+    nodeId: string;
+    /** Whether the encounter has been resolved */
+    resolved: boolean;
+    /** Optional result data after resolution */
+    result?: EncounterResult;
 }
 
 /**
@@ -34,14 +34,12 @@ export interface EncounterState {
  * Bridges CSV item data with the grid inventory system.
  */
 export interface GameItemMeta {
-  /** Original CSV item data */
-  itemData: ItemData;
-  /** Parsed shape for grid placement */
-  shape: ParsedShape;
-  /** Consumed uses, if card cost type is uses**/
-  consumedUses?: number;
-  /** Effects applied to the item */
-  effects?: Record<string, number>;
+    /** Original CSV item data */
+    itemData: ItemData;
+    /** Parsed shape for grid placement */
+    shape: ParsedShape;
+    /** Consumed uses, if card cost type is uses**/
+    depletion?: number;
 }
 
 /**
@@ -54,12 +52,12 @@ export type GameItem = InventoryItem<GameItemMeta>;
  * Player runtime state.
  */
 export interface PlayerState {
-  /** Maximum HP */
-  maxHp: number;
-  /** Current HP */
-  currentHp: number;
-  /** Current gold */
-  gold: number;
+    /** Maximum HP */
+    maxHp: number;
+    /** Current HP */
+    currentHp: number;
+    /** Current gold */
+    gold: number;
 }
 
 /**
@@ -67,25 +65,23 @@ export interface PlayerState {
  * Designed to be used inside `MutableSignal.produce()` callbacks.
  */
 export interface RunState {
-  /** Generated point crawl map */
-  map: PointCrawlMap;
-  /** Player HP and gold */
-  player: PlayerState;
-  /** Grid inventory with placed items */
-  inventory: GridInventory<GameItemMeta>;
-  /** Current node ID where the player is located */
-  currentNodeId: string;
-  /** State of the encounter at the current node */
-  currentEncounter: EncounterState;
-  /** Set of node IDs whose encounters have been resolved */
-  resolvedNodeIds: Set<string>;
-  /** Internal counter for generating unique item instance IDs */
-  _idCounter: { value: number };
+    /** Generated point crawl map */
+    map: PointCrawlMap;
+    /** Player HP and gold */
+    player: PlayerState;
+    /** Grid inventory with placed items */
+    inventory: GridInventory<GameItemMeta>;
+    /** Current node ID where the player is located */
+    currentNodeId: string;
+    /** State of the encounter at the current node */
+    currentEncounter: EncounterState;
+    /** Set of node IDs whose encounters have been resolved */
+    resolvedNodeIds: Set<string>;
+    /** Internal counter for generating unique item instance IDs */
+    _idCounter: { value: number };
 }
 
 /**
  * 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 };

tests/samples/slay-the-spire-like/combat/effects.test.ts

@@ -17,14 +17,10 @@ import type {
   CombatEntity,
   CombatState,
   EffectTable,
-  IRunContext,
   PlayerEntity,
   EnemyEntity,
 } from "@/samples/slay-the-spire-like/system/combat/types";
-import type {
-  EffectData,
-  ItemData,
-} from "@/samples/slay-the-spire-like/system/types";
+import type { EffectData } from "@/samples/slay-the-spire-like/system/types";
 import type {
   CellKey,
   GridInventory,
@@ -34,31 +30,6 @@ 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"],
@@ -94,7 +65,9 @@ function createItem(
     id: itemId,
     shape: { id: "1x1", cells: [{ x: 0, y: 0 }] } as unknown as ParsedShape,
     transform: {
-      offset: { x: 0, y: 0 },
+      x: 0,
+      y: 0,
+      rotation: 0,
       flipX: false,
       flipY: false,
     } as unknown as Transform2D,
@@ -109,7 +82,7 @@ function createItem(
         description: "",
       },
       shape: { id: "1x1", cells: [{ x: 0, y: 0 }] } as unknown as ParsedShape,
-      consumedUses: costType === "uses" ? depletion : undefined,
+      depletion: costType === "uses" ? depletion : undefined,
     },
   };
 }
@@ -121,14 +94,13 @@ function createInventory(
   const occupied = new Set<CellKey>();
   for (const item of items) {
     map.set(item.id, item);
-    occupied.add(`${item.transform.offset.x},${item.transform.offset.y}`);
+    occupied.add(`${item.transform.x},${item.transform.y}`);
   }
   return { width: 6, height: 4, items: map, occupiedCells: occupied };
 }
 
 function createCombatEntity(hp = 10, maxHp = 10): CombatEntity {
   return {
-    id: "",
     effects: {},
     hp,
     maxHp,
@@ -158,9 +130,9 @@ function createEnemyEntity(id: string, hp = 10, maxHp = 10): EnemyEntity {
   return {
     ...createCombatEntity(hp, maxHp),
     id,
-    enemy: { id, name: id, description: "", intents: null! },
+    enemy: { id, name: id, description: "" },
     intents: {},
-    currentIntent: null!,
+    currentIntentId: "",
   };
 }
 
@@ -171,6 +143,12 @@ function createCombatState(
   return {
     player: createPlayerEntity(playerHp),
     enemies,
+    inventory: {
+      width: 6,
+      height: 4,
+      items: new Map(),
+      occupiedCells: new Set(),
+    },
     phase: "playerTurn",
     turnNumber: 1,
     result: null,
@@ -539,9 +517,8 @@ describe("combat/effects", () => {
       const player = createPlayerEntity();
       player.energy = 3;
       const inventory = createInventory([]);
-      const run = createRunContext(inventory.items);
 
-      const result = canPlayCard(player, "energy", 2, "any", run);
+      const result = canPlayCard(player, "energy", 2, "any", inventory);
 
       expect(result).toBe(true);
     });
@@ -550,9 +527,8 @@ describe("combat/effects", () => {
       const player = createPlayerEntity();
       player.energy = 1;
       const inventory = createInventory([]);
-      const run = createRunContext(inventory.items);
 
-      const result = canPlayCard(player, "energy", 2, "any", run);
+      const result = canPlayCard(player, "energy", 2, "any", inventory);
 
       expect(result).toBe(false);
     });
@@ -561,9 +537,8 @@ 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", run);
+      const result = canPlayCard(player, "uses", 3, "potion-1", inventory);
 
       expect(result).toBe(true);
     });
@@ -572,9 +547,8 @@ 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", run);
+      const result = canPlayCard(player, "uses", 3, "potion-1", inventory);
 
       expect(result).toBe(false);
     });
@@ -582,9 +556,8 @@ 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", run);
+      const result = canPlayCard(player, "uses", 1, "missing", inventory);
 
       expect(result).toBe(false);
     });
@@ -593,56 +566,51 @@ describe("combat/effects", () => {
       const player = createPlayerEntity();
       player.energy = 0;
       const inventory = createInventory([]);
-      const run = createRunContext(inventory.items);
 
-      const result = canPlayCard(player, "none", 0, "any", run);
+      const result = canPlayCard(player, "none", 0, "any", inventory);
 
       expect(result).toBe(true);
     });
   });
 
   describe("payCardCost", () => {
-    it("should deduct energy for energy cost card", async () => {
+    it("should deduct energy for energy cost card", () => {
       const player = createPlayerEntity();
       player.energy = 3;
       const inventory = createInventory([]);
-      const run = createRunContext(inventory.items);
 
-      await payCardCost(player, "energy", 2, "any", run);
+      payCardCost(player, "energy", 2, "any", inventory);
 
       expect(player.energy).toBe(1);
     });
 
-    it("should increment depletion for uses cost card", async () => {
+    it("should increment depletion for uses cost card", () => {
       const player = createPlayerEntity();
       const item = createItem("potion-1", "potion-card", "uses", 3, 1);
       const inventory = createInventory([item]);
-      const run = createRunContext(inventory.items);
 
-      await payCardCost(player, "uses", 3, "potion-1", run);
+      payCardCost(player, "uses", 3, "potion-1", inventory);
 
-      expect(item.meta?.consumedUses).toBe(4);
+      expect(item.meta?.depletion).toBe(4);
     });
 
-    it("should do nothing for none cost card", async () => {
+    it("should do nothing for none cost card", () => {
       const player = createPlayerEntity();
       player.energy = 3;
       const inventory = createInventory([]);
-      const run = createRunContext(inventory.items);
 
-      await payCardCost(player, "none", 0, "any", run);
+      payCardCost(player, "none", 0, "any", inventory);
 
       expect(player.energy).toBe(3);
     });
 
-    it("should handle missing item gracefully for uses cost", async () => {
+    it("should handle missing item gracefully for uses cost", () => {
       const player = createPlayerEntity();
       const inventory = createInventory([]);
-      const run = createRunContext(inventory.items);
 
-      await expect(
-        payCardCost(player, "uses", 1, "missing", run),
-      ).resolves.not.toThrow();
+      expect(() =>
+        payCardCost(player, "uses", 1, "missing", inventory),
+      ).not.toThrow();
     });
   });
 });

tests/samples/slay-the-spire-like/combat/triggers.test.ts

@@ -14,7 +14,6 @@ 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 {
@@ -139,6 +138,7 @@ function createCombatState(overrides: Partial<CombatState> = {}): CombatState {
       itemEffects: {},
     },
     enemies: [],
+    inventory: createInventory([]),
     phase: "playerTurn",
     turnNumber: 1,
     result: null,
@@ -155,18 +155,8 @@ function createTestContext(state?: CombatState): IGameContext<CombatState> {
 }
 
 function getTriggers(): Triggers {
-  const run: IRunContext = {
-    getConsumedUses() {
-      return 0;
-    },
-    getItemData() {
-      return null;
-    },
-    *getNeighborItems() {},
-    async setConsumedUsesAsync() {},
-  };
-  const triggers = createTriggers(run);
-  addTriggers(triggers, run);
+  const triggers = createTriggers();
+  addTriggers(triggers);
   return triggers;
 }
 

tsconfig.json

@@ -5,7 +5,6 @@
     "lib": ["ES2020"],
     "moduleResolution": "bundler",
     "strict": true,
-    "types": ["node"],
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
@@ -19,6 +18,6 @@
       "@/*": ["src/*"],
     },
   },
-  "include": ["src/**/*", "tests/**/*", "*.config.ts"],
+  "include": ["src/**/*", "tests/**/*"],
   "exclude": ["node_modules", "dist"],
 }

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,
     };
   },
 });