BlueGit

timfa questward

Files

questward / shared / items / origin.js

origin.js

origin.js 5.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 unknown: "unknown"
8});
9
10/** Gather verbs for origin labels (`Mined by …`, `Felled by …`). */
11export const GatherOriginVerb = Object.freeze({
12 mined: "Mined",
13 felled: "Felled",
14 caught: "Caught",
15 picked: "Picked"
16});
17
18/**
19 * Craft verbs by station (`Forged by …` furnace, `Smithed by …` anvil,
20 * `Carved by …` woodworking, `Assembled by …` crafting bench).
21 */
22export const CraftOriginVerb = Object.freeze({
23 forged: "Forged",
24 smithed: "Smithed",
25 carved: "Carved",
26 assembled: "Assembled",
27 made: "Made",
28 brewed: "Brewed",
29 mixed: "Mixed"
30});
31
32/** @type {Readonly<Record<string, string>>} */
33export const CRAFT_ORIGIN_VERB_BY_STATION = Object.freeze({
34 furnace: CraftOriginVerb.forged,
35 anvil: CraftOriginVerb.smithed,
36 "woodworking-bench": CraftOriginVerb.carved,
37 "crafting-bench": CraftOriginVerb.assembled,
38 "spinning-wheel": CraftOriginVerb.made,
39 loom: CraftOriginVerb.made,
40 "tailor-bench": CraftOriginVerb.made
41});
42
43export function craftOriginVerbForStation (stationId)
44{
45 return CRAFT_ORIGIN_VERB_BY_STATION[stationId] ?? CraftOriginVerb.made;
46}
47
48export function originKey (origin)
49{
50 if (!origin)
51 { return "none"; }
52 return JSON.stringify(origin);
53}
54
55export function originLabel (origin, { lowercaseVerb = false } = {})
56{
57 if (!origin)
58 { return "unknown origin"; }
59 if (origin.kind === ItemOriginKind.crafted)
60 {
61 let verb = origin.verb?.trim() || CraftOriginVerb.made;
62 if (lowercaseVerb && verb.length)
63 { verb = verb.charAt(0).toLowerCase() + verb.slice(1); }
64 const name = origin.displayName?.trim() || "someone";
65 return `${verb} by ${name}`;
66 }
67 if (origin.kind === ItemOriginKind.shop)
68 {
69 const name = origin.displayName?.trim() || "a shop";
70 return lowercaseVerb ? `bought from ${name}` : `Bought from ${name}`;
71 }
72 if (origin.kind === ItemOriginKind.gathered)
73 {
74 let verb = origin.verb?.trim() || "Gathered";
75 if (lowercaseVerb && verb.length)
76 { verb = verb.charAt(0).toLowerCase() + verb.slice(1); }
77 const name = origin.displayName?.trim() || "someone";
78 return `${verb} by ${name}`;
79 }
80 if (origin.kind === ItemOriginKind.loot)
81 {
82 const mob = origin.mobName?.trim() || "a creature";
83 const killer = origin.killerName?.trim() || "someone";
84 const label = `Dropped by ${mob}, slain by ${killer}.`;
85 if (!lowercaseVerb)
86 { return label; }
87 return label.charAt(0).toLowerCase() + label.slice(1);
88 }
89 if (origin.kind === ItemOriginKind.gods)
90 { return "Received from the gods"; }
91 return "unknown origin";
92}
93
94function originLabelWithQuantity (entry)
95{
96 const label = originLabel(entry.origin, { lowercaseVerb: true });
97 return `${entry.quantity} ${label}`;
98}
99
100/** Build a crafted-item origin (`Forged by Ada`, …). */
101export function craftOrigin (verb, displayName)
102{
103 return {
104 kind: ItemOriginKind.crafted,
105 verb: String(verb ?? CraftOriginVerb.made).trim() || CraftOriginVerb.made,
106 displayName: String(displayName ?? "").trim() || "someone"
107 };
108}
109
110/** Build a gathered-item origin (`Mined by Ada`, …). */
111export function gatherOrigin (verb, displayName)
112{
113 return {
114 kind: ItemOriginKind.gathered,
115 verb: String(verb ?? "Gathered").trim() || "Gathered",
116 displayName: String(displayName ?? "").trim() || "someone"
117 };
118}
119
120/** Build a mob-drop origin (`Dropped by Rat, slain by Ada.`). */
121export function lootOrigin (mobName, killerName)
122{
123 return {
124 kind: ItemOriginKind.loot,
125 mobName: String(mobName ?? "").trim() || "a creature",
126 killerName: String(killerName ?? "").trim() || "someone"
127 };
128}
129
130/** Starter gear granted at character creation. */
131export function godsOrigin ()
132{
133 return { kind: ItemOriginKind.gods };
134}
135
136/** @returns {{ origin: object|null, quantity: number }[]} */
137export function normalizeOrigins (stack)
138{
139 if (!stack)
140 { return []; }
141 const qty = Math.max(0, Math.floor(Number(stack.quantity) || 0));
142 if (Array.isArray(stack.origins) && stack.origins.length)
143 {
144 return stack.origins.map((entry) => ({
145 origin: entry.origin ?? null,
146 quantity: Math.max(0, Math.floor(Number(entry.quantity) || 0))
147 })).filter((entry) => entry.quantity > 0);
148 }
149 if (qty <= 0)
150 { return []; }
151 return [{ origin: stack.origin ?? null, quantity: qty }];
152}
153
154export function mergeOriginLists (left, right)
155{
156 const map = new Map();
157 for (const entry of [...normalizeOriginsList(left), ...normalizeOriginsList(right)])
158 {
159 const key = originKey(entry.origin);
160 const prev = map.get(key) ?? { origin: entry.origin ?? null, quantity: 0 };
161 prev.quantity += entry.quantity;
162 map.set(key, prev);
163 }
164 return [...map.values()].filter((entry) => entry.quantity > 0);
165}
166
167function normalizeOriginsList (list)
168{
169 if (!Array.isArray(list))
170 { return []; }
171 return list.map((entry) => ({
172 origin: entry?.origin ?? null,
173 quantity: Math.max(0, Math.floor(Number(entry?.quantity) || 0))
174 })).filter((entry) => entry.quantity > 0);
175}
176
177/** FIFO split of origin quantities when taking from a stack. */
178export function splitOrigins (origins, takeQuantity)
179{
180 const take = Math.max(0, Math.floor(Number(takeQuantity) || 0));
181 const source = normalizeOriginsList(origins);
182 const taken = [];
183 const remain = [];
184 let left = take;
185 for (const entry of source)
186 {
187 if (left <= 0)
188 {
189 remain.push({ ...entry });
190 continue;
191 }
192 const amount = Math.min(entry.quantity, left);
193 if (amount > 0)
194 {
195 taken.push({ origin: entry.origin ?? null, quantity: amount });
196 left -= amount;
197 }
198 const rest = entry.quantity - amount;
199 if (rest > 0)
200 { remain.push({ origin: entry.origin ?? null, quantity: rest }); }
201 }
202 return { taken, remain };
203}
204
205export function attachOrigins (stack)
206{
207 const origins = normalizeOrigins(stack);
208 const next = { ...stack, origins };
209 delete next.origin;
210 return next;
211}
212
213export function formatOriginBreakdown (stack)
214{
215 const origins = normalizeOrigins(stack);
216 if (!origins.length)
217 { return ""; }
218 if (origins.length === 1)
219 { return originLabel(origins[0].origin); }
220 return origins
221 .map((entry) => originLabelWithQuantity(entry))
222 .join("\n");
223}