BlueGit

timfa questward

Files

questward / server / tests / shop.test.js

shop.test.js

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