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