@rpgm-tools/neo-angband-core 0.10.0

package/src/store/bind.ts

@@ -0,0 +1,145 @@
+/**
+ * Bind compiled store records (packages/content/pack/store.json) into the
+ * runtime store model, ported from the parsing side of reference/src/store.c
+ * (init_parse_stores / store_parser_new / store_owner_parser_new) and
+ * store_at (Angband 4.2.6).
+ *
+ * This is the data-binding slice of the store subsystem. It resolves each
+ * store's entrance feature, owners, always/normal stocking tables (tval + sval
+ * names -> object kinds), and buy list. The behavioural half of store.c
+ * (pricing, stock maintenance, buying/selling, town placement) is deferred to
+ * later increments; see store/types.ts.
+ */
+
+import { FEAT, OF } from "../generated/index.js";
+import { tvalFindIdx } from "../obj/bind.js";
+import type { ObjRegistry } from "../obj/bind.js";
+import type { ObjectKind } from "../obj/types.js";
+import type {
+  BoundStore,
+  ObjectBuy,
+  StoreBuyJson,
+  StoreItemJson,
+  StoreOwner,
+  StoreRecordJson,
+} from "./types.js";
+
+/** Resolve a FEAT_* name (the store record's `store` key) to its index. */
+function featByName(name: string): number {
+  const feat = (FEAT as Record<string, number>)[name];
+  if (feat === undefined) {
+    throw new Error(`store: unknown entrance feature ${name}`);
+  }
+  return feat;
+}
+
+/** Resolve an OF_* flag name to its index (for flag-qualified buy rules). */
+function flagByName(name: string): number {
+  const flag = (OF as Record<string, number>)[name];
+  if (flag === undefined) {
+    throw new Error(`store: unknown buy flag ${name}`);
+  }
+  return flag;
+}
+
+/** Resolve a `{tval, sval}` table entry (sval required) to its object kind. */
+function resolveKind(item: StoreItemJson, reg: ObjRegistry): ObjectKind {
+  const tval = tvalFindIdx(item.tval);
+  if (tval < 0) throw new Error(`store: unknown tval ${item.tval}`);
+  if (item.sval === undefined) {
+    throw new Error(`store: table entry ${item.tval} needs an sval`);
+  }
+  const sval = reg.lookupSval(tval, item.sval);
+  if (sval < 0) {
+    throw new Error(`store: unknown sval ${item.tval}:${item.sval}`);
+  }
+  const kind = reg.lookupKind(tval, sval);
+  if (!kind) throw new Error(`store: no kind ${item.tval}:${item.sval}`);
+  return kind;
+}
+
+/** Resolve one buy entry (bare tval string, or `{tval, flag}` object). */
+function resolveBuy(entry: StoreBuyJson): ObjectBuy {
+  if (typeof entry === "string") {
+    const tval = tvalFindIdx(entry);
+    if (tval < 0) throw new Error(`store: unknown buy tval ${entry}`);
+    return { tval, flag: 0 };
+  }
+  const tval = tvalFindIdx(entry.tval);
+  if (tval < 0) throw new Error(`store: unknown buy tval ${entry.tval}`);
+  return { tval, flag: entry.flag ? flagByName(entry.flag) : 0 };
+}
+
+/**
+ * Bind a single store record. This is the semantic half of parse_store
+ * (store.c:132) and its sibling directive handlers (parse_slots, parse_turnover,
+ * parse_normal, parse_always, parse_buy): the grammar itself lives in
+ * packages/content/src/specs/misc.ts storeSpec, and the record arrives here
+ * already tokenised.
+ *
+ * Two upstream parse-time behaviours are deliberately absent, both recorded in
+ * parity/phase3-2026-07-25/findings/W1-CITED.md: the TF_SHOP check on the
+ * entrance feature (store.c:135-137, a validation on trusted data), and
+ * ordering the store array by the feature's shopnum (L142). Stores here keep
+ * store.txt order and are looked up by feature (store_at -> byFeat), which
+ * matches shopnum order for the shipped data.
+ */
+export function bindStore(rec: StoreRecordJson, reg: ObjRegistry): BoundStore {
+  const owners: StoreOwner[] = rec.owner.map((o, index) => ({
+    index,
+    name: o.name,
+    maxCost: o.purse,
+  }));
+
+  /* `always:` entries with an sval resolve to a specific kind; entries with
+   * no sval are the bookseller's town-book lines (expansion deferred). */
+  const alwaysTable: ObjectKind[] = [];
+  const alwaysBookTvals: number[] = [];
+  for (const it of rec.always ?? []) {
+    if (it.sval === undefined) {
+      const tval = tvalFindIdx(it.tval);
+      if (tval < 0) throw new Error(`store: unknown always tval ${it.tval}`);
+      alwaysBookTvals.push(tval);
+    } else {
+      alwaysTable.push(resolveKind(it, reg));
+    }
+  }
+  const normalTable = (rec.normal ?? []).map((it) => resolveKind(it, reg));
+  const buy = rec.buy ? rec.buy.map(resolveBuy) : null;
+
+  return {
+    feat: featByName(rec.store),
+    featName: rec.store,
+    owners,
+    alwaysTable,
+    alwaysBookTvals,
+    normalTable,
+    buy,
+    turnover: rec.turnover ?? 0,
+    normalStockMin: rec.slots?.min ?? 0,
+    normalStockMax: rec.slots?.max ?? 0,
+  };
+}
+
+/**
+ * The bound set of stores, indexable by entrance feature. Mirrors the global
+ * `stores` array; `byFeat` is the store_at lookup (given a town grid's feature,
+ * which store is it?).
+ */
+export class StoreRegistry {
+  readonly stores: BoundStore[];
+
+  constructor(records: StoreRecordJson[], reg: ObjRegistry) {
+    this.stores = records.map((rec) => bindStore(rec, reg));
+  }
+
+  /** store_at: the store whose entrance feature matches, or null. */
+  byFeat(feat: number): BoundStore | null {
+    return this.stores.find((s) => s.feat === feat) ?? null;
+  }
+
+  /** The store with the given FEAT_* name, or null. */
+  byName(featName: string): BoundStore | null {
+    return this.stores.find((s) => s.featName === featName) ?? null;
+  }
+}

package/src/store/price.ts

@@ -0,0 +1,97 @@
+/**
+ * Store pricing, ported from reference/src/store.c (Angband 4.2.6): price_item.
+ *
+ * This is the economics layer on top of object valuation (obj/value.ts): the
+ * buy-versus-sell asymmetry, the black-market surcharge (applied twice on the
+ * sell side), the birth_no_selling kill-switch, and the owner's purse cap.
+ */
+
+import { FEAT } from "../generated/index.js";
+import { tvalCanHaveCharges } from "../obj/object.js";
+import type { GameObject } from "../obj/object.js";
+import type { ObjRegistry } from "../obj/bind.js";
+import { objectValue, objectValueReal } from "../obj/value.js";
+
+/**
+ * price_item (store.c L579): the price of `obj` (qty one, or a wand/staff
+ * stack) in a store. A shop never loses money on a trade.
+ *
+ * @param store the entrance-feature carrier (BoundStore); only .feat is read,
+ *   to detect the black market.
+ * @param owner the current proprietor (StoreOwner); .maxCost is the purse cap.
+ * @param storeBuying true when the shop is buying (player selling), false when
+ *   the shop is selling (player buying).
+ * @param aware object_flavor_is_aware(obj), for object_value's dispatch.
+ * @param noSelling OPT(player, birth_no_selling): when set, the shop pays 0.
+ */
+export function priceItem(
+  reg: ObjRegistry,
+  store: { feat: number },
+  owner: { maxCost: number },
+  obj: GameObject,
+  storeBuying: boolean,
+  qty: number,
+  aware: boolean,
+  noSelling: boolean,
+): number {
+  let adjust = 100;
+  let price: number;
+
+  /* Get the value of the stack of wands, or a single item. */
+  if (tvalCanHaveCharges(obj.tval)) {
+    price = storeBuying
+      ? Math.min(objectValueReal(reg, obj, qty), objectValue(reg, obj, qty, aware))
+      : Math.max(objectValueReal(reg, obj, qty), objectValue(reg, obj, qty, aware));
+  } else {
+    price = storeBuying
+      ? Math.min(objectValueReal(reg, obj, 1), objectValue(reg, obj, 1, aware))
+      : Math.max(objectValueReal(reg, obj, 1), objectValue(reg, obj, 1, aware));
+  }
+
+  /* Worthless items. */
+  if (price <= 0) {
+    return storeBuying ? 0 : qty;
+  }
+
+  /* The black market is always a worse deal. */
+  if (store.feat === FEAT.STORE_BLACK) adjust = 150;
+
+  if (storeBuying) {
+    /* Set the factor. */
+    adjust = 100 + (100 - adjust);
+    if (adjust > 100) adjust = 100;
+
+    /* Shops now pay 2/3 of true value. */
+    price = Math.trunc((price * 2) / 3);
+
+    /* Black market sucks. */
+    if (store.feat === FEAT.STORE_BLACK) price = Math.trunc(price / 2);
+
+    /* Check for no_selling option. */
+    if (noSelling) return 0;
+  } else {
+    /* Re-evaluate if we're selling. */
+    price = tvalCanHaveCharges(obj.tval)
+      ? objectValueReal(reg, obj, qty)
+      : objectValueReal(reg, obj, 1);
+
+    /* Black market sucks. */
+    if (store.feat === FEAT.STORE_BLACK) price = price * 2;
+  }
+
+  /* Compute the final price (with rounding). */
+  price = Math.trunc((price * adjust + 50) / 100);
+
+  /* Convert price to total price for non-wands. */
+  if (!tvalCanHaveCharges(obj.tval)) price *= qty;
+
+  /* Limit the price to the purse limit. */
+  if (storeBuying && price > owner.maxCost * qty) {
+    price = owner.maxCost * qty;
+  }
+
+  /* Never become "free". */
+  if (price <= 0) return qty;
+
+  return price;
+}

package/src/store/store-cmd.ts

@@ -0,0 +1,73 @@
+/**
+ * The store COMMANDS' entry guards, ported from reference/src/store.c's
+ * do_cmd_buy (L1650), do_cmd_retrieve (L1783), do_cmd_sell (L1869) and
+ * do_cmd_stash (L2009), plus enter_store (ui-store.c L1255) - Angband 4.2.6.
+ *
+ * Each of those four commands begins by resolving `store_at(cave, player->grid)`
+ * AFRESH and refusing if the player is not standing in a store of the right
+ * kind. The transactions themselves (store/transact.ts storeBuy / storeSell)
+ * already model every later failure; these are the checks that come first, and
+ * the port had none of them: its shop screen captured one Store when the player
+ * stepped onto the tile and then called the transaction directly, so a command
+ * naming a store the player is not in was inexpressible.
+ *
+ * That was an argument from the port's current UI, not from the C. Upstream's
+ * commands take the store from the grid every time, so a mod adding remote trade
+ * - or anything that moves the player mid-transaction - reaches these. They are
+ * therefore real guards on the command path, returning upstream's message or
+ * null to proceed, rather than assertions.
+ */
+
+import { FEAT } from "../generated/index.js";
+import type { Store } from "./store.js";
+
+/**
+ * do_cmd_buy (store.c:1667-1670): purchasing requires standing in a store.
+ * Returns the refusal message, or null when the command may proceed.
+ */
+export function storeBuyGuard(store: Store | null): string | null {
+  if (!store) return "You cannot purchase items when not in a store.";
+  return null;
+}
+
+/**
+ * do_cmd_retrieve (store.c:1793-1800): taking from the Home requires being at
+ * the Home. Upstream returns SILENTLY when there is no store at all (L1794) and
+ * only speaks when the store is not the Home, so a null store says nothing.
+ */
+export function storeRetrieveGuard(store: Store | null): string | null {
+  if (!store) return null;
+  if (store.feat !== FEAT.HOME) return "You are not currently at home.";
+  return null;
+}
+
+/**
+ * do_cmd_sell (store.c:1902-1905): selling requires standing in a store. Note
+ * upstream checks this AFTER the stuck-item check (L1889-1893), so a stuck item
+ * outside a store reports being stuck, not the absent store.
+ */
+export function storeSellGuard(store: Store | null): string | null {
+  if (!store) return "You cannot sell items when not in a store.";
+  return null;
+}
+
+/**
+ * do_cmd_stash (store.c:2031-2034): stashing requires the Home, and unlike
+ * retrieve this one speaks for a null store too - the condition is
+ * `!store || store->feat != FEAT_HOME`.
+ */
+export function storeStashGuard(store: Store | null): string | null {
+  if (!store || store.feat !== FEAT.HOME) return "You are not in your home.";
+  return null;
+}
+
+/**
+ * enter_store (ui-store.c:1257-1262): the store screen refuses to open when the
+ * player's grid holds no store. The port opens the screen as a post-move
+ * consequence, so this fires only if the grid stops holding a store between the
+ * step and the screen opening - which is exactly the case upstream guards.
+ */
+export function enterStoreGuard(store: Store | null): string | null {
+  if (!store) return "You see no store here.";
+  return null;
+}