BlueGit

timfa questward

Files

questward / server / tests / shop.test.js

shop.test.js

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