BlueGit

timfa questward

Files

questward / shared / items / origin.js

origin.js

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