| 1 | import { ItemId, itemDefinition, itemAssetPathForStack } from "/shared/definitions/items.js"; |
| 2 | import { SPRITE_SIZE_PX } from "/shared/protocol/constants.js"; |
| 3 | import { |
| 4 | applyMagentaTintToImageData, |
| 5 | applyDualChannelTintToImageData, |
| 6 | normalizeRgb, |
| 7 | resolveItemTint, |
| 8 | resolveItemDualTint |
| 9 | } from "/shared/render/tint.js"; |
| 10 | |
| 11 | const bottleCache = new Map(); |
| 12 | const fillCache = new Map(); |
| 13 | const urlCache = new Map(); |
| 14 | const imageCache = new Map(); |
| 15 | |
| 16 | function 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 | |
| 31 | async 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 | |
| 38 | async 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 | |
| 46 | function 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 | */ |
| 56 | export 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. */ |
| 82 | export 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). */ |
| 103 | export 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 | |
| 124 | export 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. */ |
| 131 | export 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 | } |