BlueGit

timfa questward

Files

questward / shared / items / origin.js

origin.js

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