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