BlueGit

timfa questward

Files

questward / client / src / render / potionIcon.js

potionIcon.js

potionIcon.js 6.2 KiB Download Raw
1import { ItemId, itemDefinition, itemAssetPathForStack } from "/shared/definitions/items.js";
2import { SPRITE_SIZE_PX } from "/shared/protocol/constants.js";
3import { chargeSpriteFrameIndex, itemMaxCharges } from "/shared/items/charges.js";
4import
5 {
6 applyMagentaTintToImageData,
7 applyDualChannelTintToImageData,
8 normalizeRgb,
9 resolveItemTint,
10 resolveItemDualTint
11 } from "/shared/render/tint.js";
12
13const bottleCache = new Map();
14const fillCache = new Map();
15const urlCache = new Map();
16const imageCache = new Map();
17
18function loadImage (src)
19{
20 if (imageCache.has(src))
21 { return imageCache.get(src); }
22 const promise = new Promise((resolve, reject) =>
23 {
24 const img = new Image();
25 img.onload = () => resolve(img);
26 img.onerror = () => reject(new Error(`Failed to load ${src}`));
27 img.src = src;
28 });
29 imageCache.set(src, promise);
30 return promise;
31}
32
33async function getBottle ()
34{
35 if (!bottleCache.has("bottle"))
36 { bottleCache.set("bottle", loadImage("/assets/items/glass-bottle/glass-bottle.png")); }
37 return bottleCache.get("bottle");
38}
39
40async function getFill (level)
41{
42 const key = Math.max(1, Math.min(5, level | 0 || 4));
43 if (!fillCache.has(key))
44 { fillCache.set(key, loadImage(`/assets/items/potion/fill-${key}.png`)); }
45 return fillCache.get(key);
46}
47
48function colorKey (color)
49{
50 const c = normalizeRgb(color);
51 return `${Math.round(c.r * 255)},${Math.round(c.g * 255)},${Math.round(c.b * 255)}`;
52}
53
54/**
55 * Bottle + magenta fill mask → tinted potion icon (UI).
56 * Fill sprites use magenta lightness; bottle stays non-magenta.
57 */
58export async function potionIconDataUrl (instance)
59{
60 const fillLevel = Math.max(1, Math.min(5, instance?.fillLevel | 0 || 4));
61 const tint = normalizeRgb(instance?.color);
62 const key = `potion|${fillLevel}|${colorKey(tint)}`;
63 if (urlCache.has(key))
64 { return urlCache.get(key); }
65
66 const [bottle, fill] = await Promise.all([getBottle(), getFill(fillLevel)]);
67 const canvas = document.createElement("canvas");
68 canvas.width = SPRITE_SIZE_PX;
69 canvas.height = SPRITE_SIZE_PX;
70 const ctx = canvas.getContext("2d");
71 ctx.clearRect(0, 0, canvas.width, canvas.height);
72 ctx.drawImage(fill, 0, 0);
73 const image = ctx.getImageData(0, 0, canvas.width, canvas.height);
74 applyMagentaTintToImageData(image, tint);
75 ctx.putImageData(image, 0, 0);
76 ctx.drawImage(bottle, 0, 0);
77
78 const url = canvas.toDataURL("image/png");
79 urlCache.set(key, url);
80 return url;
81}
82
83/** Tint magenta pixels in an arbitrary item PNG for UI icons. */
84export async function tintedItemIconDataUrl (assetPath, tint)
85{
86 const key = `item|${assetPath}|${colorKey(tint)}`;
87 if (urlCache.has(key))
88 { return urlCache.get(key); }
89 const img = await loadImage(assetPath);
90 const canvas = document.createElement("canvas");
91 canvas.width = img.width || SPRITE_SIZE_PX;
92 canvas.height = img.height || SPRITE_SIZE_PX;
93 const ctx = canvas.getContext("2d");
94 ctx.clearRect(0, 0, canvas.width, canvas.height);
95 ctx.drawImage(img, 0, 0);
96 const image = ctx.getImageData(0, 0, canvas.width, canvas.height);
97 applyMagentaTintToImageData(image, tint);
98 ctx.putImageData(image, 0, 0);
99 const url = canvas.toDataURL("image/png");
100 urlCache.set(key, url);
101 return url;
102}
103
104/** Dual/triple-channel arrow icon (red shaft + blue tip + optional green coat). */
105export async function dualTintedItemIconDataUrl (assetPath, dualTint)
106{
107 const coatKey = dualTint.coat ? colorKey(dualTint.coat) : "-";
108 const key = `dual|${assetPath}|${colorKey(dualTint.shaft)}|${colorKey(dualTint.tip)}|${coatKey}`;
109 if (urlCache.has(key))
110 { return urlCache.get(key); }
111 const img = await loadImage(assetPath);
112 const canvas = document.createElement("canvas");
113 canvas.width = img.width || SPRITE_SIZE_PX;
114 canvas.height = img.height || SPRITE_SIZE_PX;
115 const ctx = canvas.getContext("2d");
116 ctx.clearRect(0, 0, canvas.width, canvas.height);
117 ctx.drawImage(img, 0, 0);
118 const image = ctx.getImageData(0, 0, canvas.width, canvas.height);
119 applyDualChannelTintToImageData(image, dualTint);
120 ctx.putImageData(image, 0, 0);
121 const url = canvas.toDataURL("image/png");
122 urlCache.set(key, url);
123 return url;
124}
125
126/** Crop one frame from a multi-frame item sheet for UI icons. */
127export async function framedItemIconDataUrl (assetPath, frameIndex, framesPerRow = 1, frameCount = 1)
128{
129 const index = Math.max(0, Math.min((frameCount | 0 || 1) - 1, frameIndex | 0));
130 const perRow = Math.max(1, framesPerRow | 0 || 1);
131 const key = `frame|${assetPath}|${index}|${perRow}|${frameCount}`;
132 if (urlCache.has(key))
133 { return urlCache.get(key); }
134 const img = await loadImage(assetPath);
135 const canvas = document.createElement("canvas");
136 canvas.width = SPRITE_SIZE_PX;
137 canvas.height = SPRITE_SIZE_PX;
138 const ctx = canvas.getContext("2d");
139 ctx.imageSmoothingEnabled = false;
140 ctx.clearRect(0, 0, canvas.width, canvas.height);
141 const sx = (index % perRow) * SPRITE_SIZE_PX;
142 const sy = Math.floor(index / perRow) * SPRITE_SIZE_PX;
143 ctx.drawImage(img, sx, sy, SPRITE_SIZE_PX, SPRITE_SIZE_PX, 0, 0, SPRITE_SIZE_PX, SPRITE_SIZE_PX);
144 const url = canvas.toDataURL("image/png");
145 urlCache.set(key, url);
146 return url;
147}
148
149export function isPotionStack (stack)
150{
151 return (stack?.itemId === ItemId.potion && stack.instance?.kind === "potion")
152 || (stack?.itemId === ItemId.dye && stack.instance?.kind === "dye");
153}
154
155/** Set img.src to tinted icon when the stack/def has a tint; else fallback path. */
156export function applyItemIcon (img, stack, fallbackPath)
157{
158 if (!img)
159 { return; }
160 const path = fallbackPath || itemAssetPathForStack(stack);
161 img.src = path;
162 const def = itemDefinition(stack?.itemId);
163 const frames = def?.frames | 0 || 1;
164 if (frames > 1 && itemMaxCharges(def) != null)
165 {
166 const frameIndex = chargeSpriteFrameIndex(stack);
167 framedItemIconDataUrl(path, frameIndex, def.framesPerRow ?? 1, frames).then((url) =>
168 {
169 img.src = url;
170 }).catch(() =>
171 {
172 img.src = path;
173 });
174 return;
175 }
176 const dualTint = def?.iconTintFromTier ? null : resolveItemDualTint(stack, def);
177 if (dualTint)
178 {
179 dualTintedItemIconDataUrl(path, dualTint).then((url) =>
180 {
181 img.src = url;
182 }).catch(() =>
183 {
184 img.src = path;
185 });
186 return;
187 }
188 const tint = resolveItemTint(stack, def);
189 if (!tint)
190 { return; }
191 const work = isPotionStack(stack)
192 ? potionIconDataUrl(stack.instance)
193 : tintedItemIconDataUrl(path, tint);
194 work.then((url) =>
195 {
196 img.src = url;
197 }).catch(() =>
198 {
199 img.src = path;
200 });
201}