Merge branch 'main' into feature/treasure-ui-and-inventory

Reviewed-on: #11

src/App.tsx

@@ -12,7 +12,6 @@ import {
   startCombatInCurrentRoom,
   travelCurrentExit,
 } from "@/rules/runState";
-import { queueTreasureForSale, sellPendingTreasure, sendTreasureToStash } from "@/rules/town";
 import type { RunState } from "@/types/state";
 
 function createDemoRun() {
@@ -115,8 +114,6 @@ function App() {
   );
   const equippedItems = run.adventurerSnapshot.inventory.equipped;
   const latestLoot = run.lootedItems.slice(-4).reverse();
-  const pendingSales = run.townState.pendingSales;
-  const stash = run.townState.stash;
 
   const handleReset = () => {
     setRun(createDemoRun());
@@ -159,18 +156,6 @@ function App() {
     );
   };
 
-  const handleQueueSale = (definitionId: string) => {
-    setRun((previous) => queueTreasureForSale(sampleContentPack, previous, definitionId).run);
-  };
-
-  const handleStashTreasure = (definitionId: string) => {
-    setRun((previous) => sendTreasureToStash(sampleContentPack, previous, definitionId).run);
-  };
-
-  const handleSellPending = () => {
-    setRun((previous) => sellPendingTreasure(sampleContentPack, previous).run);
-  };
-
   return (
     <main className="app-shell">
       <section className="hero">
@@ -350,91 +335,6 @@ function App() {
           </div>
         </article>
 
-        <article className="panel panel-town">
-          <div className="panel-header">
-            <h2>Town Market</h2>
-            <span>{run.townState.visits} town actions</span>
-          </div>
-          <div className="town-summary">
-            <div className="inventory-badge">
-              <span>Known Services</span>
-              <strong>{run.townState.knownServices.length}</strong>
-            </div>
-            <div className="inventory-badge">
-              <span>Queued Sales</span>
-              <strong>{pendingSales.length}</strong>
-            </div>
-            <div className="inventory-badge">
-              <span>Stash</span>
-              <strong>{stash.length}</strong>
-            </div>
-          </div>
-          <div className="town-actions">
-            <button
-              className="button button-primary"
-              onClick={handleSellPending}
-              disabled={pendingSales.length === 0}
-            >
-              Sell Queued Treasure
-            </button>
-          </div>
-          <section className="town-section">
-            <span className="inventory-label">Treasure In Pack</span>
-            <div className="inventory-list">
-              {carriedTreasure.length === 0 ? (
-                <p className="supporting-text">No treasure available for town actions.</p>
-              ) : (
-                carriedTreasure.map((entry) => (
-                  <article key={`town-pack-${entry.definitionId}`} className="town-card">
-                    <div>
-                      <strong>{formatInventoryEntry(entry.definitionId, entry.quantity)}</strong>
-                      <span>Choose whether to sell or stash this treasure.</span>
-                    </div>
-                    <div className="enemy-actions">
-                      <button className="button" onClick={() => handleStashTreasure(entry.definitionId)}>
-                        Send To Stash
-                      </button>
-                      <button className="button button-primary" onClick={() => handleQueueSale(entry.definitionId)}>
-                        Queue For Sale
-                      </button>
-                    </div>
-                  </article>
-                ))
-              )}
-            </div>
-          </section>
-          <section className="town-section">
-            <span className="inventory-label">Pending Sales</span>
-            <div className="inventory-list">
-              {pendingSales.length === 0 ? (
-                <p className="supporting-text">Nothing queued at the market.</p>
-              ) : (
-                pendingSales.map((entry) => (
-                  <article key={`pending-${entry.definitionId}`} className="inventory-card inventory-card-treasure">
-                    <strong>{formatInventoryEntry(entry.definitionId, entry.quantity)}</strong>
-                    <span>Ready to convert into gold</span>
-                  </article>
-                ))
-              )}
-            </div>
-          </section>
-          <section className="town-section">
-            <span className="inventory-label">Town Stash</span>
-            <div className="inventory-list">
-              {stash.length === 0 ? (
-                <p className="supporting-text">The stash is empty.</p>
-              ) : (
-                stash.map((entry) => (
-                  <article key={`stash-${entry.definitionId}`} className="inventory-card">
-                    <strong>{formatInventoryEntry(entry.definitionId, entry.quantity)}</strong>
-                    <span>Held safely in town storage</span>
-                  </article>
-                ))
-              )}
-            </div>
-          </section>
-        </article>
-
         <article className="panel">
           <div className="panel-header">
             <h2>Current Room</h2>

src/rules/runState.test.ts

@@ -269,4 +269,46 @@ describe("run state flow", () => {
 
     expect(isCurrentRoomCombatReady(run)).toBe(true);
   });
+
+  it("lists available traversable exits for the current room", () => {
+    const run = createRunState({
+      content: sampleContentPack,
+      campaignId: "campaign.1",
+      adventurer: createAdventurer(),
+    });
+
+    expect(getAvailableMoves(run)).toEqual([
+      expect.objectContaining({
+        direction: "north",
+        generated: false,
+      }),
+    ]);
+  });
+
+  it("travels through an unresolved exit, generates a room, and enters it", () => {
+    const run = createRunState({
+      content: sampleContentPack,
+      campaignId: "campaign.1",
+      adventurer: createAdventurer(),
+      at: "2026-03-15T14:00:00.000Z",
+    });
+
+    const result = travelCurrentExit({
+      content: sampleContentPack,
+      run,
+      exitDirection: "north",
+      roller: createSequenceRoller([1, 1]),
+      at: "2026-03-15T14:05:00.000Z",
+    });
+
+    expect(result.run.currentRoomId).toBe("room.level1.room.002");
+    expect(result.run.dungeon.levels["1"]!.discoveredRoomOrder).toEqual([
+      "room.level1.start",
+      "room.level1.room.002",
+    ]);
+    expect(result.run.dungeon.levels["1"]!.rooms["room.level1.room.002"]!.discovery.entered).toBe(
+      true,
+    );
+    expect(result.run.log[0]?.text).toContain("Travelled north");
+  });
 });

src/rules/runState.ts

@@ -10,7 +10,6 @@ import { findCreatureById } from "@/data/contentHelpers";
 
 import { startCombatFromRoom } from "./combat";
 import { resolveCombatLoot } from "./loot";
-import { createInitialTownState } from "./town";
 import {
   resolveEnemyTurn,
   resolvePlayerAttack,
@@ -165,13 +164,6 @@ function cloneRun(run: RunState): RunState {
       globalFlags: [...run.dungeon.globalFlags],
     },
     activeCombat: run.activeCombat ? cloneCombat(run.activeCombat) : undefined,
-    townState: {
-      ...run.townState,
-      knownServices: [...run.townState.knownServices],
-      stash: run.townState.stash.map((entry) => ({ ...entry })),
-      pendingSales: run.townState.pendingSales.map((entry) => ({ ...entry })),
-      serviceFlags: [...run.townState.serviceFlags],
-    },
     defeatedCreatureIds: [...run.defeatedCreatureIds],
     xpGained: run.xpGained,
     goldGained: run.goldGained,
@@ -344,7 +336,6 @@ export function createRunState(options: CreateRunOptions): RunState {
       globalFlags: [],
     },
     adventurerSnapshot: options.adventurer,
-    townState: createInitialTownState(),
     defeatedCreatureIds: [],
     xpGained: 0,
     goldGained: 0,

src/rules/town.test.ts

@@ -1,74 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { sampleContentPack } from "@/data/sampleContentPack";
-
-import { createStartingAdventurer } from "./character";
-import { createRunState } from "./runState";
-import { queueTreasureForSale, sellPendingTreasure, sendTreasureToStash } from "./town";
-
-function createAdventurer() {
-  return createStartingAdventurer(sampleContentPack, {
-    name: "Aster",
-    weaponId: "weapon.short-sword",
-    armourId: "armour.leather-vest",
-    scrollId: "scroll.lesser-heal",
-  });
-}
-
-describe("town flow", () => {
-  it("moves treasure from carried inventory into the stash", () => {
-    const run = createRunState({
-      content: sampleContentPack,
-      campaignId: "campaign.1",
-      adventurer: createAdventurer(),
-    });
-
-    run.adventurerSnapshot.inventory.carried.push({
-      definitionId: "item.silver-clasp",
-      quantity: 1,
-    });
-
-    const result = sendTreasureToStash(
-      sampleContentPack,
-      run,
-      "item.silver-clasp",
-      "2026-03-15T15:00:00.000Z",
-    );
-
-    expect(result.run.townState.stash).toEqual([
-      { definitionId: "item.silver-clasp", quantity: 1 },
-    ]);
-    expect(result.run.adventurerSnapshot.inventory.carried).not.toEqual(
-      expect.arrayContaining([expect.objectContaining({ definitionId: "item.silver-clasp" })]),
-    );
-  });
-
-  it("queues treasure and sells it for item value", () => {
-    const run = createRunState({
-      content: sampleContentPack,
-      campaignId: "campaign.1",
-      adventurer: createAdventurer(),
-    });
-
-    run.adventurerSnapshot.inventory.carried.push({
-      definitionId: "item.keeper-keyring",
-      quantity: 1,
-    });
-
-    const queued = queueTreasureForSale(
-      sampleContentPack,
-      run,
-      "item.keeper-keyring",
-      "2026-03-15T15:05:00.000Z",
-    ).run;
-    const sold = sellPendingTreasure(
-      sampleContentPack,
-      queued,
-      "2026-03-15T15:06:00.000Z",
-    ).run;
-
-    expect(sold.townState.pendingSales).toEqual([]);
-    expect(sold.adventurerSnapshot.inventory.currency.gold).toBe(5);
-    expect(sold.log.at(-1)?.text).toContain("for 5 gold");
-  });
-});

src/rules/town.ts

@@ -1,165 +0,0 @@
-import { findItemById } from "@/data/contentHelpers";
-import type { ContentPack } from "@/types/content";
-import type { InventoryEntry, RunState, TownState } from "@/types/state";
-import type { LogEntry } from "@/types/rules";
-
-export type TownActionResult = {
-  run: RunState;
-  logEntries: LogEntry[];
-};
-
-function cloneTownState(townState: TownState): TownState {
-  return {
-    ...townState,
-    knownServices: [...townState.knownServices],
-    stash: townState.stash.map((entry) => ({ ...entry })),
-    pendingSales: townState.pendingSales.map((entry) => ({ ...entry })),
-    serviceFlags: [...townState.serviceFlags],
-  };
-}
-
-function cloneRun(run: RunState): RunState {
-  return {
-    ...run,
-    adventurerSnapshot: {
-      ...run.adventurerSnapshot,
-      hp: { ...run.adventurerSnapshot.hp },
-      stats: { ...run.adventurerSnapshot.stats },
-      favour: { ...run.adventurerSnapshot.favour },
-      statuses: run.adventurerSnapshot.statuses.map((status) => ({ ...status })),
-      inventory: {
-        ...run.adventurerSnapshot.inventory,
-        carried: run.adventurerSnapshot.inventory.carried.map((entry) => ({ ...entry })),
-        equipped: run.adventurerSnapshot.inventory.equipped.map((entry) => ({ ...entry })),
-        stored: run.adventurerSnapshot.inventory.stored.map((entry) => ({ ...entry })),
-        currency: { ...run.adventurerSnapshot.inventory.currency },
-        lightSources: run.adventurerSnapshot.inventory.lightSources.map((entry) => ({ ...entry })),
-      },
-      progressionFlags: [...run.adventurerSnapshot.progressionFlags],
-      manoeuvreIds: [...run.adventurerSnapshot.manoeuvreIds],
-    },
-    townState: cloneTownState(run.townState),
-    defeatedCreatureIds: [...run.defeatedCreatureIds],
-    lootedItems: run.lootedItems.map((entry) => ({ ...entry })),
-    log: run.log.map((entry) => ({ ...entry, relatedIds: entry.relatedIds ? [...entry.relatedIds] : undefined })),
-    pendingEffects: run.pendingEffects.map((effect) => ({ ...effect })),
-  };
-}
-
-function mergeEntry(entries: InventoryEntry[], entry: InventoryEntry) {
-  const existing = entries.find((candidate) => candidate.definitionId === entry.definitionId);
-
-  if (existing) {
-    existing.quantity += entry.quantity;
-    return;
-  }
-
-  entries.push({ ...entry });
-}
-
-function extractEntry(entries: InventoryEntry[], definitionId: string) {
-  const index = entries.findIndex((entry) => entry.definitionId === definitionId);
-
-  if (index === -1) {
-    throw new Error(`No inventory entry found for ${definitionId}.`);
-  }
-
-  const [removed] = entries.splice(index, 1);
-  return removed;
-}
-
-function createTownLog(id: string, at: string, text: string, relatedIds: string[]): LogEntry {
-  return {
-    id,
-    at,
-    type: "town",
-    text,
-    relatedIds,
-  };
-}
-
-export function createInitialTownState(): TownState {
-  return {
-    visits: 0,
-    knownServices: ["service.market"],
-    stash: [],
-    pendingSales: [],
-    serviceFlags: [],
-  };
-}
-
-export function sendTreasureToStash(
-  content: ContentPack,
-  run: RunState,
-  definitionId: string,
-  at = new Date().toISOString(),
-): TownActionResult {
-  const nextRun = cloneRun(run);
-  const removed = extractEntry(nextRun.adventurerSnapshot.inventory.carried, definitionId);
-  mergeEntry(nextRun.townState.stash, removed);
-  nextRun.townState.visits += 1;
-  const item = findItemById(content, definitionId);
-  const logEntry = createTownLog(
-    `town.stash.${definitionId}.${nextRun.log.length + 1}`,
-    at,
-    `Moved ${item.name} into the town stash.`,
-    [definitionId],
-  );
-  nextRun.log.push(logEntry);
-
-  return { run: nextRun, logEntries: [logEntry] };
-}
-
-export function queueTreasureForSale(
-  content: ContentPack,
-  run: RunState,
-  definitionId: string,
-  at = new Date().toISOString(),
-): TownActionResult {
-  const nextRun = cloneRun(run);
-  const removed = extractEntry(nextRun.adventurerSnapshot.inventory.carried, definitionId);
-  mergeEntry(nextRun.townState.pendingSales, removed);
-  nextRun.townState.visits += 1;
-  const item = findItemById(content, definitionId);
-  const logEntry = createTownLog(
-    `town.queue.${definitionId}.${nextRun.log.length + 1}`,
-    at,
-    `Queued ${item.name} for sale at the market.`,
-    [definitionId],
-  );
-  nextRun.log.push(logEntry);
-
-  return { run: nextRun, logEntries: [logEntry] };
-}
-
-export function sellPendingTreasure(
-  content: ContentPack,
-  run: RunState,
-  at = new Date().toISOString(),
-): TownActionResult {
-  const nextRun = cloneRun(run);
-  const soldEntries = nextRun.townState.pendingSales;
-  const goldEarned = soldEntries.reduce((total, entry) => {
-    const item = findItemById(content, entry.definitionId);
-    return total + (item.valueGp ?? 0) * entry.quantity;
-  }, 0);
-
-  nextRun.adventurerSnapshot.inventory.currency.gold += goldEarned;
-  nextRun.townState.pendingSales = [];
-  nextRun.townState.visits += 1;
-
-  const soldText =
-    soldEntries.length === 0
-      ? "No treasure was queued for sale."
-      : `Sold ${soldEntries.reduce((total, entry) => total + entry.quantity, 0)} treasure item${soldEntries.reduce((total, entry) => total + entry.quantity, 0) === 1 ? "" : "s"} for ${goldEarned} gold.`;
-
-  const logEntry = createTownLog(
-    `town.sell.${nextRun.log.length + 1}`,
-    at,
-    soldText,
-    soldEntries.map((entry) => entry.definitionId),
-  );
-  nextRun.log.push(logEntry);
-
-  return { run: nextRun, logEntries: [logEntry] };
-}

src/schemas/state.ts

@@ -214,7 +214,6 @@ export const runStateSchema = z.object({
   dungeon: dungeonStateSchema,
   adventurerSnapshot: adventurerStateSchema,
   activeCombat: combatStateSchema.optional(),
-  townState: townStateSchema,
   defeatedCreatureIds: z.array(z.string()),
   xpGained: z.number().int().nonnegative(),
   goldGained: z.number().int().nonnegative(),

src/styles.css

@@ -159,13 +159,6 @@ select {
     rgba(25, 19, 16, 0.9);
 }
 
-.panel-town {
-  grid-column: span 4;
-  background:
-    linear-gradient(180deg, rgba(32, 37, 24, 0.92), rgba(20, 22, 14, 0.92)),
-    rgba(25, 19, 16, 0.9);
-}
-
 .panel-log {
   grid-column: span 12;
 }
@@ -236,14 +229,12 @@ select {
 }
 
 .inventory-summary,
-.inventory-grid,
+.inventory-grid {
-.town-summary {
   display: grid;
   gap: 0.75rem;
 }
 
-.inventory-summary,
+.inventory-summary {
-.town-summary {
   grid-template-columns: repeat(4, minmax(0, 1fr));
 }
 
@@ -259,36 +250,6 @@ select {
     linear-gradient(180deg, rgba(255, 245, 223, 0.04), rgba(255, 245, 223, 0.02));
 }
 
-.town-section {
-  margin-top: 1rem;
-  padding-top: 1rem;
-  border-top: 1px solid rgba(255, 231, 196, 0.08);
-}
-
-.town-actions {
-  margin-top: 1rem;
-}
-
-.town-card {
-  display: grid;
-  gap: 0.75rem;
-  padding: 0.95rem;
-  border: 1px solid rgba(255, 231, 196, 0.08);
-  background: rgba(255, 245, 223, 0.04);
-}
-
-.town-card strong {
-  display: block;
-  color: #fff2d6;
-}
-
-.town-card span {
-  display: block;
-  margin-top: 0.25rem;
-  color: rgba(244, 239, 227, 0.62);
-  font-size: 0.84rem;
-}
-
 .inventory-label {
   display: block;
   margin-bottom: 0.7rem;
@@ -520,8 +481,7 @@ select {
   }
 
   .inventory-summary,
-  .inventory-grid,
+  .inventory-grid {
-  .town-summary {
     grid-template-columns: 1fr;
   }
 }

src/types/state.ts

@@ -215,7 +215,6 @@ export type RunState = {
   dungeon: DungeonState;
   adventurerSnapshot: AdventurerState;
   activeCombat?: CombatState;
-  townState: TownState;
   defeatedCreatureIds: string[];
   xpGained: number;
   goldGained: number;