BlueGit

timfa questward

Files

questward / server / src / assets / spriteCatalog.js

spriteCatalog.js

spriteCatalog.js 15.0 KiB Download Raw
1import { readdirSync } from "node:fs";
2import { extname, join } from "node:path";
3import { BLOCK_DEFINITIONS, GROUND_DEFINITIONS, BlockType } from "../../../shared/definitions/tiles.js";
4import { ITEM_DEFINITIONS } from "../../../shared/definitions/items.js";
5import { MOB_DEFINITIONS } from "../../../shared/definitions/mobs.js";
6import { HERB_ORDER } from "../../../shared/definitions/herbs.js";
7import
8 {
9 ORE_BEARING_MATERIALS,
10 oreBoulderState,
11 materialTintColor,
12 WOOD_TIER_ORDER
13 } from "../../../shared/definitions/materialTiers.js";
14import
15 {
16 FLOWER_COLOR_ORDER,
17 flowerBlockState,
18 flowerColorRgb
19 } from "../../../shared/definitions/dyes.js";
20import
21 {
22 bloomImageName,
23 equipBloomImageName,
24 equipImageName,
25 isCompanionSpriteStem,
26 parseSpriteStem,
27 palettePreviewImageName,
28 spriteImageName
29 } from "../../../shared/definitions/tileSprites.js";
30import { preferredSeasonalDefaultState, typeHasSeasonalStates, isSeasonalOverlayVariant } from "../../../shared/world/season.js";
31import { composeNeighborConnectState, NEIGHBOR_CONNECT_MASK_COUNT, definitionUsesMaterialNeighborConnect } from "../../../shared/world/neighborConnect.js";
32
33const CHARACTER_DEFINITIONS = Object.freeze({
34 "player-body-male": Object.freeze({ key: "player-body-male", id: "player-body-male" }),
35 "player-body-female": Object.freeze({ key: "player-body-female", id: "player-body-female" })
36});
37
38export function buildSpriteCatalog (assetRoot)
39{
40 const blockDefs = Object.fromEntries(
41 Object.entries(BLOCK_DEFINITIONS).filter(([, def]) => def.key !== "herb")
42 );
43 const grounds = scanLayer(join(assetRoot, "grounds"), GROUND_DEFINITIONS, "ground", "grounds");
44 const blocks = scanLayer(join(assetRoot, "blocks"), blockDefs, "block", "blocks");
45 const items = scanLayer(join(assetRoot, "items"), itemScanDefs(), "item", "items");
46 const herbs = scanHerbAssets(join(assetRoot, "herbs"));
47 Object.assign(blocks.types, herbs.blockTypes);
48 Object.assign(items.types, herbs.itemTypes);
49 const mobs = scanMobLayers(assetRoot);
50 const characters = scanLayer(join(assetRoot, "characters"), CHARACTER_DEFINITIONS, "character", "characters");
51 const fx = scanFx(join(assetRoot, "fx"));
52 return {
53 grounds: grounds.types,
54 blocks: blocks.types,
55 items: items.types,
56 mobs: mobs.types,
57 characters: characters.types,
58 fx: fx.types,
59 images: [
60 ...grounds.images,
61 ...blocks.images,
62 ...items.images,
63 ...herbs.images,
64 ...mobs.images,
65 ...characters.images,
66 ...fx.images
67 ]
68 };
69}
70
71/**
72 * Shared `assets/herbs/<herbId>.png` — registered as both world block states and item icons.
73 */
74function scanHerbAssets (herbRoot)
75{
76 const stems = new Set(listPngStems(herbRoot));
77 const missing = HERB_ORDER.filter((id) => !stems.has(id));
78 if (missing.length)
79 { throw new Error(`Missing herb sprites in ${herbRoot}: ${missing.join(", ")}`); }
80
81 const images = [];
82 for (const herbId of HERB_ORDER)
83 {
84 const url = `/assets/herbs/${herbId}.png`;
85 images.push({
86 name: spriteImageName("block", "herb", herbId),
87 url,
88 subImgTotal: 1,
89 perRow: 1,
90 loop: false,
91 animationSpeed: 0
92 });
93 images.push({
94 name: spriteImageName("item", "herbs", herbId),
95 url,
96 subImgTotal: 1,
97 perRow: 1,
98 loop: false,
99 animationSpeed: 0
100 });
101 }
102
103 const blockTypes = {
104 herb: {
105 key: "herb",
106 typeId: BlockType.herbPlant,
107 states: [...HERB_ORDER],
108 defaultState: HERB_ORDER[0],
109 blooms: {},
110 equips: {},
111 equipBlooms: {},
112 frames: 1,
113 framesPerRow: 1,
114 animationSpeed: 0,
115 outdoor: true,
116 seasonal: false
117 }
118 };
119 const itemTypes = {
120 herbs: {
121 key: "herbs",
122 typeId: "herbs",
123 states: [...HERB_ORDER],
124 defaultState: HERB_ORDER[0],
125 blooms: {},
126 equips: {},
127 equipBlooms: {},
128 frames: 1,
129 framesPerRow: 1,
130 animationSpeed: 0,
131 outdoor: false,
132 seasonal: false
133 }
134 };
135 return { images, blockTypes, itemTypes };
136}
137
138function itemScanDefs ()
139{
140 const defs = {};
141 for (const def of Object.values(ITEM_DEFINITIONS))
142 {
143 if (def?.herb)
144 { continue; }
145 const folderKey = def.iconKey && def.iconKey !== def.key ? def.iconKey : def.key;
146 if (!folderKey || defs[folderKey])
147 { continue; }
148 defs[folderKey] = {
149 key: folderKey,
150 id: def.itemId,
151 frames: def.frames ?? 1,
152 framesPerRow: def.framesPerRow ?? 1,
153 animationSpeed: def.animationSpeed ?? 0
154 };
155 }
156 /** Shared metal armour worn overlays (items/armour/*-equip.png). */
157 if (!defs.armour)
158 {
159 defs.armour = {
160 key: "armour",
161 id: "armour-overlays",
162 frames: 1,
163 framesPerRow: 1,
164 animationSpeed: 0
165 };
166 }
167 return defs;
168}
169
170function mobScanDefs ()
171{
172 const defs = {};
173 for (const def of Object.values(MOB_DEFINITIONS))
174 {
175 if (def.usePlayerBody)
176 { continue; }
177 // spriteKey reuses another mob's art folder when set.
178 const key = def.spriteKey ?? def.key ?? def.mobTypeId;
179 if (defs[key])
180 { continue; }
181 defs[key] = {
182 key,
183 id: def.mobTypeId,
184 frames: def.frames ?? 1,
185 framesPerRow: def.framesPerRow ?? 1,
186 animationSpeed: def.animationSpeed ?? 0,
187 bloomFrames: def.bloomFrames ?? null,
188 bloomFramesPerRow: def.bloomFramesPerRow ?? null,
189 bloomAnimationSpeed: def.bloomAnimationSpeed ?? null,
190 assetFolder: def.assetFolder ?? "mobs"
191 };
192 }
193 return defs;
194}
195
196function scanMobLayers (assetRoot)
197{
198 const byFolder = new Map();
199 for (const def of Object.values(mobScanDefs()))
200 {
201 const folder = def.assetFolder ?? "mobs";
202 if (!byFolder.has(folder))
203 { byFolder.set(folder, {}); }
204 byFolder.get(folder)[def.key] = def;
205 }
206 const types = {};
207 const images = [];
208 for (const [folder, defs] of byFolder)
209 {
210 const scanned = scanLayer(join(assetRoot, folder), defs, "mob", folder);
211 Object.assign(types, scanned.types);
212 images.push(...scanned.images);
213 }
214 return { types, images };
215}
216
217function scanFx (fxRoot)
218{
219 const types = {};
220 const images = [];
221 let folders;
222 try
223 { folders = readdirSync(fxRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()); }
224 catch (error)
225 {
226 if (error.code === "ENOENT")
227 { return { types, images }; }
228 throw error;
229 }
230 for (const entry of folders)
231 {
232 const key = entry.name;
233 const defs = {
234 [key]: { key, id: key, frames: 1, framesPerRow: 1, animationSpeed: 0 }
235 };
236 const scanned = scanLayer(fxRoot, defs, "fx", "fx");
237 Object.assign(types, scanned.types);
238 images.push(...scanned.images);
239 }
240 return { types, images };
241}
242
243function scanLayer (layerDir, definitions, layer, urlFolder)
244{
245 const types = {};
246 const images = [];
247 for (const def of Object.values(definitions))
248 {
249 const folder = join(layerDir, def.key);
250 const { states: fileStates, blooms: fileBlooms, equips, equipBlooms, previews } = listVisualStates(folder);
251 if (fileStates.length === 0)
252 { throw new Error(`No PNG states in ${folder}`); }
253
254 const frames = Math.max(1, def.frames ?? 1);
255 const framesPerRow = Math.max(1, def.framesPerRow ?? 1);
256 const animationSpeed = Math.max(0, def.animationSpeed ?? 0);
257 let states = [...fileStates];
258 let blooms = fileBlooms;
259 const imagesForType = [];
260
261 if (layer === "block" && def.key === "boulder")
262 {
263 states = states.filter((state) => state !== "boulder-ore" && state !== "boulder-ore-winter");
264 if (!states.includes("boulder"))
265 { states.unshift("boulder"); }
266 for (const material of ORE_BEARING_MATERIALS)
267 {
268 const state = oreBoulderState(material);
269 if (!states.includes(state))
270 { states.push(state); }
271 const tint = materialTintColor(material, { ore: true });
272 imagesForType.push({
273 name: spriteImageName(layer, def.key, state),
274 url: `/assets/${urlFolder}/${def.key}/boulder-ore.png`,
275 subImgTotal: frames,
276 perRow: framesPerRow,
277 loop: animationSpeed > 0,
278 animationSpeed,
279 tint: { r: tint.r, g: tint.g, b: tint.b }
280 });
281 const winterState = `${state}-winter`;
282 if (!states.includes(winterState))
283 { states.push(winterState); }
284 imagesForType.push({
285 name: spriteImageName(layer, def.key, winterState),
286 url: `/assets/${urlFolder}/${def.key}/boulder-ore-winter.png`,
287 subImgTotal: frames,
288 perRow: framesPerRow,
289 loop: animationSpeed > 0,
290 animationSpeed,
291 tint: { r: tint.r, g: tint.g, b: tint.b }
292 });
293 }
294 }
295
296 if (layer === "block" && def.key === "flower")
297 {
298 states = [];
299 for (const colorId of FLOWER_COLOR_ORDER)
300 {
301 const state = flowerBlockState(colorId);
302 states.push(state);
303 const tint = flowerColorRgb(colorId);
304 imagesForType.push({
305 name: spriteImageName(layer, def.key, state),
306 url: `/assets/${urlFolder}/${def.key}/flower.png`,
307 subImgTotal: frames,
308 perRow: framesPerRow,
309 loop: animationSpeed > 0,
310 animationSpeed,
311 tint: { r: tint.r, g: tint.g, b: tint.b }
312 });
313 }
314 }
315
316 if (layer === "block" && def.key === "campfire")
317 {
318 states = [];
319 const nextBlooms = {};
320 for (const material of WOOD_TIER_ORDER)
321 {
322 states.push(material);
323 const tint = materialTintColor(material);
324 imagesForType.push({
325 name: spriteImageName(layer, def.key, material),
326 url: `/assets/${urlFolder}/${def.key}/campfire.png`,
327 subImgTotal: frames,
328 perRow: framesPerRow,
329 loop: animationSpeed > 0,
330 animationSpeed,
331 tint: { r: tint.r, g: tint.g, b: tint.b }
332 });
333 imagesForType.push({
334 name: bloomImageName(layer, def.key, material),
335 url: `/assets/${urlFolder}/${def.key}/campfire-bloom.png`,
336 subImgTotal: frames,
337 perRow: framesPerRow,
338 loop: animationSpeed > 0,
339 animationSpeed
340 });
341 nextBlooms[material] = true;
342 }
343 blooms = nextBlooms;
344 }
345
346 if (layer === "block" && def.door)
347 {
348 states = [];
349 for (const material of WOOD_TIER_ORDER)
350 {
351 for (const facing of ["n", "s"])
352 {
353 for (const openness of ["closed", "open"])
354 {
355 const state = `${material}-${facing}-${openness}`;
356 states.push(state);
357 const tint = materialTintColor(material);
358 imagesForType.push({
359 name: spriteImageName(layer, def.key, state),
360 url: `/assets/${urlFolder}/${def.key}/door-${facing}-${openness}.png`,
361 subImgTotal: frames,
362 perRow: framesPerRow,
363 loop: animationSpeed > 0,
364 animationSpeed,
365 tint: { r: tint.r, g: tint.g, b: tint.b }
366 });
367 }
368 }
369 }
370 }
371
372 if (layer === "block" && definitionUsesMaterialNeighborConnect(def))
373 {
374 // Magenta mask sources `0`–`15`; expand per wood tier (`pine-0` …).
375 states = [];
376 for (const material of WOOD_TIER_ORDER)
377 {
378 for (let mask = 0; mask < NEIGHBOR_CONNECT_MASK_COUNT; mask++)
379 {
380 const state = composeNeighborConnectState(def, material, mask);
381 states.push(state);
382 const tint = materialTintColor(material);
383 imagesForType.push({
384 name: spriteImageName(layer, def.key, state),
385 url: `/assets/${urlFolder}/${def.key}/${mask}.png`,
386 subImgTotal: frames,
387 perRow: framesPerRow,
388 loop: animationSpeed > 0,
389 animationSpeed,
390 tint: { r: tint.r, g: tint.g, b: tint.b }
391 });
392 }
393 }
394 }
395
396 types[def.key] = {
397 key: def.key,
398 typeId: def.id,
399 states,
400 defaultState: def.key === "boulder" && states.includes("boulder")
401 ? "boulder"
402 : def.key === "fishing-spot" && states.includes("fishing-spot")
403 ? "fishing-spot"
404 : def.door && states.includes("pine-s-closed")
405 ? "pine-s-closed"
406 : def.key === "sand" && states.includes("sand")
407 ? "sand"
408 : (def.outdoor && preferredSeasonalDefaultState(states)) || states[0],
409 blooms,
410 equips,
411 equipBlooms,
412 frames,
413 framesPerRow,
414 animationSpeed,
415 outdoor: !!def.outdoor,
416 /** Calendar-driven only when outdoor and summer/fall/winter states exist. */
417 seasonal: !!def.outdoor && typeHasSeasonalStates(states)
418 };
419 for (const state of states)
420 {
421 if (imagesForType.some((entry) => entry.name === spriteImageName(layer, def.key, state)))
422 { continue; }
423 /** Seasonal overlays (e.g. frozen water-winter) are static single-frame sprites. */
424 const overlay = isSeasonalOverlayVariant(state);
425 const sheet = {
426 subImgTotal: overlay ? 1 : frames,
427 perRow: overlay ? 1 : framesPerRow,
428 loop: !overlay && animationSpeed > 0,
429 animationSpeed: overlay ? 0 : animationSpeed
430 };
431 images.push({
432 name: spriteImageName(layer, def.key, state),
433 url: `/assets/${urlFolder}/${def.key}/${state}.png`,
434 ...sheet
435 });
436 if (blooms[state])
437 {
438 const bloomFrames = Math.max(1, def.bloomFrames ?? frames);
439 const bloomPerRow = Math.max(1, def.bloomFramesPerRow ?? framesPerRow);
440 const bloomSpeed = Math.max(0, def.bloomAnimationSpeed ?? animationSpeed);
441 images.push({
442 name: bloomImageName(layer, def.key, state),
443 url: `/assets/${urlFolder}/${def.key}/${state}-bloom.png`,
444 subImgTotal: bloomFrames,
445 perRow: bloomPerRow,
446 loop: bloomSpeed > 0,
447 animationSpeed: bloomSpeed
448 });
449 }
450 /** Worn/gather overlays are always single-frame (inventory sheets may differ). */
451 const equipSheet = {
452 subImgTotal: 1,
453 perRow: 1,
454 loop: false,
455 animationSpeed: 0
456 };
457 if (equips[state])
458 {
459 images.push({
460 name: equipImageName(layer, def.key, state),
461 url: `/assets/${urlFolder}/${def.key}/${state}-equip.png`,
462 ...equipSheet
463 });
464 }
465 if (equipBlooms[state])
466 {
467 images.push({
468 name: equipBloomImageName(layer, def.key, state),
469 url: `/assets/${urlFolder}/${def.key}/${state}-equip-bloom.png`,
470 ...equipSheet
471 });
472 }
473 }
474 const previewStem = previews?.[def.key];
475 if (previewStem)
476 {
477 images.push({
478 name: palettePreviewImageName(layer, def.key),
479 url: `/assets/${urlFolder}/${def.key}/${previewStem}.png`,
480 subImgTotal: 1,
481 perRow: 1,
482 loop: false,
483 animationSpeed: 0
484 });
485 }
486 images.push(...imagesForType);
487 }
488 return { types, images };
489}
490
491function listVisualStates (folder)
492{
493 const stems = listPngStems(folder);
494 const blooms = {};
495 const equips = {};
496 const equipBlooms = {};
497 const previews = {};
498 const states = [];
499 for (const stem of stems)
500 {
501 const parsed = parseSpriteStem(stem);
502 if (parsed.companion)
503 {
504 if (!parsed.base)
505 { continue; }
506 if (parsed.preview)
507 { previews[parsed.base] = stem; }
508 else if (parsed.equip && parsed.bloom)
509 { equipBlooms[parsed.base] = true; }
510 else if (parsed.equip)
511 { equips[parsed.base] = true; }
512 else if (parsed.bloom)
513 { blooms[parsed.base] = true; }
514 continue;
515 }
516 if (isCompanionSpriteStem(stem))
517 { continue; }
518 states.push(stem);
519 }
520 const filterMap = (map) =>
521 {
522 const next = {};
523 for (const state of states)
524 {
525 if (map[state])
526 { next[state] = true; }
527 }
528 return next;
529 };
530 return {
531 states,
532 blooms: filterMap(blooms),
533 equips: filterMap(equips),
534 equipBlooms: filterMap(equipBlooms),
535 /** Editor palette thumbs (`water-preview` → base `water`); not placeable states. */
536 previews
537 };
538}
539
540function listPngStems (folder)
541{
542 let entries;
543 try
544 { entries = readdirSync(folder, { withFileTypes: true }); }
545 catch (error)
546 {
547 if (error.code === "ENOENT")
548 { return []; }
549 throw error;
550 }
551
552 return entries
553 .filter((entry) => entry.isFile() && extname(entry.name).toLowerCase() === ".png")
554 .map((entry) => entry.name.slice(0, -extname(entry.name).length))
555 .filter((stem) => !stem.startsWith("example") && !stem.startsWith("_"))
556 .sort((a, b) => a.localeCompare(b, "en", { numeric: true, sensitivity: "base" }));
557}