BlueGit

timfa questward

Files

questward / server / src / assets / spriteCatalog.js

spriteCatalog.js

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