BlueGit

timfa questward

Files

questward / shared / items / origin.js

origin.js

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