BlueGit

timfa questward

Files

questward / server / src / assets / spriteCatalog.js

spriteCatalog.js

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