| 1 | import { ItemId, itemDefinition, itemAssetPathForStack } from "/shared/definitions/items.js"; |
| 2 | import { SPRITE_SIZE_PX } from "/shared/protocol/constants.js"; |
| 3 | import { chargeSpriteFrameIndex, itemMaxCharges } from "/shared/items/charges.js"; |
| 4 | import |
| 5 | { |
| 6 | applyMagentaTintToImageData, |
| 7 | applyDualChannelTintToImageData, |
| 8 | normalizeRgb, |
| 9 | resolveItemTint, |
| 10 | resolveItemDualTint |
| 11 | } from "/shared/render/tint.js"; |
| 12 | |
| 13 | const bottleCache = new Map(); |
| 14 | const fillCache = new Map(); |
| 15 | const urlCache = new Map(); |
| 16 | const imageCache = new Map(); |
| 17 | |
| 18 | function 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 | |
| 33 | async 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 | |
| 40 | async 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 | |
| 48 | function 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 | */ |
| 58 | export 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. */ |
| 84 | export 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). */ |
| 105 | export 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. */ |
| 127 | export 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 | |
| 149 | export 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. */ |
| 156 | export 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 | } |