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);
+    const adjacent = getAdjacentItems<GameItemMeta>(
-    for (const adjItemId of adjacent) {
+      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) {
+export function addDesertTriggers(triggers: Triggers) {
     addInstantEffectTriggers(triggers);
     addDamageTriggers(triggers);
     addTurnStartTriggers(triggers);
-  addCardEventTriggers(triggers, run);
+    addCardEventTriggers(triggers);
 }

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

@@ -1,95 +1,78 @@
-import {
+import {CombatEntity, CombatGameContext, CombatState, EffectTable, PlayerEntity} from "./types";
-  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(
+export function addEffect(effects: EffectTable, effect: EffectData, stacks: number){
-  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];
+    if(current.stacks === 0 && effects[effect.id])
-  else 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(
+export function addEntityEffect(entity: CombatEntity, effect: EffectData, stacks: number){
-  entity: CombatEntity,
-  effect: EffectData,
-  stacks: number,
-) {
     addEffect(entity.effects, effect, stacks);
 }
 
-export function addItemEffect(
+export function addItemEffect(entity: PlayerEntity, itemKey: string, effect: EffectData, stacks: number){
-  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) {
+export function onEntityEffectUpkeep(entity: CombatEntity){
-  for (const effect of Object.values(entity.effects)) {
+    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) {
+export function onEntityPostureDamage(entity: CombatEntity, damage: number){
-  for (const effect of Object.values(entity.effects)) {
+    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) {
+export function onPlayerItemEffectUpkeep(entity: PlayerEntity){
-  for (const [itemKey, itemEffects] of Object.entries(entity.itemEffects)) {
+    for(const [itemKey, itemEffects] of Object.entries(entity.itemEffects)){
-    for (const effect of Object.values(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;
+    if(!effects)return;
-  for (const effect of Object.values(effects)) {
+    for(const effect of Object.values(effects)){
-    if (effect.data.lifecycle === "itemUntilPlay") {
+        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;
+    if(!effects)return;
-  for (const effect of Object.values(effects)) {
+    for(const effect of Object.values(effects)){
-    if (effect.data.lifecycle === "itemUntilDiscard") {
+        if(effect.data.lifecycle === 'itemUntilDiscard'){
             addItemEffect(entity, itemKey, effect.data, -effect.stacks);
         }
     }
@@ -103,66 +86,49 @@ export function* getAliveEnemies(state: CombatState) {
     }
 }
 
-export function* getEffectTargets(
+export function* getEffectTargets(target: CardEffectTarget | EffectTarget, game: CombatGameContext, targetId?: string){
-  target: CardEffectTarget | EffectTarget,
+    if(target === 'all' || target === 'team'){
-  game: CombatGameContext,
+        for(const enemy of getAliveEnemies(game.value)){
-  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") {
+    } else if(target === 'target'){
-    if (!targetId) return;
+        if(!targetId) return;
         const entity = getCombatEntity(game.value, targetId);
-    if (entity) yield entity;
+        if(entity) yield entity;
-  } else if (target === "random") {
+    } 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) {
+export function getCombatEntity(state: CombatState, entityKey: string){
-  return entityKey === "player"
+    return entityKey === 'player' ? state.player : state.enemies.find(e => e.id === entityKey);
-    ? state.player
-    : state.enemies.find((e) => e.id === entityKey);
 }
 
-export function canPlayCard(
+export function canPlayCard(player: PlayerEntity, costType: CardData['costType'], costCount: number, itemId: string, inventory: GridInventory<GameItemMeta>): boolean {
-  player: PlayerEntity,
+    if (costType === 'energy') {
-  costType: CardData["costType"],
-  costCount: number,
-  itemId: string,
-  run: IRunContext,
-): boolean {
-  if (costType === "energy") {
         return player.energy >= costCount;
     }
-  if (costType === "uses") {
+    if (costType === 'uses') {
-    const item = run.getItemData(itemId);
+        const item = inventory.items.get(itemId);
-    if (!item) return false;
+        if (!item || !item.meta) return false;
-    const maxUses = item?.card.costType === "uses" ? item.card.costCount : 0;
+        const depletion = item.meta.depletion ?? 0;
-    const consumed = run.getConsumedUses(itemId);
+        return depletion < costCount;
-    return consumed < maxUses;
     }
     return true;
 }
 
-export async function payCardCost(
+export function payCardCost(player: PlayerEntity, costType: CardData['costType'], costCount: number, itemId: string, inventory: GridInventory<GameItemMeta>): void {
-  player: PlayerEntity,
+    if (costType === 'energy') {
-  costType: CardData["costType"],
-  costCount: number,
-  itemId: string,
-  run: IRunContext,
-): Promise<void> {
-  if (costType === "energy") {
         player.energy -= costCount;
-  } else if (costType === "uses") {
+    } else if (costType === 'uses') {
-    const consumed = run.getConsumedUses(itemId);
+        const item = inventory.items.get(itemId);
-    await run.setConsumedUsesAsync(itemId, consumed + costCount);
+        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 {CombatGameContext} from "./types";
-import { canPlayCard } from "@/samples/slay-the-spire-like/system/combat/effects";
+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(
+export async function promptMainAction(game: CombatGameContext){
-  game: CombatGameContext,
-  run: IRunContext,
-) {
     return await game.prompt(prompts.mainAction, (cardId, targetId) => {
-    if (cardId === "end-turn")
+        if(cardId === 'end-turn') return {
-      return {
+            action: 'end-turn' as 'end-turn'
-        action: "end-turn" as "end-turn",
         };
         
-    const exists =
+        const exists = game.value.player.deck.regions.hand.childIds.includes(cardId);
-      game.value.player.deck.regions.hand.childIds.includes(cardId);
+        if(!exists) throw `卡牌"${cardId}"不在手牌中`;
-    if (!exists) throw `卡牌"${cardId}"不在手牌中`;
         
         const card = game.value.player.deck.cards[cardId];
-    const { cardData, itemId } = card;
+        const {cardData, itemId} = card;
-    if (
+        if(!canPlayCard(game.value.player, cardData.costType, cardData.costCount, itemId, game.value.inventory)){
-      !canPlayCard(
-        game.value.player,
-        cardData.costType,
-        cardData.costCount,
-        itemId,
-        run,
-      )
-    ) {
             throw `无法支付卡牌"${cardId}"的费用`;
         }
         
-    const { targetType } = cardData;
+        const {targetType} = cardData;
-    if (targetType === "single") {
+        if(targetType === 'single'){
-      if (!targetId) throw `请指定目标`;
+            if(!targetId) throw `请指定目标`;
-      const target = game.value.enemies.find((e) => e.id === targetId);
+            const target = game.value.enemies.find(e => e.id === targetId);
-      if (!target) throw `目标"${targetId}"不存在`;
+            if(!target) throw `目标"${targetId}"不存在`;
-      if (!target.isAlive) throw `目标"${targetId}"已死亡`;
+            if(!target.isAlive) throw `目标"${targetId}"已死亡`;
-    } else if (targetType === "none") {
+        }else if(targetType === 'none'){
-      if (targetId) throw `目标"${targetId}"无效`;
+            if(targetId) throw `目标"${targetId}"无效`;
         }
         
         return {
-      action: "play" as "play",
+            action: 'play' as 'play',
             cardId,
-      targetId,
+            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);
+          const nearby = getAdjacentItems<GameItemMeta>(
-          for (const itemId of nearby) {
+            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(
+export function createStartWith(build: (triggers: Triggers) => void) {
-  build: (triggers: Triggers, run: IRunContext) => void,
+  const triggers = createTriggers();
-  run: IRunContext,
+  build(triggers);
-) {
-  const triggers = createTriggers(run);
-  build(triggers, run);
   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,7 +1,7 @@
-import type { PointCrawlMap } from "../map/types";
+import type { PointCrawlMap } from '../map/types';
-import type { GridInventory, InventoryItem } from "../grid-inventory/types";
+import type { GridInventory, InventoryItem } from '../grid-inventory/types';
-import type { ParsedShape } from "../utils/parse-shape";
+import type { ParsedShape } from '../utils/parse-shape';
-import { ItemData } from "@/samples/slay-the-spire-like/system/types";
+import {ItemData} from "@/samples/slay-the-spire-like/system/types";
 
 /**
  * Result of an encounter (combat, event, etc.).
@@ -39,9 +39,7 @@ export interface GameItemMeta {
     /** Parsed shape for grid placement */
     shape: ParsedShape;
     /** Consumed uses, if card cost type is uses**/
-  consumedUses?: number;
+    depletion?: number;
-  /** Effects applied to the item */
-  effects?: Record<string, number>;
 }
 
 /**
@@ -86,6 +84,4 @@ export interface RunState {
 /**
  * Result of a mutation operation on the run state.
  */
-export type RunMutationResult =
+export type RunMutationResult = { success: true } | { success: false; reason: string };
-  | { 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 {
+import type { EffectData } from "@/samples/slay-the-spire-like/system/types";
-  EffectData,
-  ItemData,
-} 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(
+      expect(() =>
-        payCardCost(player, "uses", 1, "missing", run),
+        payCardCost(player, "uses", 1, "missing", inventory),
-      ).resolves.not.toThrow();
+      ).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 = {
+  const triggers = createTriggers();
-    getConsumedUses() {
+  addTriggers(triggers);
-      return 0;
-    },
-    getItemData() {
-      return null;
-    },
-    *getNeighborItems() {},
-    async setConsumedUsesAsync() {},
-  };
-  const triggers = createTriggers(run);
-  addTriggers(triggers, run);
   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 { defineConfig } from 'tsup';
-import { fileURLToPath } from "url";
+import { fileURLToPath } from 'url';
-import { csvLoader } from "inline-schema/csv-loader/rollup";
+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"],
+  entry: ['src/index.ts'],
-  format: ["esm"],
+  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,
     };
   },
 });