BlueGit

timfa questward

Files

questward / server / src / assets / spriteCatalog.js

spriteCatalog.js

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