BlueGit

timfa questward

Files

questward / shared / items / origin.js

origin.js

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