BlueGit

timfa questward

Files

questward / server / tests / shop.test.js

shop.test.js

shop.test.js 37.4 KiB Download Raw
1import test from "node:test";
2import assert from "node:assert/strict";
3import
4 {
5 shopUnitPrice,
6 undiscountedMarketValue,
7 undiscountedMarketCoins,
8 marketValueAsCoins,
9 canSellInNpcShop,
10 canPlayerSellToNpc,
11 shopBuyFromPlayerPrice,
12 shopBoughtResalePrice,
13 shopChequeAdminFee,
14 resolveShopSellQuote,
15 shopRestockDayKey,
16 lerp
17 } from "../../shared/shop/pricing.js";
18import { ItemId, listAllItemPickerEntries } from "../../shared/definitions/items.js";
19import { CraftingItemId } from "../../shared/definitions/craftingItems.js";
20import { MobId, normalizeSpawnerConfig, isHumanoidMob } from "../../shared/definitions/mobs.js";
21import { makeCharacter, makeSimulation } from "./helpers/simulationHarness.js";
22import { Component } from "../src/ecs/components.js";
23import { emptyEquipment, emptySlots, addCoinsToSlots, countCoinsInSlots, INVENTORY_SLOTS } from "../../shared/items/inventory.js";
24import { ItemOriginKind } from "../../shared/items/origin.js";
25import { createEmptyChunkData, encodeChunkBlob } from "../src/world/chunkData.js";
26import { ensureShopRestocked } from "../src/shop/service.js";
27import { BlockType } from "../../shared/definitions/tiles.js";
28import { GatherOriginVerb, gatherOrigin } from "../../shared/items/origin.js";
29
30function boughtQty (shop, itemId)
31{
32 const raw = shop?.boughtStock?.[itemId];
33 if (raw == null)
34 { return 0; }
35 if (typeof raw === "number")
36 { return raw | 0; }
37 return raw.quantity | 0 || 0;
38}
39
40test("listAllItemPickerEntries includes paper and bronze gather tools", () =>
41{
42 const ids = new Set(listAllItemPickerEntries().map((entry) => entry.itemId));
43 assert.ok(ids.has(ItemId.paper));
44 assert.ok(ids.has(CraftingItemId.bronzeAxe));
45 assert.ok(ids.has(CraftingItemId.bronzePickaxe));
46 assert.equal(canSellInNpcShop(ItemId.paper), false);
47 assert.equal(canSellInNpcShop(CraftingItemId.bronzeAxe), false);
48});
49
50test("buy paper from a shopkeeper with explicit catalog", () =>
51{
52 const harness = makeSimulation({ workerCount: 1 });
53 try
54 {
55 const data = createEmptyChunkData();
56 data.open = true;
57 data.spawners = [{
58 localX: 9,
59 localY: 8,
60 config: {
61 mobTypeId: MobId.humanoid,
62 maxAlive: 1,
63 spawnRangeTiles: 1,
64 maxWanderRangeTiles: 1,
65 sex: "male",
66 displayName: "Stationer",
67 sells: [{ itemId: ItemId.paper, quantity: 0 }],
68 hiddenDiscount: 1,
69 equipment: { chest: ItemId.clothShirt }
70 }
71 }];
72 harness.worldDb.saveChunkVersion(0, 0, harness.worldDb.getActiveRevisionId(), true, encodeChunkBlob(data));
73 harness.simulation.reloadWorld();
74
75 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
76 const funded = addCoinsToSlots(emptySlots(), 20);
77 assert.equal(funded.ok, true);
78 harness.stateDb.saveBag(character.character_id, {
79 inventory: funded.slots,
80 equipment: emptyEquipment(),
81 vault: [],
82 vaultReserved: []
83 });
84 const playerId = harness.simulation.spawnCharacter(1, character);
85 harness.simulation.step();
86 harness.advance(50);
87 harness.simulation.step();
88
89 const record = harness.simulation.entityRecord(playerId);
90 const worker = harness.simulation.workers[record.workerId];
91 let npcId = null;
92 for (const entity of worker.world.ecs.query(Component.shop, Component.creature))
93 {
94 if (entity.creature.mobTypeId === MobId.humanoid)
95 {
96 npcId = entity.entityId;
97 break;
98 }
99 }
100 assert.ok(npcId, "expected a humanoid shopkeeper");
101
102 const npcHandle = worker.world.ecs.handleOf(npcId);
103 const npcPos = worker.world.ecs.get(npcHandle, Component.position);
104 const playerHandle = worker.world.ecs.handleOf(playerId);
105 const playerPos = worker.world.ecs.get(playerHandle, Component.position);
106 playerPos.tileX = npcPos.tileX;
107 playerPos.tileY = npcPos.tileY;
108
109 harness.simulation.enqueue(1, {
110 type: "interact",
111 characterId: character.character_id,
112 targetEntityId: npcId
113 });
114 const open = harness.simulation.step();
115 const shopOpen = open.events.find((event) => event.type === "shop-open");
116 assert.ok(shopOpen, JSON.stringify(open.events));
117 assert.ok(shopOpen.stock.some((row) => row.itemId === ItemId.paper));
118
119 harness.simulation.enqueue(1, {
120 type: "buy-from-shop",
121 characterId: character.character_id,
122 npcEntityId: npcId,
123 itemId: ItemId.paper,
124 quantity: 1,
125 listingId: `stock:${ItemId.paper}`
126 });
127 const buy = harness.simulation.step();
128 assert.equal(buy.events.some((event) => event.type === "command-error"), false, JSON.stringify(buy.events));
129 const bag = harness.simulation.bagOf(playerId);
130 const paper = (bag.inventory ?? []).find((slot) => slot?.itemId === ItemId.paper);
131 assert.ok(paper, JSON.stringify(bag.inventory));
132 }
133 finally
134 { harness.close(); }
135});
136
137test("shop prices fall back to seedValue and apply hidden discount", () =>
138{
139 assert.equal(undiscountedMarketValue(ItemId.copperOre), 5);
140 assert.equal(undiscountedMarketValue(ItemId.tinOre), 5);
141 assert.equal(undiscountedMarketValue(ItemId.pineLog), 5);
142 assert.equal(shopUnitPrice(ItemId.copperOre, { hiddenDiscount: 0.9 }), 5);
143 assert.equal(shopUnitPrice(ItemId.copperOre, { hiddenDiscount: 0.5 }), 3);
144 assert.equal(shopBuyFromPlayerPrice(ItemId.copperOre), 4);
145 assert.equal(shopBoughtResalePrice(ItemId.copperOre), 6);
146 assert.equal(lerp(10, 20, 0.5), 15);
147 assert.equal(canSellInNpcShop(ItemId.copperOre), true);
148 assert.equal(canSellInNpcShop(ItemId.tinOre), true);
149 assert.equal(canSellInNpcShop(ItemId.stick), false);
150 assert.equal(canPlayerSellToNpc({ itemId: ItemId.copperOre, quantity: 1 }), true);
151 assert.equal(canPlayerSellToNpc({ itemId: ItemId.stick, quantity: 1 }), true);
152 assert.equal(canPlayerSellToNpc({ itemId: ItemId.blankCheque, quantity: 1 }), false);
153 assert.equal(canPlayerSellToNpc({ itemId: ItemId.coins, quantity: 10 }), false);
154 assert.equal(canPlayerSellToNpc({
155 itemId: ItemId.recipePaper,
156 quantity: 1,
157 instance: { kind: "recipe-paper", recipeId: "lesser-health-tonic" }
158 }), false);
159 assert.equal(canPlayerSellToNpc({
160 itemId: ItemId.filledCheque,
161 quantity: 1,
162 instance: { kind: "filled-cheque", itemId: ItemId.copperOre, quantity: 3 }
163 }), true);
164 assert.equal(shopChequeAdminFee(100), 5);
165 assert.equal(shopChequeAdminFee(10), 1);
166 assert.equal(shopChequeAdminFee(1), 1);
167 const chequeQuote = resolveShopSellQuote({
168 itemId: ItemId.filledCheque,
169 quantity: 1,
170 instance: { kind: "filled-cheque", itemId: ItemId.copperOre, quantity: 2 }
171 });
172 assert.equal(chequeQuote.baseTotal, shopBuyFromPlayerPrice(ItemId.copperOre) * 2);
173 assert.equal(chequeQuote.adminFee, shopChequeAdminFee(chequeQuote.baseTotal));
174 assert.equal(chequeQuote.payout, chequeQuote.baseTotal - chequeQuote.adminFee);
175});
176
177test("market value display and shop use ceil fractional lerps", () =>
178{
179 const now = 1_000_000;
180 const lastSale = {
181 lastTradePrice: 10,
182 lastTradeAt: now - 500,
183 priceFrom: 5
184 };
185 // Halfway from 5 → 10 over 1000ms → 7.5 internally.
186 const raw = undiscountedMarketValue(ItemId.copperOre, lastSale, now, 1000);
187 assert.equal(raw, 7.5);
188 assert.equal(marketValueAsCoins(raw), 8);
189 assert.equal(undiscountedMarketCoins(ItemId.copperOre, lastSale, now, 1000), 8);
190 assert.equal(shopBuyFromPlayerPrice(ItemId.copperOre, { lastSale, now, lerpDurationMs: 1000 }), 6);
191 assert.equal(shopBoughtResalePrice(ItemId.copperOre, { lastSale, now, lerpDurationMs: 1000 }), 9);
192 assert.equal(shopUnitPrice(ItemId.copperOre, {
193 lastSale,
194 now,
195 lerpDurationMs: 1000,
196 hiddenDiscount: 1
197 }), 8);
198});
199
200test("humanoid spawner config keeps sex equipment sells quantities and buysItems", () =>
201{
202 assert.equal(isHumanoidMob(MobId.humanoid), true);
203 const config = normalizeSpawnerConfig({
204 mobTypeId: MobId.humanoid,
205 sex: "female",
206 displayName: "Ore trader",
207 equipment: { chest: ItemId.clothShirt, weapon: ItemId.stick },
208 sells: [
209 { itemId: ItemId.copperOre, quantity: 10 },
210 { itemId: ItemId.tinOre, quantity: 0 },
211 ItemId.copperOre
212 ],
213 buysItems: true,
214 hiddenDiscount: 0.85
215 }, "shop-1");
216 assert.equal(config.sex, "female");
217 assert.equal(config.displayName, "Ore trader");
218 assert.equal(config.equipment.chest, ItemId.clothShirt);
219 assert.deepEqual(config.sells, [
220 { itemId: ItemId.copperOre, quantity: 10 },
221 { itemId: ItemId.tinOre, quantity: 0 }
222 ]);
223 assert.equal(config.buysItems, true);
224 assert.equal(config.hiddenDiscount, 0.85);
225 assert.equal(config.maxAlive, 1);
226});
227
228test("shopkeeper with default buysItems accepts paper from the player", () =>
229{
230 const harness = makeSimulation({ workerCount: 1 });
231 try
232 {
233 const data = createEmptyChunkData();
234 data.open = true;
235 data.spawners = [{
236 localX: 9,
237 localY: 8,
238 config: {
239 mobTypeId: MobId.humanoid,
240 maxAlive: 1,
241 spawnRangeTiles: 0,
242 maxWanderRangeTiles: 0,
243 displayName: "Stationer"
244 }
245 }];
246 harness.worldDb.saveChunkVersion(0, 0, harness.worldDb.getActiveRevisionId(), true, encodeChunkBlob(data));
247 harness.simulation.reloadWorld();
248
249 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
250 const slots = emptySlots(INVENTORY_SLOTS);
251 slots[0] = { itemId: ItemId.paper, quantity: 3 };
252 harness.stateDb.saveBag(character.character_id, {
253 inventory: slots,
254 equipment: emptyEquipment(),
255 vault: [],
256 vaultReserved: []
257 });
258 const playerId = harness.simulation.spawnCharacter(1, character);
259 harness.simulation.step();
260 harness.advance(50);
261 harness.simulation.step();
262
263 const record = harness.simulation.entityRecord(playerId);
264 const worker = harness.simulation.workers[record.workerId];
265 let npcId = null;
266 for (const entity of worker.world.ecs.query(Component.shop, Component.creature))
267 {
268 if (entity.creature.mobTypeId === MobId.humanoid)
269 {
270 npcId = entity.entityId;
271 break;
272 }
273 }
274 assert.ok(npcId);
275 const npcHandle = worker.world.ecs.handleOf(npcId);
276 const shop = worker.world.ecs.get(npcHandle, Component.shop);
277 assert.equal(shop.buysItems, true);
278 const npcPos = worker.world.ecs.get(npcHandle, Component.position);
279 const playerHandle = worker.world.ecs.handleOf(playerId);
280 const playerPos = worker.world.ecs.get(playerHandle, Component.position);
281 playerPos.tileX = npcPos.tileX;
282 playerPos.tileY = npcPos.tileY;
283
284 const beforeCoins = countCoinsInSlots(worker.world.ecs.get(playerHandle, Component.inventory).slots);
285 harness.simulation.enqueue(1, {
286 type: "sell-to-shop",
287 characterId: character.character_id,
288 npcEntityId: npcId,
289 slotIndex: 0,
290 quantity: 1
291 });
292 const sold = harness.simulation.step();
293 assert.equal(sold.events.some((event) => event.type === "command-error"), false, JSON.stringify(sold.events));
294 const inv = worker.world.ecs.get(playerHandle, Component.inventory);
295 assert.equal(inv.slots[0]?.quantity, 2);
296 assert.ok(countCoinsInSlots(inv.slots) >= beforeCoins + shopBuyFromPlayerPrice(ItemId.paper));
297 }
298 finally
299 { harness.close(); }
300});
301
302test("humanoid spawner equipment can store clothing dye color", () =>
303{
304 const dyeColor = { r: 0.2, g: 0.4, b: 0.8 };
305 const config = normalizeSpawnerConfig({
306 mobTypeId: MobId.humanoid,
307 equipment: {
308 chest: { itemId: ItemId.clothShirt, dyeColor },
309 weapon: ItemId.stick
310 }
311 }, "shop-dye");
312 assert.deepEqual(config.equipment.chest, {
313 itemId: ItemId.clothShirt,
314 dyeColor
315 });
316 assert.equal(config.equipment.weapon, ItemId.stick);
317});
318
319test("buy copper ore from a spawned shopkeeper", () =>
320{
321 const harness = makeSimulation({ workerCount: 1 });
322 try
323 {
324 const data = createEmptyChunkData();
325 data.open = true;
326 data.spawners = [{
327 localX: 9,
328 localY: 8,
329 config: {
330 mobTypeId: MobId.humanoid,
331 maxAlive: 1,
332 spawnRangeTiles: 1,
333 maxWanderRangeTiles: 1,
334 sex: "male",
335 displayName: "Ore trader",
336 sells: [
337 { itemId: ItemId.copperOre, quantity: 0 },
338 { itemId: ItemId.tinOre, quantity: 0 }
339 ],
340 hiddenDiscount: 1,
341 equipment: { chest: ItemId.clothShirt }
342 }
343 }];
344 harness.worldDb.saveChunkVersion(0, 0, harness.worldDb.getActiveRevisionId(), true, encodeChunkBlob(data));
345 harness.simulation.reloadWorld();
346
347 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
348 const funded = addCoinsToSlots(emptySlots(), 50);
349 assert.equal(funded.ok, true);
350 harness.stateDb.saveBag(character.character_id, {
351 inventory: funded.slots,
352 equipment: emptyEquipment(),
353 vault: [],
354 vaultReserved: []
355 });
356 const playerId = harness.simulation.spawnCharacter(1, character);
357 harness.simulation.step();
358 harness.advance(50);
359 harness.simulation.step();
360
361 const record = harness.simulation.entityRecord(playerId);
362 const worker = harness.simulation.workers[record.workerId];
363 let npcId = null;
364 for (const entity of worker.world.ecs.query(Component.shop, Component.creature))
365 {
366 if (entity.creature.mobTypeId === MobId.humanoid)
367 {
368 npcId = entity.entityId;
369 break;
370 }
371 }
372 assert.ok(npcId, "expected a humanoid shopkeeper");
373
374 const npcHandle = worker.world.ecs.handleOf(npcId);
375 const npcPos = worker.world.ecs.get(npcHandle, Component.position);
376 const playerHandle = worker.world.ecs.handleOf(playerId);
377 const playerPos = worker.world.ecs.get(playerHandle, Component.position);
378 playerPos.tileX = npcPos.tileX;
379 playerPos.tileY = npcPos.tileY;
380
381 harness.simulation.enqueue(1, {
382 type: "interact",
383 characterId: character.character_id,
384 targetEntityId: npcId
385 });
386 const open = harness.simulation.step();
387 const shopOpen = open.events.find((event) => event.type === "shop-open");
388 assert.ok(shopOpen, JSON.stringify(open.events));
389 assert.ok(shopOpen.stock.some((row) => row.itemId === ItemId.copperOre));
390
391 harness.simulation.enqueue(1, {
392 type: "buy-from-shop",
393 characterId: character.character_id,
394 npcEntityId: npcId,
395 itemId: ItemId.copperOre,
396 quantity: 1,
397 listingId: `stock:${ItemId.copperOre}`
398 });
399 const buy = harness.simulation.step();
400 assert.equal(buy.events.some((event) => event.type === "command-error"), false, JSON.stringify(buy.events));
401 const bag = harness.simulation.bagOf(playerId);
402 const ore = (bag.inventory ?? []).find((slot) => slot?.itemId === ItemId.copperOre);
403 assert.ok(ore, JSON.stringify(bag.inventory));
404 assert.equal(ore.origins?.[0]?.origin?.kind, ItemOriginKind.shop);
405 assert.equal(ore.origins?.[0]?.origin?.displayName, "Ore trader");
406 }
407 finally
408 { harness.close(); }
409});
410
411test("limited shop stock depletes and restocks on a new day", () =>
412{
413 const shop = {
414 catalog: [{ itemId: ItemId.copperOre, quantity: 2 }],
415 buysItems: false,
416 hiddenDiscount: 1,
417 remaining: Object.create(null),
418 boughtStock: Object.create(null),
419 restockDay: null
420 };
421 const dayA = new Date(2026, 7, 25, 12, 0, 0, 0).getTime();
422 ensureShopRestocked(shop, dayA);
423 assert.equal(shop.restockDay, shopRestockDayKey(dayA));
424 assert.equal(shop.remaining[ItemId.copperOre], 2);
425 shop.remaining[ItemId.copperOre] = 0;
426 shop.boughtStock[ItemId.tinOre] = 3;
427 ensureShopRestocked(shop, dayA);
428 assert.equal(shop.remaining[ItemId.copperOre], 0);
429 assert.equal(shop.boughtStock[ItemId.tinOre], 3);
430 const dayB = new Date(2026, 7, 26, 0, 0, 1, 0).getTime();
431 ensureShopRestocked(shop, dayB);
432 assert.equal(shop.remaining[ItemId.copperOre], 2);
433 assert.equal(shop.boughtStock[ItemId.tinOre], undefined);
434});
435
436test("shop overflow goes to bank vault when inventory is full", () =>
437{
438 const harness = makeSimulation({ workerCount: 1 });
439 try
440 {
441 const data = createEmptyChunkData();
442 data.open = true;
443 data.spawners = [{
444 localX: 9,
445 localY: 8,
446 config: {
447 mobTypeId: MobId.humanoid,
448 maxAlive: 1,
449 spawnRangeTiles: 0,
450 maxWanderRangeTiles: 0,
451 displayName: "Ore trader",
452 sells: [{ itemId: ItemId.copperOre, quantity: 0 }],
453 hiddenDiscount: 1
454 }
455 }];
456 harness.worldDb.saveChunkVersion(0, 0, harness.worldDb.getActiveRevisionId(), true, encodeChunkBlob(data));
457 harness.simulation.reloadWorld();
458
459 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
460 const slots = emptySlots();
461 const funded = addCoinsToSlots(slots, 50);
462 assert.equal(funded.ok, true);
463 for (let i = 0; i < funded.slots.length; i++)
464 {
465 if (!funded.slots[i])
466 { funded.slots[i] = { itemId: ItemId.stick, quantity: 1 }; }
467 }
468 harness.stateDb.saveBag(character.character_id, {
469 inventory: funded.slots,
470 equipment: emptyEquipment(),
471 vault: [],
472 vaultReserved: []
473 });
474 const playerId = harness.simulation.spawnCharacter(1, character);
475 harness.simulation.step();
476 harness.advance(50);
477 harness.simulation.step();
478
479 const record = harness.simulation.entityRecord(playerId);
480 const worker = harness.simulation.workers[record.workerId];
481 let npcId = null;
482 for (const entity of worker.world.ecs.query(Component.shop, Component.creature))
483 {
484 if (entity.creature.mobTypeId === MobId.humanoid)
485 {
486 npcId = entity.entityId;
487 break;
488 }
489 }
490 assert.ok(npcId);
491 const npcHandle = worker.world.ecs.handleOf(npcId);
492 const npcPos = worker.world.ecs.get(npcHandle, Component.position);
493 const playerHandle = worker.world.ecs.handleOf(playerId);
494 const playerPos = worker.world.ecs.get(playerHandle, Component.position);
495 playerPos.tileX = npcPos.tileX;
496 playerPos.tileY = npcPos.tileY;
497
498 harness.simulation.enqueue(1, {
499 type: "buy-from-shop",
500 characterId: character.character_id,
501 npcEntityId: npcId,
502 itemId: ItemId.copperOre,
503 quantity: 1,
504 listingId: `stock:${ItemId.copperOre}`
505 });
506 const buy = harness.simulation.step();
507 assert.equal(buy.events.some((event) => event.type === "command-error"), false, JSON.stringify(buy.events));
508 const bag = harness.simulation.bagOf(playerId);
509 assert.equal((bag.inventory ?? []).some((slot) => slot?.itemId === ItemId.copperOre), false);
510 assert.ok((bag.vault ?? []).some((slot) => slot?.itemId === ItemId.copperOre));
511 }
512 finally
513 { harness.close(); }
514});
515
516test("buysItems refills limited catalog then stores extras for 120% resale", () =>
517{
518 const harness = makeSimulation({ workerCount: 1 });
519 try
520 {
521 const data = createEmptyChunkData();
522 data.open = true;
523 data.spawners = [{
524 localX: 9,
525 localY: 8,
526 config: {
527 mobTypeId: MobId.humanoid,
528 maxAlive: 1,
529 spawnRangeTiles: 0,
530 maxWanderRangeTiles: 0,
531 displayName: "Buyer",
532 sells: [{ itemId: ItemId.copperOre, quantity: 2 }],
533 buysItems: true,
534 hiddenDiscount: 1
535 }
536 }];
537 harness.worldDb.saveChunkVersion(0, 0, harness.worldDb.getActiveRevisionId(), true, encodeChunkBlob(data));
538 harness.simulation.reloadWorld();
539
540 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
541 harness.stateDb.saveBag(character.character_id, {
542 inventory: emptySlots(INVENTORY_SLOTS),
543 equipment: emptyEquipment(),
544 vault: [],
545 vaultReserved: []
546 });
547 const playerId = harness.simulation.spawnCharacter(1, character);
548 harness.simulation.step();
549 harness.advance(50);
550 harness.simulation.step();
551
552 const record = harness.simulation.entityRecord(playerId);
553 const worker = harness.simulation.workers[record.workerId];
554 let npcId = null;
555 for (const entity of worker.world.ecs.query(Component.shop, Component.creature))
556 {
557 if (entity.creature.mobTypeId === MobId.humanoid)
558 {
559 npcId = entity.entityId;
560 break;
561 }
562 }
563 assert.ok(npcId);
564 const npcHandle = worker.world.ecs.handleOf(npcId);
565 const shop = worker.world.ecs.get(npcHandle, Component.shop);
566 const npcPos = worker.world.ecs.get(npcHandle, Component.position);
567 const playerHandle = worker.world.ecs.handleOf(playerId);
568 const playerPos = worker.world.ecs.get(playerHandle, Component.position);
569 playerPos.tileX = npcPos.tileX;
570 playerPos.tileY = npcPos.tileY;
571
572 // Fund coins and buy out limited stock first.
573 const inv = worker.world.ecs.get(playerHandle, Component.inventory);
574 const funded = addCoinsToSlots(inv.slots, 50);
575 assert.equal(funded.ok, true);
576 inv.slots = funded.slots;
577 inv.slots[1] = { itemId: ItemId.copperOre, quantity: 5 };
578
579 harness.simulation.enqueue(1, {
580 type: "buy-from-shop",
581 characterId: character.character_id,
582 npcEntityId: npcId,
583 itemId: ItemId.copperOre,
584 quantity: 2,
585 listingId: `stock:${ItemId.copperOre}`
586 });
587 const boughtOut = harness.simulation.step();
588 assert.equal(boughtOut.events.some((event) => event.type === "command-error"), false, JSON.stringify(boughtOut.events));
589 assert.equal(shop.remaining[ItemId.copperOre], 0);
590
591 const oreSlot = inv.slots.findIndex((slot) => slot?.itemId === ItemId.copperOre && (slot.quantity | 0) >= 5);
592 assert.ok(oreSlot >= 0);
593
594 harness.simulation.enqueue(1, {
595 type: "sell-to-shop",
596 characterId: character.character_id,
597 npcEntityId: npcId,
598 slotIndex: oreSlot,
599 quantity: 5
600 });
601 const sold = harness.simulation.step();
602 assert.equal(sold.events.some((event) => event.type === "command-error"), false, JSON.stringify(sold.events));
603 assert.equal(shop.remaining[ItemId.copperOre], 2);
604 assert.equal(boughtQty(shop, ItemId.copperOre), 3);
605
606 const open = sold.events.find((event) => event.type === "shop-open");
607 assert.ok(open.stock.some((row) => row.source === "stock" && row.available === 2));
608 assert.ok(open.stock.some((row) => row.source === "bought" && row.available === 3));
609 }
610 finally
611 { harness.close(); }
612});
613
614test("shop adjacency errors use gendered pronouns", () =>
615{
616 const harness = makeSimulation({ workerCount: 1 });
617 try
618 {
619 const data = createEmptyChunkData();
620 data.open = true;
621 data.spawners = [{
622 localX: 9,
623 localY: 8,
624 config: {
625 mobTypeId: MobId.humanoid,
626 maxAlive: 1,
627 spawnRangeTiles: 0,
628 maxWanderRangeTiles: 0,
629 sex: "female",
630 displayName: "Trader",
631 sells: [{ itemId: ItemId.copperOre, quantity: 0 }],
632 hiddenDiscount: 1
633 }
634 }];
635 harness.worldDb.saveChunkVersion(0, 0, harness.worldDb.getActiveRevisionId(), true, encodeChunkBlob(data));
636 harness.simulation.reloadWorld();
637
638 const character = makeCharacter(harness.stateDb, { tileX: 2, tileY: 2 });
639 harness.stateDb.saveBag(character.character_id, {
640 inventory: emptySlots(INVENTORY_SLOTS),
641 equipment: emptyEquipment(),
642 vault: [],
643 vaultReserved: []
644 });
645 const playerId = harness.simulation.spawnCharacter(1, character);
646 harness.simulation.step();
647 harness.advance(50);
648 harness.simulation.step();
649
650 const record = harness.simulation.entityRecord(playerId);
651 const worker = harness.simulation.workers[record.workerId];
652 let npcId = null;
653 for (const entity of worker.world.ecs.query(Component.shop, Component.creature))
654 {
655 if (entity.creature.mobTypeId === MobId.humanoid)
656 {
657 npcId = entity.entityId;
658 break;
659 }
660 }
661 assert.ok(npcId);
662
663 harness.simulation.enqueue(1, {
664 type: "interact",
665 characterId: character.character_id,
666 targetEntityId: npcId
667 });
668 const open = harness.simulation.step();
669 const err = open.events.find((event) => event.type === "command-error");
670 assert.ok(err, JSON.stringify(open.events));
671 assert.match(err.message, /stand next to her/i);
672 assert.doesNotMatch(err.message, /\bthem\b/i);
673 }
674 finally
675 { harness.close(); }
676});
677
678test("shopkeeper stops wandering while a player has the shop open", () =>
679{
680 const harness = makeSimulation({ workerCount: 1 });
681 try
682 {
683 const data = createEmptyChunkData();
684 data.open = true;
685 data.spawners = [{
686 localX: 8,
687 localY: 8,
688 config: {
689 mobTypeId: MobId.humanoid,
690 maxAlive: 1,
691 spawnRangeTiles: 4,
692 maxWanderRangeTiles: 8,
693 sex: "male",
694 displayName: "Stay put",
695 sells: [{ itemId: ItemId.copperOre, quantity: 0 }],
696 hiddenDiscount: 1
697 }
698 }];
699 harness.worldDb.saveChunkVersion(0, 0, harness.worldDb.getActiveRevisionId(), true, encodeChunkBlob(data));
700 harness.simulation.reloadWorld();
701
702 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
703 harness.stateDb.saveBag(character.character_id, {
704 inventory: emptySlots(INVENTORY_SLOTS),
705 equipment: emptyEquipment(),
706 vault: [],
707 vaultReserved: []
708 });
709 const playerId = harness.simulation.spawnCharacter(1, character);
710 harness.simulation.step();
711 harness.advance(50);
712 harness.simulation.step();
713
714 const record = harness.simulation.entityRecord(playerId);
715 const worker = harness.simulation.workers[record.workerId];
716 let npc = null;
717 for (const entity of worker.world.ecs.query(Component.shop, Component.creature, Component.position, Component.path))
718 {
719 if (entity.creature.mobTypeId === MobId.humanoid)
720 {
721 npc = entity;
722 break;
723 }
724 }
725 assert.ok(npc);
726
727 const playerHandle = worker.world.ecs.handleOf(playerId);
728 const playerPos = worker.world.ecs.get(playerHandle, Component.position);
729 playerPos.tileX = npc.position.tileX;
730 playerPos.tileY = npc.position.tileY;
731
732 harness.simulation.enqueue(1, {
733 type: "interact",
734 characterId: character.character_id,
735 targetEntityId: npc.entityId
736 });
737 const open = harness.simulation.step();
738 assert.ok(open.events.some((event) => event.type === "shop-open"));
739 assert.equal(!!npc.shop.browsers?.[character.character_id], true);
740
741 npc.path.tiles = [{ x: npc.position.tileX + 1, y: npc.position.tileY }];
742 for (let i = 0; i < 20; i++)
743 { harness.simulation.step(); }
744 assert.equal(npc.path.tiles.length, 0);
745 assert.equal(npc.position.tileX, playerPos.tileX);
746 assert.equal(npc.position.tileY, playerPos.tileY);
747
748 harness.simulation.enqueue(1, {
749 type: "close-shop",
750 characterId: character.character_id,
751 npcEntityId: npc.entityId
752 });
753 harness.simulation.step();
754 assert.equal(!!npc.shop.browsers?.[character.character_id], false);
755 }
756 finally
757 { harness.close(); }
758});
759
760test("buysItems accepts non-ingredient tools like sticks", () =>
761{
762 const harness = makeSimulation({ workerCount: 1 });
763 try
764 {
765 const data = createEmptyChunkData();
766 data.open = true;
767 data.spawners = [{
768 localX: 9,
769 localY: 8,
770 config: {
771 mobTypeId: MobId.humanoid,
772 maxAlive: 1,
773 spawnRangeTiles: 0,
774 maxWanderRangeTiles: 0,
775 displayName: "Buyer",
776 buysItems: true,
777 hiddenDiscount: 1
778 }
779 }];
780 harness.worldDb.saveChunkVersion(0, 0, harness.worldDb.getActiveRevisionId(), true, encodeChunkBlob(data));
781 harness.simulation.reloadWorld();
782
783 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
784 const slots = emptySlots(INVENTORY_SLOTS);
785 slots[0] = { itemId: ItemId.stick, quantity: 1 };
786 harness.stateDb.saveBag(character.character_id, {
787 inventory: slots,
788 equipment: emptyEquipment(),
789 vault: [],
790 vaultReserved: []
791 });
792 const playerId = harness.simulation.spawnCharacter(1, character);
793 harness.simulation.step();
794 harness.advance(50);
795 harness.simulation.step();
796
797 const record = harness.simulation.entityRecord(playerId);
798 const worker = harness.simulation.workers[record.workerId];
799 let npcId = null;
800 for (const entity of worker.world.ecs.query(Component.shop, Component.creature))
801 {
802 if (entity.creature.mobTypeId === MobId.humanoid)
803 {
804 npcId = entity.entityId;
805 break;
806 }
807 }
808 assert.ok(npcId);
809 const npcHandle = worker.world.ecs.handleOf(npcId);
810 const shop = worker.world.ecs.get(npcHandle, Component.shop);
811 const npcPos = worker.world.ecs.get(npcHandle, Component.position);
812 const playerHandle = worker.world.ecs.handleOf(playerId);
813 const playerPos = worker.world.ecs.get(playerHandle, Component.position);
814 playerPos.tileX = npcPos.tileX;
815 playerPos.tileY = npcPos.tileY;
816
817 const beforeCoins = countCoinsInSlots(worker.world.ecs.get(playerHandle, Component.inventory).slots);
818 harness.simulation.enqueue(1, {
819 type: "sell-to-shop",
820 characterId: character.character_id,
821 npcEntityId: npcId,
822 slotIndex: 0,
823 quantity: 1
824 });
825 const sold = harness.simulation.step();
826 assert.equal(sold.events.some((event) => event.type === "command-error"), false, JSON.stringify(sold.events));
827 const inv = worker.world.ecs.get(playerHandle, Component.inventory);
828 assert.equal(inv.slots[0]?.itemId === ItemId.stick, false);
829 assert.ok(countCoinsInSlots(inv.slots) >= beforeCoins + shopBuyFromPlayerPrice(ItemId.stick));
830 assert.equal(boughtQty(shop, ItemId.stick), 1);
831 }
832 finally
833 { harness.close(); }
834});
835
836test("selling a filled cheque pays reserved-goods price minus 5% admin fee", () =>
837{
838 const harness = makeSimulation({ workerCount: 1 });
839 try
840 {
841 const data = createEmptyChunkData();
842 data.open = true;
843 data.blocks[8 * 16 + 8] = { typeId: BlockType.bank, state: 0 };
844 data.spawners = [{
845 localX: 9,
846 localY: 8,
847 config: {
848 mobTypeId: MobId.humanoid,
849 maxAlive: 1,
850 spawnRangeTiles: 0,
851 maxWanderRangeTiles: 0,
852 displayName: "Buyer",
853 sells: [{ itemId: ItemId.copperOre, quantity: 0 }],
854 buysItems: true,
855 hiddenDiscount: 1
856 }
857 }];
858 harness.worldDb.saveChunkVersion(0, 0, harness.worldDb.getActiveRevisionId(), true, encodeChunkBlob(data));
859 harness.simulation.reloadWorld();
860
861 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 9 });
862 const slots = emptySlots(INVENTORY_SLOTS);
863 slots[0] = { itemId: ItemId.copperOre, quantity: 2 };
864 harness.stateDb.saveBag(character.character_id, {
865 inventory: slots,
866 equipment: emptyEquipment(),
867 vault: [],
868 vaultReserved: []
869 });
870 const playerId = harness.simulation.spawnCharacter(1, character);
871 harness.simulation.step();
872
873 harness.simulation.enqueue(1, {
874 type: "get-blank-cheques",
875 characterId: character.character_id
876 });
877 harness.simulation.step();
878 harness.simulation.enqueue(1, {
879 type: "bank-deposit",
880 characterId: character.character_id,
881 slotIndex: 0,
882 quantity: null
883 });
884 harness.simulation.step();
885 let bag = harness.simulation.bagOf(playerId);
886 const blankIndex = bag.inventory.findIndex((slot) => slot?.itemId === ItemId.blankCheque);
887 const vaultIndex = bag.vault.findIndex((slot) => slot?.itemId === ItemId.copperOre);
888 harness.simulation.enqueue(1, {
889 type: "write-cheque",
890 characterId: character.character_id,
891 slotIndex: blankIndex,
892 vaultSlotIndex: vaultIndex,
893 quantity: 2
894 });
895 harness.simulation.step();
896 bag = harness.simulation.bagOf(playerId);
897 const chequeIndex = bag.inventory.findIndex((slot) => slot?.itemId === ItemId.filledCheque);
898 assert.ok(chequeIndex >= 0);
899
900 const record = harness.simulation.entityRecord(playerId);
901 const worker = harness.simulation.workers[record.workerId];
902 let npcId = null;
903 for (const entity of worker.world.ecs.query(Component.shop, Component.creature))
904 {
905 if (entity.creature.mobTypeId === MobId.humanoid)
906 {
907 npcId = entity.entityId;
908 break;
909 }
910 }
911 assert.ok(npcId);
912 const npcHandle = worker.world.ecs.handleOf(npcId);
913 const shop = worker.world.ecs.get(npcHandle, Component.shop);
914 const npcPos = worker.world.ecs.get(npcHandle, Component.position);
915 const playerHandle = worker.world.ecs.handleOf(playerId);
916 const playerPos = worker.world.ecs.get(playerHandle, Component.position);
917 playerPos.tileX = npcPos.tileX;
918 playerPos.tileY = npcPos.tileY;
919
920 const quote = resolveShopSellQuote(bag.inventory[chequeIndex]);
921 assert.ok(quote?.isCheque);
922 const beforeCoins = countCoinsInSlots(worker.world.ecs.get(playerHandle, Component.inventory).slots);
923 harness.simulation.enqueue(1, {
924 type: "sell-to-shop",
925 characterId: character.character_id,
926 npcEntityId: npcId,
927 slotIndex: chequeIndex,
928 quantity: 1
929 });
930 const sold = harness.simulation.step();
931 assert.equal(sold.events.some((event) => event.type === "command-error"), false, JSON.stringify(sold.events));
932 bag = harness.simulation.bagOf(playerId);
933 assert.equal(bag.inventory.findIndex((slot) => slot?.itemId === ItemId.filledCheque), -1);
934 assert.equal((bag.vaultReserved ?? []).length, 0);
935 const afterCoins = countCoinsInSlots(worker.world.ecs.get(playerHandle, Component.inventory).slots);
936 assert.equal(afterCoins - beforeCoins, quote.payout);
937 // Infinite catalog absorbs goods without bought-from-player resale stock.
938 assert.equal(boughtQty(shop, ItemId.copperOre), 0);
939 }
940 finally
941 { harness.close(); }
942});
943
944test("resale stock keeps the seller origin instead of Bought from NPC", () =>
945{
946 const harness = makeSimulation({ workerCount: 1 });
947 try
948 {
949 const data = createEmptyChunkData();
950 data.open = true;
951 data.spawners = [{
952 localX: 9,
953 localY: 8,
954 config: {
955 mobTypeId: MobId.humanoid,
956 maxAlive: 1,
957 spawnRangeTiles: 0,
958 maxWanderRangeTiles: 0,
959 displayName: "Fence",
960 sells: [],
961 buysItems: true,
962 hiddenDiscount: 1
963 }
964 }];
965 harness.worldDb.saveChunkVersion(0, 0, harness.worldDb.getActiveRevisionId(), true, encodeChunkBlob(data));
966 harness.simulation.reloadWorld();
967
968 const minerOrigin = gatherOrigin(GatherOriginVerb.mined, "Ada Miner");
969 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
970 const funded = addCoinsToSlots(emptySlots(), 50);
971 assert.equal(funded.ok, true);
972 funded.slots[1] = {
973 itemId: ItemId.copperOre,
974 quantity: 2,
975 origins: [{ origin: minerOrigin, quantity: 2 }]
976 };
977 harness.stateDb.saveBag(character.character_id, {
978 inventory: funded.slots,
979 equipment: emptyEquipment(),
980 vault: [],
981 vaultReserved: []
982 });
983 const playerId = harness.simulation.spawnCharacter(1, character);
984 harness.simulation.step();
985 harness.advance(50);
986 harness.simulation.step();
987
988 const record = harness.simulation.entityRecord(playerId);
989 const worker = harness.simulation.workers[record.workerId];
990 let npcId = null;
991 for (const entity of worker.world.ecs.query(Component.shop, Component.creature))
992 {
993 if (entity.creature.mobTypeId === MobId.humanoid)
994 {
995 npcId = entity.entityId;
996 break;
997 }
998 }
999 assert.ok(npcId);
1000 const npcHandle = worker.world.ecs.handleOf(npcId);
1001 const shop = worker.world.ecs.get(npcHandle, Component.shop);
1002 const npcPos = worker.world.ecs.get(npcHandle, Component.position);
1003 const playerHandle = worker.world.ecs.handleOf(playerId);
1004 const playerPos = worker.world.ecs.get(playerHandle, Component.position);
1005 playerPos.tileX = npcPos.tileX;
1006 playerPos.tileY = npcPos.tileY;
1007
1008 harness.simulation.enqueue(1, {
1009 type: "sell-to-shop",
1010 characterId: character.character_id,
1011 npcEntityId: npcId,
1012 slotIndex: 1,
1013 quantity: 2
1014 });
1015 const sold = harness.simulation.step();
1016 assert.equal(sold.events.some((event) => event.type === "command-error"), false, JSON.stringify(sold.events));
1017 assert.equal(boughtQty(shop, ItemId.copperOre), 2);
1018 assert.deepEqual(shop.boughtStock[ItemId.copperOre].origins, [
1019 { origin: minerOrigin, quantity: 2 }
1020 ]);
1021
1022 harness.simulation.enqueue(1, {
1023 type: "buy-from-shop",
1024 characterId: character.character_id,
1025 npcEntityId: npcId,
1026 itemId: ItemId.copperOre,
1027 quantity: 2,
1028 listingId: `bought:${ItemId.copperOre}`,
1029 source: "bought"
1030 });
1031 const buy = harness.simulation.step();
1032 assert.equal(buy.events.some((event) => event.type === "command-error"), false, JSON.stringify(buy.events));
1033 const bag = harness.simulation.bagOf(playerId);
1034 const ore = (bag.inventory ?? []).find((slot) => slot?.itemId === ItemId.copperOre);
1035 assert.ok(ore);
1036 assert.equal(ore.origins?.[0]?.origin?.kind, ItemOriginKind.gathered);
1037 assert.equal(ore.origins?.[0]?.origin?.displayName, "Ada Miner");
1038 assert.equal(ore.origins?.[0]?.origin?.kind === ItemOriginKind.shop, false);
1039 }
1040 finally
1041 { harness.close(); }
1042});
1043
1044test("NPC letter sales pay out and destroy the letter without stock", () =>
1045{
1046 const harness = makeSimulation({ workerCount: 1 });
1047 try
1048 {
1049 const data = createEmptyChunkData();
1050 data.open = true;
1051 data.spawners = [{
1052 localX: 9,
1053 localY: 8,
1054 config: {
1055 mobTypeId: MobId.humanoid,
1056 maxAlive: 1,
1057 spawnRangeTiles: 0,
1058 maxWanderRangeTiles: 0,
1059 displayName: "Fence",
1060 sells: [],
1061 buysItems: true,
1062 hiddenDiscount: 1
1063 }
1064 }];
1065 harness.worldDb.saveChunkVersion(0, 0, harness.worldDb.getActiveRevisionId(), true, encodeChunkBlob(data));
1066 harness.simulation.reloadWorld();
1067
1068 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
1069 const funded = addCoinsToSlots(emptySlots(), 10);
1070 assert.equal(funded.ok, true);
1071 funded.slots[1] = {
1072 itemId: ItemId.letter,
1073 quantity: 1,
1074 instance: {
1075 kind: "letter",
1076 letterId: "sell-me",
1077 authorCharacterId: character.character_id,
1078 authorDisplayName: "Ada",
1079 body: "For sale",
1080 opened: true,
1081 writtenAt: Date.now()
1082 }
1083 };
1084 harness.stateDb.saveBag(character.character_id, {
1085 inventory: funded.slots,
1086 equipment: emptyEquipment(),
1087 vault: [],
1088 vaultReserved: []
1089 });
1090 const playerId = harness.simulation.spawnCharacter(1, character);
1091 harness.simulation.step();
1092 harness.advance(50);
1093 harness.simulation.step();
1094
1095 const record = harness.simulation.entityRecord(playerId);
1096 const worker = harness.simulation.workers[record.workerId];
1097 let npcId = null;
1098 for (const entity of worker.world.ecs.query(Component.shop, Component.creature))
1099 {
1100 if (entity.creature.mobTypeId === MobId.humanoid)
1101 {
1102 npcId = entity.entityId;
1103 break;
1104 }
1105 }
1106 assert.ok(npcId);
1107 const npcHandle = worker.world.ecs.handleOf(npcId);
1108 const shop = worker.world.ecs.get(npcHandle, Component.shop);
1109 const npcPos = worker.world.ecs.get(npcHandle, Component.position);
1110 const playerHandle = worker.world.ecs.handleOf(playerId);
1111 const playerPos = worker.world.ecs.get(playerHandle, Component.position);
1112 playerPos.tileX = npcPos.tileX;
1113 playerPos.tileY = npcPos.tileY;
1114
1115 const letterSlot = harness.simulation.bagOf(playerId).inventory
1116 .findIndex((slot) => slot?.itemId === ItemId.letter);
1117 assert.ok(letterSlot >= 0);
1118 const quote = resolveShopSellQuote(harness.simulation.bagOf(playerId).inventory[letterSlot]);
1119 assert.ok(quote);
1120 const beforeCoins = countCoinsInSlots(worker.world.ecs.get(playerHandle, Component.inventory).slots);
1121
1122 harness.simulation.enqueue(1, {
1123 type: "sell-to-shop",
1124 characterId: character.character_id,
1125 npcEntityId: npcId,
1126 slotIndex: letterSlot,
1127 quantity: 1
1128 });
1129 const sold = harness.simulation.step();
1130 assert.equal(sold.events.some((event) => event.type === "command-error"), false, JSON.stringify(sold.events));
1131 const bag = harness.simulation.bagOf(playerId);
1132 assert.equal(bag.inventory.some((slot) => slot?.itemId === ItemId.letter), false);
1133 assert.equal(boughtQty(shop, ItemId.letter), 0);
1134 assert.equal(shop.boughtStock?.[ItemId.letter], undefined);
1135 const afterCoins = countCoinsInSlots(worker.world.ecs.get(playerHandle, Component.inventory).slots);
1136 assert.equal(afterCoins - beforeCoins, quote.payout);
1137 }
1138 finally
1139 { harness.close(); }
1140});