Refactor the inventory

src/common/rpg/components/inventory.ts

@@ -1,6 +1,8 @@
-import type { InventoryOptions, InventorySlotInput, SlotId } from "../types";
+import type { InventorySlotInput, RPGVariables, SlotId } from "../types";
 import { action } from "../utils/decorators";
-import { Component } from "../core/world";
+import { Component, type EvalContext } from "../core/world";
+import { Stackable, Usable } from "./item";
+import { resolveVariables } from "../utils/variables";
 
 interface SlotEntry {
     readonly slotId: SlotId;
@@ -16,9 +18,8 @@ interface SlotUpdateArgs {
 
 export class Inventory extends Component {
     private readonly slots: Map<SlotId, SlotEntry>;
-    private readonly maxAmountPerItem: Record<string, number>;
 
-    constructor(slotDefs: Array<InventorySlotInput>, options?: InventoryOptions) {
+    constructor(slotDefs: Array<InventorySlotInput>) {
         super();
         this.slots = new Map(
             slotDefs.map(def => {
@@ -27,17 +28,15 @@ export class Inventory extends Component {
                 return [slotId, { slotId, limit, state: null }];
             })
         );
-        this.maxAmountPerItem = options?.maxAmountPerItem ?? {};
     }
 
-    // Max amount of itemId allowed in a single slot (min of slot.limit and maxAmountPerItem cap)
     private slotCapFor(slot: SlotEntry, itemId: string): number {
         const limitCap = slot.limit ?? Infinity;
-        const itemCap = this.maxAmountPerItem[itemId] ?? Infinity;
+        const stackable = this.entity.world.getEntity(itemId)?.get(Stackable);
-        return Math.min(limitCap, itemCap);
+        const stackCap = stackable ? stackable.maxStack : 1;
+        return Math.min(limitCap, stackCap);
     }
 
-    // Remaining space in slot for itemId
     private slotRoomFor(slot: SlotEntry, itemId: string): number {
         if (slot.state !== null && slot.state.itemId !== itemId) return 0;
         return this.slotCapFor(slot, itemId) - (slot.state?.amount ?? 0);
@@ -48,6 +47,11 @@ export class Inventory extends Component {
         if (amount < 0) return false;
         if (amount === 0) return true;
 
+        if (!this.entity.world.getEntity(itemId)) {
+            console.warn(`[Inventory] add: item entity '${itemId}' not found`);
+            return false;
+        }
+
         if (slotId !== undefined) {
             const slot = this.slots.get(slotId);
             if (!slot) return false;
@@ -134,6 +138,36 @@ export class Inventory extends Component {
         return false;
     }
 
+    @action
+    async use(itemId?: string, ctx?: EvalContext): Promise<boolean> {
+        if (!itemId) return false;
+
+        if (this.getAmount(itemId) === 0) {
+            console.warn(`[Inventory] use: item '${itemId}' not in inventory`);
+            return false;
+        }
+
+        const itemEntity = this.entity.world.getEntity(itemId);
+        if (!itemEntity) {
+            console.warn(`[Inventory] use: item entity '${itemId}' not found`);
+            return false;
+        }
+
+        const usable = itemEntity.get(Usable);
+        if (!usable) {
+            console.warn(`[Inventory] use: item '${itemId}' has no Usable component`);
+            return false;
+        }
+
+        if (usable.consumeOnUse) {
+            this.remove({ itemId, amount: 1 });
+        }
+
+        const resolvedCtx = ctx ?? { self: this.entity, world: this.entity.world };
+        await usable.use(resolvedCtx);
+        return true;
+    }
+
     getAmount(itemId: string, slotId?: SlotId): number {
         if (slotId !== undefined) {
             const slot = this.slots.get(slotId);
@@ -156,7 +190,17 @@ export class Inventory extends Component {
         return result;
     }
 
-    override getVariables(): Record<string, number> {
+    override getVariables(): RPGVariables {
-        return Object.fromEntries(this.getItems());
+        const result: RPGVariables = {};
+        for (const [itemId, amount] of this.getItems()) {
+            result[itemId] = amount;
+            const itemEntity = this.entity.world.getEntity(itemId);
+            if (itemEntity) {
+                for (const [key, value] of Object.entries(resolveVariables(itemEntity))) {
+                    result[`${itemId}.${key}`] = value;
+                }
+            }
+        }
+        return result;
     }
 }

src/common/rpg/components/item.ts

@@ -0,0 +1,56 @@
+import { Component, type EvalContext, type World } from "../core/world";
+import type { RPGAction } from "../types";
+import { action, variable } from "../utils/decorators";
+import { executeAction } from "../utils/variables";
+
+export class Item extends Component {
+    constructor(
+        readonly name: string,
+        readonly description: string = '',
+    ) {
+        super();
+    }
+}
+
+export class Stackable extends Component {
+    @variable readonly maxStack: number;
+    constructor(maxStack: number) {
+        super();
+        this.maxStack = maxStack;
+    }
+}
+
+export class Usable extends Component {
+    @variable readonly consumeOnUse: boolean;
+    constructor(private readonly actions: RPGAction[], consumeOnUse = true) {
+        super();
+        this.consumeOnUse = consumeOnUse;
+    }
+
+    @action
+    async use(arg?: EvalContext, ctx?: EvalContext): Promise<void> {
+        ctx = arg ?? ctx ?? this.context;
+        if (!ctx) return;
+        for (const action of this.actions) {
+            await executeAction(action, ctx);
+        }
+    }
+}
+
+export namespace Items {
+    export interface RegisterOptions {
+        maxStack?: number;
+        description?: string;
+        usable?: { actions: RPGAction[]; consumeOnUse?: boolean };
+    }
+
+    export function register(world: World, id: string, name: string, options?: RegisterOptions) {
+        const entity = world.createEntity(id);
+        entity.add('item', new Item(name, options?.description));
+        if (options?.maxStack !== undefined)
+            entity.add('stackable', new Stackable(options.maxStack));
+        if (options?.usable)
+            entity.add('usable', new Usable(options.usable.actions, options.usable.consumeOnUse));
+        return entity;
+    }
+}

src/common/rpg/core/world.ts

@@ -57,6 +57,10 @@ export abstract class Component {
         }
         return actions;
     }
+
+    get context(): EvalContext {
+        return { self: this.entity, world: this.entity.world };
+    }
 }
 
 export abstract class System {
@@ -70,7 +74,7 @@ export class Entity {
 
     constructor(
         readonly id: string,
-        private readonly world: World,
+        readonly world: World,
     ) { }
 
     add<T extends Component>(key: string, component: T): T {
@@ -277,6 +281,10 @@ export class World {
         map.get(key)!.add(handler);
         return () => map.get(key)?.delete(handler);
     }
+
+    *[Symbol.iterator]() {
+        yield* this.#entities.values();
+    }
 }
 
 export function isEvalContext(v: unknown): v is EvalContext {

src/common/rpg/types.ts

@@ -12,6 +12,7 @@ export type RPGVariables = Record<string, string | number | boolean | undefined>
 export type RPGActions = Record<string, (arg?: any) => unknown>;
 export type RPGAction = Static<typeof RPGActionScheme>;
 
+
 // ── Dialog ────────────────────────────────────────────────────────────────────
 
 const DialogChoiceScheme = Type.Object({
@@ -85,6 +86,4 @@ export interface InventorySlotDefinition {
 
 export type InventorySlotInput = SlotId | InventorySlotDefinition;
 
-export interface InventoryOptions {
+
-    maxAmountPerItem?: Record<string, number>;
-}

src/common/rpg/utils/decorators.ts

@@ -3,13 +3,15 @@ import type { RPGVariables } from "../types";
 export const ACTION_KEYS = Symbol('rpg.actions');
 export const VARIABLE_KEYS = Symbol('rpg.variables');
 
-export function action<T extends (arg?: any) => unknown>(
+export function action<T extends (arg?: any, ctx?: any) => unknown>(
     target: T,
     context: ClassMethodDecoratorContext<unknown, T>
 ): T {
     const prev = context.metadata[ACTION_KEYS] as Set<string | symbol> | undefined;
     context.metadata[ACTION_KEYS] = new Set(prev).add(context.name);
-    return target;
+    return function(this: any, arg?: any, ctx?: any) {
+        return target.call(this, arg, ctx ?? this.context);
+    } as unknown as T;
 }
 
 type VariableContext<T extends RPGVariables[string]> =

src/common/rpg/utils/variables.ts

@@ -1,9 +1,21 @@
 import type { RPGAction, RPGActions, RPGVariables } from "../types";
+import { World } from "../core/world";
 import type { EvalContext, Entity } from "../core/world";
 
-export function resolveVariables(entity: Entity): RPGVariables {
+export function resolveVariables(entity: Entity): RPGVariables;
+export function resolveVariables(world: World): RPGVariables;
+export function resolveVariables(entityOrWorld: Entity | World): RPGVariables {
+    if (entityOrWorld instanceof World) {
+        const result: RPGVariables = {};
+        for (const entity of entityOrWorld) {
+            for (const [key, value] of Object.entries(resolveVariables(entity))) {
+                result[`${entity.id}.${key}`] = value;
+            }
+        }
+        return result;
+    }
     const result: RPGVariables = {};
-    for (const [key, component] of entity) {
+    for (const [key, component] of entityOrWorld) {
         for (const [varKey, value] of Object.entries(component.getVariables())) {
             if (value != null) {
                 if (varKey && varKey !== '.') {

src/games/playground/index.tsx

@@ -4,12 +4,16 @@ import { Health } from "@common/rpg/components/stat";
 import { Variables } from "@common/rpg/components/variables";
 import { QuestLog } from "@common/rpg/components/questLog";
 import { QuestSystem } from "@common/rpg/systems/questSystem";
+import { Items } from "@common/rpg/components/item";
 import { resolveVariables, resolveActions } from "@common/rpg/utils/variables";
 
 export default async function main() {
     const world = new World();
     world.addSystem(new QuestSystem());
 
+    Items.register(world, 'helmet', 'Iron Helmet');
+    Items.register(world, 'boots', 'Leather Boots', { maxStack: 2 });
+
     const player = world.createEntity('player');
     player.add('inventory', new Inventory(['head', 'legs']));
     player.add('health', new Health(100, 100));
@@ -24,7 +28,7 @@ export default async function main() {
         stages: [],
     });
 
-    console.log(resolveVariables(player));
+    console.log(resolveVariables(world));
 
     const inventory = player.get(Inventory)!;
     inventory.add({ itemId: 'helmet', amount: 1, slotId: 'head' });
@@ -33,5 +37,5 @@ export default async function main() {
     actions['inventory.add']({ itemId: 'boots', amount: 2 });
 
     console.log(actions);
-    console.log(resolveVariables(player));
+    console.log(resolveVariables(world));
 }