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