BlueGit

timfa questward

Files

questward / shared / items / origin.js

origin.js

origin.js 4.9 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)
55{
56 if (!origin)
57 { return "unknown origin"; }
58 if (origin.kind === ItemOriginKind.crafted)
59 {
60 const verb = origin.verb?.trim() || CraftOriginVerb.made;
61 const name = origin.displayName?.trim() || "someone";
62 return `${verb} by ${name}`;
63 }
64 if (origin.kind === ItemOriginKind.shop)
65 {
66 const name = origin.displayName?.trim() || "a shop";
67 return `Bought from ${name}`;
68 }
69 if (origin.kind === ItemOriginKind.gathered)
70 {
71 const verb = origin.verb?.trim() || "Gathered";
72 const name = origin.displayName?.trim() || "someone";
73 return `${verb} by ${name}`;
74 }
75 if (origin.kind === ItemOriginKind.gods)
76 { return "Received from the gods"; }
77 return "unknown origin";
78}
79
80/** Build a crafted-item origin (`Forged by Ada`, …). */
81export function craftOrigin (verb, displayName)
82{
83 return {
84 kind: ItemOriginKind.crafted,
85 verb: String(verb ?? CraftOriginVerb.made).trim() || CraftOriginVerb.made,
86 displayName: String(displayName ?? "").trim() || "someone"
87 };
88}
89
90/** Build a gathered-item origin (`Mined by Ada`, …). */
91export function gatherOrigin (verb, displayName)
92{
93 return {
94 kind: ItemOriginKind.gathered,
95 verb: String(verb ?? "Gathered").trim() || "Gathered",
96 displayName: String(displayName ?? "").trim() || "someone"
97 };
98}
99
100/** Starter gear granted at character creation. */
101export function godsOrigin ()
102{
103 return { kind: ItemOriginKind.gods };
104}
105
106/** @returns {{ origin: object|null, quantity: number }[]} */
107export function normalizeOrigins (stack)
108{
109 if (!stack)
110 { return []; }
111 const qty = Math.max(0, Math.floor(Number(stack.quantity) || 0));
112 if (Array.isArray(stack.origins) && stack.origins.length)
113 {
114 return stack.origins.map((entry) => ({
115 origin: entry.origin ?? null,
116 quantity: Math.max(0, Math.floor(Number(entry.quantity) || 0))
117 })).filter((entry) => entry.quantity > 0);
118 }
119 if (qty <= 0)
120 { return []; }
121 return [{ origin: stack.origin ?? null, quantity: qty }];
122}
123
124export function mergeOriginLists (left, right)
125{
126 const map = new Map();
127 for (const entry of [...normalizeOriginsList(left), ...normalizeOriginsList(right)])
128 {
129 const key = originKey(entry.origin);
130 const prev = map.get(key) ?? { origin: entry.origin ?? null, quantity: 0 };
131 prev.quantity += entry.quantity;
132 map.set(key, prev);
133 }
134 return [...map.values()].filter((entry) => entry.quantity > 0);
135}
136
137function normalizeOriginsList (list)
138{
139 if (!Array.isArray(list))
140 { return []; }
141 return list.map((entry) => ({
142 origin: entry?.origin ?? null,
143 quantity: Math.max(0, Math.floor(Number(entry?.quantity) || 0))
144 })).filter((entry) => entry.quantity > 0);
145}
146
147/** FIFO split of origin quantities when taking from a stack. */
148export function splitOrigins (origins, takeQuantity)
149{
150 const take = Math.max(0, Math.floor(Number(takeQuantity) || 0));
151 const source = normalizeOriginsList(origins);
152 const taken = [];
153 const remain = [];
154 let left = take;
155 for (const entry of source)
156 {
157 if (left <= 0)
158 {
159 remain.push({ ...entry });
160 continue;
161 }
162 const amount = Math.min(entry.quantity, left);
163 if (amount > 0)
164 {
165 taken.push({ origin: entry.origin ?? null, quantity: amount });
166 left -= amount;
167 }
168 const rest = entry.quantity - amount;
169 if (rest > 0)
170 { remain.push({ origin: entry.origin ?? null, quantity: rest }); }
171 }
172 return { taken, remain };
173}
174
175export function attachOrigins (stack)
176{
177 const origins = normalizeOrigins(stack);
178 const next = { ...stack, origins };
179 delete next.origin;
180 return next;
181}
182
183export function formatOriginBreakdown (stack)
184{
185 const origins = normalizeOrigins(stack);
186 if (!origins.length)
187 { return ""; }
188 return origins
189 .map((entry) => `${entry.quantity} ${originLabel(entry.origin)}`)
190 .join(", ");
191}