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