BlueGit

timfa questward

Files

questward / client / src / render / potionIcon.js

potionIcon.js

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