BlueGit

timfa questward

Files

questward / server / tests / shop.test.js

shop.test.js

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