BlueGit

timfa questward

Files

questward / shared / items / origin.js

origin.js

origin.js 7.9 KiB Download Raw
1export const ItemOriginKind = Object.freeze({
2 crafted: "crafted",
3 shop: "shop",
4 gathered: "gathered",
5 gods: "gods",
6 loot: "loot",
7 minted: "minted",
8 ash: "ash",
9 unknown: "unknown"
10});
11
12/** Must match `ItemId.coins` — kept here to avoid a circular import with definitions/items.js. */
13const COINS_ITEM_ID = 8;
14
15export const ROYAL_TREASURY_ORIGIN_LABEL = "Minted by the Royal Treasury";
16
17/** Official coinage origin for every coin stack. */
18export function royalTreasuryOrigin ()
19{
20 return { kind: ItemOriginKind.minted };
21}
22
23/** Gather verbs for origin labels (`Mined by …`, `Felled by …`). */
24export const GatherOriginVerb = Object.freeze({
25 mined: "Mined",
26 felled: "Felled",
27 caught: "Caught",
28 picked: "Picked"
29});
30
31/**
32 * Craft verbs by station (`Forged by …` furnace, `Smithed by …` anvil,
33 * `Carved by …` woodworking, `Assembled by …` crafting bench).
34 */
35export const CraftOriginVerb = Object.freeze({
36 forged: "Forged",
37 smithed: "Smithed",
38 cut: "Cut",
39 carved: "Carved",
40 assembled: "Assembled",
41 made: "Made",
42 ruined: "Ruined",
43 brewed: "Brewed",
44 mixed: "Mixed",
45 written: "Written",
46 issued: "Issued"
47});
48
49/** @type {Readonly<Record<string, string>>} */
50export const CRAFT_ORIGIN_VERB_BY_STATION = Object.freeze({
51 furnace: CraftOriginVerb.forged,
52 anvil: CraftOriginVerb.smithed,
53 "jewelering-station": CraftOriginVerb.cut,
54 "woodworking-bench": CraftOriginVerb.carved,
55 "crafting-bench": CraftOriginVerb.assembled,
56 "spinning-wheel": CraftOriginVerb.made,
57 loom: CraftOriginVerb.made,
58 "tailor-bench": CraftOriginVerb.made
59});
60
61export function craftOriginVerbForStation (stationId)
62{
63 return CRAFT_ORIGIN_VERB_BY_STATION[stationId] ?? CraftOriginVerb.made;
64}
65
66export function originKey (origin)
67{
68 if (!origin)
69 { return "none"; }
70 return JSON.stringify(origin);
71}
72
73export function originLabel (origin, { lowercaseVerb = false } = {})
74{
75 if (!origin)
76 { return "unknown origin"; }
77 if (origin.kind === ItemOriginKind.crafted)
78 {
79 let verb = origin.verb?.trim() || CraftOriginVerb.made;
80 if (lowercaseVerb && verb.length)
81 { verb = verb.charAt(0).toLowerCase() + verb.slice(1); }
82 const name = origin.displayName?.trim() || "someone";
83 return `${verb} by ${name}`;
84 }
85 if (origin.kind === ItemOriginKind.shop)
86 {
87 const name = origin.displayName?.trim() || "a shop";
88 return lowercaseVerb ? `bought from ${name}` : `Bought from ${name}`;
89 }
90 if (origin.kind === ItemOriginKind.gathered)
91 {
92 let verb = origin.verb?.trim() || "Gathered";
93 if (lowercaseVerb && verb.length)
94 { verb = verb.charAt(0).toLowerCase() + verb.slice(1); }
95 const name = origin.displayName?.trim() || "someone";
96 return `${verb} by ${name}`;
97 }
98 if (origin.kind === ItemOriginKind.loot)
99 {
100 const mob = origin.mobName?.trim() || "a creature";
101 const killer = origin.killerName?.trim() || "someone";
102 const label = `Dropped by ${mob}, slain by ${killer}.`;
103 if (!lowercaseVerb)
104 { return label; }
105 return label.charAt(0).toLowerCase() + label.slice(1);
106 }
107 if (origin.kind === ItemOriginKind.ash)
108 {
109 const wood = (origin.woodName?.trim() || "wood").toLowerCase();
110 const name = origin.displayName?.trim() || "someone";
111 const label = `From a ${wood} log burnt by ${name}`;
112 if (!lowercaseVerb)
113 { return label; }
114 return label.charAt(0).toLowerCase() + label.slice(1);
115 }
116 if (origin.kind === ItemOriginKind.gods)
117 { return "Received from the gods"; }
118 if (origin.kind === ItemOriginKind.minted)
119 {
120 return lowercaseVerb
121 ? ROYAL_TREASURY_ORIGIN_LABEL.charAt(0).toLowerCase() + ROYAL_TREASURY_ORIGIN_LABEL.slice(1)
122 : ROYAL_TREASURY_ORIGIN_LABEL;
123 }
124 return "unknown origin";
125}
126
127function originLabelWithQuantity (entry)
128{
129 const label = originLabel(entry.origin, { lowercaseVerb: true });
130 return `${entry.quantity} ${label}`;
131}
132
133/** Build a crafted-item origin (`Forged by Ada`, …). */
134export function craftOrigin (verb, displayName)
135{
136 return {
137 kind: ItemOriginKind.crafted,
138 verb: String(verb ?? CraftOriginVerb.made).trim() || CraftOriginVerb.made,
139 displayName: String(displayName ?? "").trim() || "someone"
140 };
141}
142
143/** Letters / recipe paper: `Written by <signer>`. */
144export function writtenOrigin (displayName)
145{
146 return craftOrigin(CraftOriginVerb.written, displayName);
147}
148
149/** Blank cheques from the bank: `Issued by The Bank`. */
150export function bankIssuedOrigin (displayName = "The Bank")
151{
152 return craftOrigin(CraftOriginVerb.issued, displayName);
153}
154
155/** NPC catalog purchase origin (`Bought from …`). */
156export function shopOrigin (displayName)
157{
158 return {
159 kind: ItemOriginKind.shop,
160 displayName: String(displayName ?? "").trim() || "a shop"
161 };
162}
163
164/** Build a gathered-item origin (`Mined by Ada`, …). */
165export function gatherOrigin (verb, displayName)
166{
167 return {
168 kind: ItemOriginKind.gathered,
169 verb: String(verb ?? "Gathered").trim() || "Gathered",
170 displayName: String(displayName ?? "").trim() || "someone"
171 };
172}
173
174/** Build a mob-drop origin (`Dropped by Rat, slain by Ada.`). */
175export function lootOrigin (mobName, killerName)
176{
177 return {
178 kind: ItemOriginKind.loot,
179 mobName: String(mobName ?? "").trim() || "a creature",
180 killerName: String(killerName ?? "").trim() || "someone"
181 };
182}
183
184/** Campfire ash: `From a pine log burnt by Ada`. */
185export function ashOrigin (woodName, displayName)
186{
187 return {
188 kind: ItemOriginKind.ash,
189 woodName: String(woodName ?? "").trim() || "wood",
190 displayName: String(displayName ?? "").trim() || "someone"
191 };
192}
193
194/** Starter gear granted at character creation. */
195export function godsOrigin ()
196{
197 return { kind: ItemOriginKind.gods };
198}
199
200/** @returns {{ origin: object|null, quantity: number }[]} */
201export function normalizeOrigins (stack)
202{
203 if (!stack)
204 { return []; }
205 const qty = Math.max(0, Math.floor(Number(stack.quantity) || 0));
206 if (qty <= 0)
207 { return []; }
208 // All coinage is royal mint — ignore any other origin metadata on the stack.
209 if ((stack.itemId | 0) === COINS_ITEM_ID)
210 { return [{ origin: royalTreasuryOrigin(), quantity: qty }]; }
211 if (Array.isArray(stack.origins) && stack.origins.length)
212 {
213 return stack.origins.map((entry) => ({
214 origin: entry.origin ?? null,
215 quantity: Math.max(0, Math.floor(Number(entry.quantity) || 0))
216 })).filter((entry) => entry.quantity > 0);
217 }
218 return [{ origin: stack.origin ?? null, quantity: qty }];
219}
220
221export function mergeOriginLists (left, right)
222{
223 const map = new Map();
224 for (const entry of [...normalizeOriginsList(left), ...normalizeOriginsList(right)])
225 {
226 const key = originKey(entry.origin);
227 const prev = map.get(key) ?? { origin: entry.origin ?? null, quantity: 0 };
228 prev.quantity += entry.quantity;
229 map.set(key, prev);
230 }
231 return [...map.values()].filter((entry) => entry.quantity > 0);
232}
233
234function normalizeOriginsList (list)
235{
236 if (!Array.isArray(list))
237 { return []; }
238 return list.map((entry) => ({
239 origin: entry?.origin ?? null,
240 quantity: Math.max(0, Math.floor(Number(entry?.quantity) || 0))
241 })).filter((entry) => entry.quantity > 0);
242}
243
244/** FIFO split of origin quantities when taking from a stack. */
245export function splitOrigins (origins, takeQuantity)
246{
247 const take = Math.max(0, Math.floor(Number(takeQuantity) || 0));
248 const source = normalizeOriginsList(origins);
249 const taken = [];
250 const remain = [];
251 let left = take;
252 for (const entry of source)
253 {
254 if (left <= 0)
255 {
256 remain.push({ ...entry });
257 continue;
258 }
259 const amount = Math.min(entry.quantity, left);
260 if (amount > 0)
261 {
262 taken.push({ origin: entry.origin ?? null, quantity: amount });
263 left -= amount;
264 }
265 const rest = entry.quantity - amount;
266 if (rest > 0)
267 { remain.push({ origin: entry.origin ?? null, quantity: rest }); }
268 }
269 return { taken, remain };
270}
271
272export function attachOrigins (stack)
273{
274 const origins = normalizeOrigins(stack);
275 const next = { ...stack, origins };
276 delete next.origin;
277 return next;
278}
279
280export function formatOriginBreakdown (stack)
281{
282 const origins = normalizeOrigins(stack);
283 if (!origins.length)
284 { return ""; }
285 if (origins.length === 1)
286 { return originLabel(origins[0].origin); }
287 return origins
288 .map((entry) => originLabelWithQuantity(entry))
289 .join("\n");
290}