| 1 | import { ItemId, itemDefinition, itemAssetPathForStack } from "/shared/definitions/items.js"; |
| 2 | import { SPRITE_SIZE_PX } from "/shared/protocol/constants.js"; |
| 3 | import |
| 4 | { |
| 5 | applyMagentaTintToImageData, |
| 6 | applyDualChannelTintToImageData, |
| 7 | normalizeRgb, |
| 8 | resolveItemTint, |
| 9 | resolveItemDualTint |
| 10 | } from "/shared/render/tint.js"; |
| 11 | |
| 12 | const bottleCache = new Map(); |
| 13 | const fillCache = new Map(); |
| 14 | const urlCache = new Map(); |
| 15 | const imageCache = new Map(); |
| 16 | |
| 17 | function 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 | |
| 32 | async 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 | |
| 39 | async 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 | |
| 47 | function 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 | */ |
| 57 | export 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. */ |
| 83 | export 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). */ |
| 104 | export 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 | |
| 125 | export 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. */ |
| 132 | export 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 | } |