BlueGit

timfa questward

Files

questward / shared / definitions / tiles.js

tiles.js

tiles.js 13.1 KiB Download Raw
1import {
2 ORE_BEARING_MATERIALS,
3 oreBoulderState,
4 materialFromOreBoulderState,
5 MATERIAL_DISPLAY_NAME,
6 WoodTier,
7 WOOD_TIER_ORDER
8} from "./materialTiers.js";
9import { spriteImageName, resolveState } from "./tileSprites.js";
10import { isSeasonalStumpState, SeasonId } from "../world/season.js";
11import {
12 composeNeighborConnectState,
13 definitionUsesMaterialNeighborConnect
14} from "../world/neighborConnect.js";
15
16export const GroundType = Object.freeze({
17 grass: 1,
18 wood: 2,
19 water: 3,
20 deepWater: 4
21});
22
23export const BlockType = Object.freeze({
24 stoneWall: 1,
25 torch: 2,
26 /** @deprecated Legacy authored block; migrated into chunk `spawners[]` on load. */
27 spawner: 3,
28 bank: 4,
29 churchAltar: 5,
30 cauldron: 6,
31 boulder: 7,
32 furnace: 8,
33 anvil: 9,
34 woodworkingBench: 10,
35 craftingBench: 11,
36 pineTree: 12,
37 marketplace: 13,
38 table: 14
39});
40
41export const GROUND_DEFINITIONS = Object.freeze({
42 [GroundType.grass]: Object.freeze({
43 id: GroundType.grass,
44 key: "grass",
45 displayName: "Grass",
46 passable: true,
47 wades: false,
48 water: false,
49 frames: 1,
50 framesPerRow: 1,
51 animationSpeed: 0,
52 /** Outdoor grounds should expose summer/fall/winter (legacy `grass` ok for summer). */
53 outdoor: true
54 }),
55 [GroundType.wood]: Object.freeze({
56 id: GroundType.wood,
57 key: "wood",
58 displayName: "Wood",
59 passable: true,
60 wades: false,
61 water: false,
62 frames: 1,
63 framesPerRow: 1,
64 animationSpeed: 0,
65 outdoor: false
66 }),
67 [GroundType.water]: Object.freeze({
68 id: GroundType.water,
69 key: "water",
70 displayName: "Water",
71 passable: true,
72 wades: true,
73 water: true,
74 frames: 4,
75 framesPerRow: 4,
76 animationSpeed: 0.12,
77 outdoor: true
78 }),
79 [GroundType.deepWater]: Object.freeze({
80 id: GroundType.deepWater,
81 key: "deep-water",
82 displayName: "Deep water",
83 passable: false,
84 wades: false,
85 water: true,
86 frames: 4,
87 framesPerRow: 4,
88 animationSpeed: 0.12,
89 outdoor: true
90 })
91});
92
93export const BLOCK_DEFINITIONS = Object.freeze({
94 [BlockType.stoneWall]: Object.freeze({
95 id: BlockType.stoneWall,
96 key: "stone-wall",
97 displayName: "Stone wall",
98 passable: false,
99 lightRangeTiles: 0,
100 frames: 1,
101 framesPerRow: 1,
102 animationSpeed: 0,
103 /** Building walls count as indoor (no seasonal art required). */
104 outdoor: false
105 }),
106 [BlockType.torch]: Object.freeze({
107 id: BlockType.torch,
108 key: "torch",
109 displayName: "Torch",
110 passable: true,
111 lightRangeTiles: 8,
112 frames: 1,
113 framesPerRow: 1,
114 animationSpeed: 0,
115 outdoor: false
116 }),
117 [BlockType.spawner]: Object.freeze({
118 id: BlockType.spawner,
119 key: "spawner",
120 displayName: "Spawner",
121 passable: true,
122 lightRangeTiles: 0,
123 frames: 1,
124 framesPerRow: 1,
125 animationSpeed: 0,
126 /** Not shown in the placeable block palette; use the Spawners tab. */
127 editorHidden: true,
128 outdoor: false
129 }),
130 [BlockType.bank]: Object.freeze({
131 id: BlockType.bank,
132 key: "bank",
133 displayName: "Bank",
134 passable: false,
135 lightRangeTiles: 0,
136 frames: 1,
137 framesPerRow: 1,
138 animationSpeed: 0,
139 outdoor: false
140 }),
141 [BlockType.churchAltar]: Object.freeze({
142 id: BlockType.churchAltar,
143 key: "church-altar",
144 displayName: "Church altar",
145 passable: false,
146 lightRangeTiles: 0,
147 frames: 1,
148 framesPerRow: 1,
149 animationSpeed: 0,
150 outdoor: false
151 }),
152 [BlockType.cauldron]: Object.freeze({
153 id: BlockType.cauldron,
154 key: "cauldron",
155 displayName: "Cauldron",
156 passable: false,
157 blocksLight: false,
158 lightRangeTiles: 0,
159 frames: 1,
160 framesPerRow: 1,
161 animationSpeed: 0,
162 outdoor: false
163 }),
164 [BlockType.boulder]: Object.freeze({
165 id: BlockType.boulder,
166 key: "boulder",
167 displayName: "Boulder",
168 passable: false,
169 blocksLight: false,
170 lightRangeTiles: 0,
171 frames: 1,
172 framesPerRow: 1,
173 animationSpeed: 0,
174 /** Ore states are synthesized in the sprite catalog (tinted boulder-ore). */
175 gatherable: true,
176 outdoor: true
177 }),
178 [BlockType.furnace]: Object.freeze({
179 id: BlockType.furnace,
180 key: "furnace",
181 displayName: "Furnace",
182 passable: false,
183 blocksLight: false,
184 lightRangeTiles: 4,
185 frames: 1,
186 framesPerRow: 1,
187 animationSpeed: 0,
188 craftingStationId: "furnace",
189 outdoor: false
190 }),
191 [BlockType.anvil]: Object.freeze({
192 id: BlockType.anvil,
193 key: "anvil",
194 displayName: "Anvil",
195 passable: false,
196 blocksLight: false,
197 lightRangeTiles: 0,
198 frames: 1,
199 framesPerRow: 1,
200 animationSpeed: 0,
201 craftingStationId: "anvil",
202 outdoor: false
203 }),
204 [BlockType.woodworkingBench]: Object.freeze({
205 id: BlockType.woodworkingBench,
206 key: "woodworking-bench",
207 displayName: "Woodworking bench",
208 passable: false,
209 blocksLight: false,
210 lightRangeTiles: 0,
211 frames: 1,
212 framesPerRow: 1,
213 animationSpeed: 0,
214 craftingStationId: "woodworking-bench",
215 outdoor: false
216 }),
217 [BlockType.craftingBench]: Object.freeze({
218 id: BlockType.craftingBench,
219 key: "crafting-bench",
220 displayName: "Crafting bench",
221 passable: false,
222 blocksLight: false,
223 lightRangeTiles: 0,
224 frames: 1,
225 framesPerRow: 1,
226 animationSpeed: 0,
227 craftingStationId: "crafting-bench",
228 outdoor: false
229 }),
230 [BlockType.pineTree]: Object.freeze({
231 id: BlockType.pineTree,
232 key: "pine-tree",
233 displayName: "Pine tree",
234 passable: false,
235 /** Canopy: light passes but each tree tile adds +1 falloff distance. */
236 blocksLight: "partial",
237 lightRangeTiles: 0,
238 frames: 1,
239 framesPerRow: 1,
240 animationSpeed: 0,
241 outdoor: true,
242 gatherable: true,
243 /** Wood tier yielded when chopped (axe). */
244 woodTier: WoodTier.pine
245 }),
246 [BlockType.marketplace]: Object.freeze({
247 id: BlockType.marketplace,
248 key: "marketplace",
249 displayName: "Central Exchange counter",
250 passable: false,
251 /** Furniture: blocks movement but not baked/dynamic light rays. */
252 blocksLight: false,
253 lightRangeTiles: 0,
254 frames: 1,
255 framesPerRow: 1,
256 animationSpeed: 0,
257 outdoor: false,
258 /** Autotile via N/E/S/W bitmask states `"0"`…`"15"`. */
259 neighborConnect: true
260 }),
261 [BlockType.table]: Object.freeze({
262 id: BlockType.table,
263 key: "table",
264 displayName: "Table",
265 passable: false,
266 blocksLight: false,
267 lightRangeTiles: 0,
268 frames: 1,
269 framesPerRow: 1,
270 animationSpeed: 0,
271 outdoor: false,
272 /** Magenta base `0`–`15` (strip-union line tables); catalog expands `${wood}-${mask}`.
273 * Filled-rectangle corners can later add diagonal-aware sprites without replacing these. */
274 neighborConnect: true,
275 neighborConnectByMaterial: true,
276 defaultNeighborMaterial: WoodTier.pine
277 })
278});
279
280/** Grounds and real blocks the editor may place (excludes legacy/hidden entries). */
281export function listPlaceableGrounds ()
282{
283 return Object.values(GROUND_DEFINITIONS);
284}
285
286export function listPlaceableBlocks ()
287{
288 return Object.values(BLOCK_DEFINITIONS).filter((def) => !def.editorHidden);
289}
290
291/** Display name for an ore boulder state (`copper-ore` → "Copper ore boulder"). */
292export function oreBoulderDisplayName (state)
293{
294 const material = materialFromOreBoulderState(state);
295 if (!material)
296 { return null; }
297 const label = MATERIAL_DISPLAY_NAME[material] ?? material;
298 return material === "coal" ? "Coal boulder" : `${label} ore boulder`;
299}
300
301/**
302 * Hover / UI label for a gatherable resource node.
303 * Ore boulders and chopable trees; fishing / herbs can extend this later.
304 * Returns null when the block is not an active resource node.
305 */
306export function resourceNodeDisplayName (block)
307{
308 if (!block)
309 { return null; }
310 if (block.typeId === BlockType.boulder)
311 { return oreBoulderDisplayName(block.state); }
312 if (isChopableTreeBlock(block))
313 {
314 const def = BLOCK_DEFINITIONS[block.typeId];
315 return def?.displayName ?? "Tree";
316 }
317 return null;
318}
319
320/** Wood tier for a tree block type, or null. */
321export function woodTierForTreeBlock (typeId)
322{
323 const def = BLOCK_DEFINITIONS[typeId];
324 return def?.woodTier ?? null;
325}
326
327/** True when this block is a standing (non-stump) gatherable tree. */
328export function isChopableTreeBlock (block)
329{
330 if (!block || woodTierForTreeBlock(block.typeId) == null)
331 { return false; }
332 return !isSeasonalStumpState(block.state);
333}
334
335/**
336 * Editor palette cards: one entry per placeable, with boulder expanded into
337 * plain rock + each ore/coal variant (shared BlockType, distinct state).
338 */
339export function listPlaceableBlockPaletteEntries (catalog = null)
340{
341 const entries = [];
342 for (const def of listPlaceableBlocks())
343 {
344 if (def.id === BlockType.boulder)
345 {
346 entries.push({
347 typeId: def.id,
348 state: "boulder",
349 key: def.key,
350 displayName: "Boulder",
351 spriteName: spriteImageName("block", def.key, "boulder")
352 });
353 for (const material of ORE_BEARING_MATERIALS)
354 {
355 const state = oreBoulderState(material);
356 entries.push({
357 typeId: def.id,
358 state,
359 key: def.key,
360 displayName: oreBoulderDisplayName(state) ?? state,
361 spriteName: spriteImageName("block", def.key, state)
362 });
363 }
364 continue;
365 }
366 if (def.neighborConnect)
367 {
368 if (definitionUsesMaterialNeighborConnect(def))
369 {
370 for (const material of WOOD_TIER_ORDER)
371 {
372 const state = composeNeighborConnectState(def, material, 0);
373 const label = MATERIAL_DISPLAY_NAME[material] ?? material;
374 entries.push({
375 typeId: def.id,
376 state,
377 key: def.key,
378 displayName: `${label} table`,
379 spriteName: spriteImageName("block", def.key, state)
380 });
381 }
382 continue;
383 }
384 entries.push({
385 typeId: def.id,
386 state: "0",
387 key: def.key,
388 displayName: def.displayName,
389 spriteName: spriteImageName("block", def.key, "0")
390 });
391 continue;
392 }
393 const states = catalog?.blocks?.[def.key]?.states ?? [];
394 const state = resolveState(states, null);
395 entries.push({
396 typeId: def.id,
397 state,
398 key: def.key,
399 displayName: def.displayName,
400 spriteName: state
401 ? spriteImageName("block", def.key, state)
402 : spriteImageName("block", def.key, def.key)
403 });
404 }
405 return entries;
406}
407
408export function groundDefinition (typeId)
409{
410 return GROUND_DEFINITIONS[typeId] ?? null;
411}
412
413export function blockDefinition (typeId)
414{
415 return BLOCK_DEFINITIONS[typeId] ?? null;
416}
417
418export function isGroundPassable (typeId)
419{
420 const def = groundDefinition(typeId);
421 if (!def)
422 { return true; }
423 return def.passable !== false;
424}
425
426export function isWaterGround (typeId)
427{
428 return !!groundDefinition(typeId)?.water;
429}
430
431export function isWadeGround (typeId)
432{
433 return !!groundDefinition(typeId)?.wades;
434}
435
436/**
437 * Liquid water for foam / wade (shallow water freezes in winter and is solid ice).
438 * Deep water stays liquid year-round.
439 */
440export function isLiquidWaterGround (typeId, seasonId = null)
441{
442 if (!isWaterGround(typeId))
443 { return false; }
444 if (typeId === GroundType.water && seasonId === SeasonId.winter)
445 { return false; }
446 return true;
447}
448
449/** Wade clip/foam only on liquid shallow water (not winter ice). */
450export function isWadeGroundInSeason (typeId, seasonId = null)
451{
452 return isWadeGround(typeId) && isLiquidWaterGround(typeId, seasonId);
453}
454
455export function isBlockPassable (typeId)
456{
457 if (typeId == null)
458 { return true; }
459
460 const def = blockDefinition(typeId);
461 return def ? def.passable : false;
462}
463
464/**
465 * Light ray occlusion for a block tile.
466 * - `clear` (0): no effect (default for passable; set `blocksLight: false` for furniture)
467 * - `partial` (1): ray continues; each such tile adds +1 to falloff distance (2× cost)
468 * - `solid` (2): ray stops (default for impassable; set `blocksLight: true` explicitly)
469 */
470export const LightOcclusion = Object.freeze({
471 clear: 0,
472 partial: 1,
473 solid: 2
474});
475
476/**
477 * Resolve light occlusion for a block tile (type + visual state).
478 * Stumps are a runtime/editor state override: no occlusion even on tree types.
479 */
480export function blockLightOcclusionForBlock (block)
481{
482 if (!block)
483 { return LightOcclusion.clear; }
484 if (isSeasonalStumpState(block.state))
485 { return LightOcclusion.clear; }
486 return blockLightOcclusion(block.typeId ?? null);
487}
488
489/**
490 * Resolve light occlusion for a block type id.
491 * `blocksLight`: `true` | `false` | `"partial"`; omitted → solid iff `!passable`.
492 * Prefer {@link blockLightOcclusionForBlock} when block state is known.
493 */
494export function blockLightOcclusion (typeId)
495{
496 if (typeId == null)
497 { return LightOcclusion.clear; }
498 const def = blockDefinition(typeId);
499 if (!def)
500 { return LightOcclusion.solid; }
501 if (def.blocksLight === "partial")
502 { return LightOcclusion.partial; }
503 if (def.blocksLight === false)
504 { return LightOcclusion.clear; }
505 if (def.blocksLight === true)
506 { return LightOcclusion.solid; }
507 return def.passable === false ? LightOcclusion.solid : LightOcclusion.clear;
508}
509
510/** True when a block fully stops light rays (not partial canopy). */
511export function isBlockOccludingLight (typeId)
512{
513 return blockLightOcclusion(typeId) === LightOcclusion.solid;
514}
515
516export function blockLightRange (typeId)
517{
518 const def = blockDefinition(typeId);
519 return def ? def.lightRangeTiles : 0;
520}
521
522export function normalizeGround (value, fallbackTypeId = GroundType.grass)
523{
524 if (typeof value === "number")
525 { return { typeId: value, state: null }; }
526 if (value && Number.isInteger(value.typeId))
527 { return { typeId: value.typeId, state: value.state ?? null }; }
528 return { typeId: fallbackTypeId, state: null };
529}
530
531export function normalizeBlock (value)
532{
533 if (!value || !Number.isInteger(value.typeId))
534 { return null; }
535 return { typeId: value.typeId, state: value.state ?? null, config: value.config ?? null };
536}
537
538export function setBlockVisualState (block, state)
539{
540 if (!block)
541 { return null; }
542 block.state = state ?? null;
543 return block;
544}