BlueGit

timfa questward

Files

questward / shared / items / origin.js

origin.js

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