BlueGit

timfa questward

Files

questward / server / src / assets / spriteCatalog.js

spriteCatalog.js

spriteCatalog.js 10.1 KiB Download Raw
1import { readdirSync } from "node:fs";
2import { extname, join } from "node:path";
3import { BLOCK_DEFINITIONS, GROUND_DEFINITIONS } from "../../../shared/definitions/tiles.js";
4import { ITEM_DEFINITIONS } from "../../../shared/definitions/items.js";
5import { MOB_DEFINITIONS } from "../../../shared/definitions/mobs.js";
6import {
7 ORE_BEARING_MATERIALS,
8 oreBoulderState,
9 materialTintColor,
10 WOOD_TIER_ORDER
11} from "../../../shared/definitions/materialTiers.js";
12import {
13 FLOWER_COLOR_ORDER,
14 flowerBlockState,
15 flowerColorRgb
16} from "../../../shared/definitions/dyes.js";
17import {
18 bloomImageName,
19 equipBloomImageName,
20 equipImageName,
21 isCompanionSpriteStem,
22 parseSpriteStem,
23 spriteImageName
24} from "../../../shared/definitions/tileSprites.js";
25import { preferredSeasonalDefaultState, typeHasSeasonalStates, isSeasonalOverlayVariant } from "../../../shared/world/season.js";
26import { composeNeighborConnectState, NEIGHBOR_CONNECT_MASK_COUNT } from "../../../shared/world/neighborConnect.js";
27
28const CHARACTER_DEFINITIONS = Object.freeze({
29 "player-body-male": Object.freeze({ key: "player-body-male", id: "player-body-male" }),
30 "player-body-female": Object.freeze({ key: "player-body-female", id: "player-body-female" })
31});
32
33export function buildSpriteCatalog (assetRoot)
34{
35 const grounds = scanLayer(join(assetRoot, "grounds"), GROUND_DEFINITIONS, "ground", "grounds");
36 const blocks = scanLayer(join(assetRoot, "blocks"), BLOCK_DEFINITIONS, "block", "blocks");
37 const items = scanLayer(join(assetRoot, "items"), itemScanDefs(), "item", "items");
38 const mobs = scanMobLayers(assetRoot);
39 const characters = scanLayer(join(assetRoot, "characters"), CHARACTER_DEFINITIONS, "character", "characters");
40 const fx = scanFx(join(assetRoot, "fx"));
41 return {
42 grounds: grounds.types,
43 blocks: blocks.types,
44 items: items.types,
45 mobs: mobs.types,
46 characters: characters.types,
47 fx: fx.types,
48 images: [
49 ...grounds.images,
50 ...blocks.images,
51 ...items.images,
52 ...mobs.images,
53 ...characters.images,
54 ...fx.images
55 ]
56 };
57}
58
59function itemScanDefs ()
60{
61 const defs = {};
62 for (const def of Object.values(ITEM_DEFINITIONS))
63 {
64 const folderKey = def.iconKey && def.iconKey !== def.key ? def.iconKey : def.key;
65 if (!folderKey || defs[folderKey])
66 { continue; }
67 defs[folderKey] = {
68 key: folderKey,
69 id: def.itemId,
70 frames: def.frames ?? 1,
71 framesPerRow: def.framesPerRow ?? 1,
72 animationSpeed: def.animationSpeed ?? 0
73 };
74 }
75 /** Shared metal armour worn overlays (items/armour/*-equip.png). */
76 if (!defs.armour)
77 {
78 defs.armour = {
79 key: "armour",
80 id: "armour-overlays",
81 frames: 1,
82 framesPerRow: 1,
83 animationSpeed: 0
84 };
85 }
86 return defs;
87}
88
89function mobScanDefs ()
90{
91 const defs = {};
92 for (const def of Object.values(MOB_DEFINITIONS))
93 {
94 if (def.usePlayerBody)
95 { continue; }
96 const key = def.key ?? def.mobTypeId;
97 defs[key] = {
98 key,
99 id: def.mobTypeId,
100 frames: def.frames ?? 1,
101 framesPerRow: def.framesPerRow ?? 1,
102 animationSpeed: def.animationSpeed ?? 0,
103 assetFolder: def.assetFolder ?? "mobs"
104 };
105 }
106 return defs;
107}
108
109function scanMobLayers (assetRoot)
110{
111 const byFolder = new Map();
112 for (const def of Object.values(mobScanDefs()))
113 {
114 const folder = def.assetFolder ?? "mobs";
115 if (!byFolder.has(folder))
116 { byFolder.set(folder, {}); }
117 byFolder.get(folder)[def.key] = def;
118 }
119 const types = {};
120 const images = [];
121 for (const [folder, defs] of byFolder)
122 {
123 const scanned = scanLayer(join(assetRoot, folder), defs, "mob", folder);
124 Object.assign(types, scanned.types);
125 images.push(...scanned.images);
126 }
127 return { types, images };
128}
129
130function scanFx (fxRoot)
131{
132 const types = {};
133 const images = [];
134 let folders;
135 try
136 { folders = readdirSync(fxRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()); }
137 catch (error)
138 {
139 if (error.code === "ENOENT")
140 { return { types, images }; }
141 throw error;
142 }
143 for (const entry of folders)
144 {
145 const key = entry.name;
146 const defs = {
147 [key]: { key, id: key, frames: 1, framesPerRow: 1, animationSpeed: 0 }
148 };
149 const scanned = scanLayer(fxRoot, defs, "fx", "fx");
150 Object.assign(types, scanned.types);
151 images.push(...scanned.images);
152 }
153 return { types, images };
154}
155
156function scanLayer (layerDir, definitions, layer, urlFolder)
157{
158 const types = {};
159 const images = [];
160 for (const def of Object.values(definitions))
161 {
162 const folder = join(layerDir, def.key);
163 const { states: fileStates, blooms, equips, equipBlooms } = listVisualStates(folder);
164 if (fileStates.length === 0)
165 { throw new Error(`No PNG states in ${folder}`); }
166
167 const frames = Math.max(1, def.frames ?? 1);
168 const framesPerRow = Math.max(1, def.framesPerRow ?? 1);
169 const animationSpeed = Math.max(0, def.animationSpeed ?? 0);
170 let states = [...fileStates];
171 const imagesForType = [];
172
173 if (layer === "block" && def.key === "boulder")
174 {
175 states = states.filter((state) => state !== "boulder-ore" && state !== "boulder-ore-winter");
176 if (!states.includes("boulder"))
177 { states.unshift("boulder"); }
178 for (const material of ORE_BEARING_MATERIALS)
179 {
180 const state = oreBoulderState(material);
181 if (!states.includes(state))
182 { states.push(state); }
183 const tint = materialTintColor(material, { ore: true });
184 imagesForType.push({
185 name: spriteImageName(layer, def.key, state),
186 url: `/assets/${urlFolder}/${def.key}/boulder-ore.png`,
187 subImgTotal: frames,
188 perRow: framesPerRow,
189 loop: animationSpeed > 0,
190 animationSpeed,
191 tint: { r: tint.r, g: tint.g, b: tint.b }
192 });
193 const winterState = `${state}-winter`;
194 if (!states.includes(winterState))
195 { states.push(winterState); }
196 imagesForType.push({
197 name: spriteImageName(layer, def.key, winterState),
198 url: `/assets/${urlFolder}/${def.key}/boulder-ore-winter.png`,
199 subImgTotal: frames,
200 perRow: framesPerRow,
201 loop: animationSpeed > 0,
202 animationSpeed,
203 tint: { r: tint.r, g: tint.g, b: tint.b }
204 });
205 }
206 }
207
208 if (layer === "block" && def.key === "flower")
209 {
210 states = [];
211 for (const colorId of FLOWER_COLOR_ORDER)
212 {
213 const state = flowerBlockState(colorId);
214 states.push(state);
215 const tint = flowerColorRgb(colorId);
216 imagesForType.push({
217 name: spriteImageName(layer, def.key, state),
218 url: `/assets/${urlFolder}/${def.key}/flower.png`,
219 subImgTotal: frames,
220 perRow: framesPerRow,
221 loop: animationSpeed > 0,
222 animationSpeed,
223 tint: { r: tint.r, g: tint.g, b: tint.b }
224 });
225 }
226 }
227
228 if (layer === "block" && def.key === "table")
229 {
230 // Magenta mask sources `0`–`15` (+ optional artist `wood`); expand per wood tier.
231 states = [];
232 for (const material of WOOD_TIER_ORDER)
233 {
234 for (let mask = 0; mask < NEIGHBOR_CONNECT_MASK_COUNT; mask++)
235 {
236 const state = composeNeighborConnectState(def, material, mask);
237 states.push(state);
238 const tint = materialTintColor(material);
239 imagesForType.push({
240 name: spriteImageName(layer, def.key, state),
241 url: `/assets/${urlFolder}/${def.key}/${mask}.png`,
242 subImgTotal: frames,
243 perRow: framesPerRow,
244 loop: animationSpeed > 0,
245 animationSpeed,
246 tint: { r: tint.r, g: tint.g, b: tint.b }
247 });
248 }
249 }
250 }
251
252 types[def.key] = {
253 key: def.key,
254 typeId: def.id,
255 states,
256 defaultState: def.key === "boulder" && states.includes("boulder")
257 ? "boulder"
258 : (def.outdoor && preferredSeasonalDefaultState(states)) || states[0],
259 blooms,
260 equips,
261 equipBlooms,
262 frames,
263 framesPerRow,
264 animationSpeed,
265 outdoor: !!def.outdoor,
266 /** Calendar-driven only when outdoor and summer/fall/winter states exist. */
267 seasonal: !!def.outdoor && typeHasSeasonalStates(states)
268 };
269 for (const state of states)
270 {
271 if (imagesForType.some((entry) => entry.name === spriteImageName(layer, def.key, state)))
272 { continue; }
273 /** Seasonal overlays (e.g. frozen water-winter) are static single-frame sprites. */
274 const overlay = isSeasonalOverlayVariant(state);
275 const sheet = {
276 subImgTotal: overlay ? 1 : frames,
277 perRow: overlay ? 1 : framesPerRow,
278 loop: !overlay && animationSpeed > 0,
279 animationSpeed: overlay ? 0 : animationSpeed
280 };
281 images.push({
282 name: spriteImageName(layer, def.key, state),
283 url: `/assets/${urlFolder}/${def.key}/${state}.png`,
284 ...sheet
285 });
286 if (blooms[state])
287 {
288 images.push({
289 name: bloomImageName(layer, def.key, state),
290 url: `/assets/${urlFolder}/${def.key}/${state}-bloom.png`,
291 ...sheet
292 });
293 }
294 if (equips[state])
295 {
296 images.push({
297 name: equipImageName(layer, def.key, state),
298 url: `/assets/${urlFolder}/${def.key}/${state}-equip.png`,
299 ...sheet
300 });
301 }
302 if (equipBlooms[state])
303 {
304 images.push({
305 name: equipBloomImageName(layer, def.key, state),
306 url: `/assets/${urlFolder}/${def.key}/${state}-equip-bloom.png`,
307 ...sheet
308 });
309 }
310 }
311 images.push(...imagesForType);
312 }
313 return { types, images };
314}
315
316function listVisualStates (folder)
317{
318 const stems = listPngStems(folder);
319 const blooms = {};
320 const equips = {};
321 const equipBlooms = {};
322 const states = [];
323 for (const stem of stems)
324 {
325 const parsed = parseSpriteStem(stem);
326 if (parsed.companion)
327 {
328 if (!parsed.base)
329 { continue; }
330 if (parsed.equip && parsed.bloom)
331 { equipBlooms[parsed.base] = true; }
332 else if (parsed.equip)
333 { equips[parsed.base] = true; }
334 else if (parsed.bloom)
335 { blooms[parsed.base] = true; }
336 continue;
337 }
338 if (isCompanionSpriteStem(stem))
339 { continue; }
340 states.push(stem);
341 }
342 const filterMap = (map) =>
343 {
344 const next = {};
345 for (const state of states)
346 {
347 if (map[state])
348 { next[state] = true; }
349 }
350 return next;
351 };
352 return {
353 states,
354 blooms: filterMap(blooms),
355 equips: filterMap(equips),
356 equipBlooms: filterMap(equipBlooms)
357 };
358}
359
360function listPngStems (folder)
361{
362 let entries;
363 try
364 { entries = readdirSync(folder, { withFileTypes: true }); }
365 catch (error)
366 {
367 if (error.code === "ENOENT")
368 { return []; }
369 throw error;
370 }
371
372 return entries
373 .filter((entry) => entry.isFile() && extname(entry.name).toLowerCase() === ".png")
374 .map((entry) => entry.name.slice(0, -extname(entry.name).length))
375 .sort((a, b) => a.localeCompare(b, "en", { numeric: true, sensitivity: "base" }));
376}