BlueGit

timfa questward

Files

questward / server / tests / tile-average-colors.test.js

tile-average-colors.test.js

feat: add sprite average colours and an editor minimap
timfa project_85689633_bot_760517ee9267c86ff1d6c3a0237abf7d · pushed by timfa · 6 weeks ago
8a24eb51 History
tile-average-colors.test.js 5.0 KiB Download Raw
1import test from "node:test";
2import assert from "node:assert/strict";
3import { fileURLToPath } from "node:url";
4import { join } from "node:path";
5import { buildSpriteCatalog } from "../src/assets/spriteCatalog.js";
6import { AVERAGE_COLOR_ALPHA_THRESHOLD, averageOpaqueColor } from "../../shared/render/averageSpriteColor.js";
7import
8{
9 BlockType,
10 GroundType,
11 BLOCK_DEFINITIONS,
12 GROUND_DEFINITIONS,
13 blockAverageColor,
14 groundAverageColor,
15 installTileAverageColors
16} from "../../shared/definitions/tiles.js";
17import { minimapChunkAtPixel, renderChunkMinimapRgba } from "../../shared/render/chunkMinimap.js";
18import { CHUNK_SIZE } from "../../shared/protocol/constants.js";
19
20const ASSET_ROOT = join(fileURLToPath(new URL("../../client/assets", import.meta.url)));
21
22test("average colour ignores pixels at or below the alpha threshold", () =>
23{
24 assert.equal(AVERAGE_COLOR_ALPHA_THRESHOLD, 16);
25 const rgba = new Uint8ClampedArray([
26 255, 0, 0, 16,
27 0, 0, 255, 17,
28 0, 255, 0, 255
29 ]);
30 assert.deepEqual(averageOpaqueColor(rgba, 3, 1), { r: 0, g: 128, b: 128 });
31 assert.equal(averageOpaqueColor(new Uint8ClampedArray([0, 0, 0, 0, 1, 2, 3, 16]), 2, 1), null);
32});
33
34test("registry falls back from an unknown state to the type colour", () =>
35{
36 installTileAverageColors({
37 grounds: {
38 grass: {
39 typeId: GroundType.grass,
40 averageColor: { r: 1, g: 2, b: 3 },
41 stateColors: { summer: { r: 4, g: 5, b: 6 } }
42 }
43 },
44 blocks: {
45 flower: {
46 typeId: BlockType.flower,
47 averageColor: { r: 9, g: 0, b: 0 },
48 stateColors: { blue: { r: 0, g: 0, b: 9 } }
49 }
50 }
51 });
52 assert.deepEqual(groundAverageColor(GroundType.grass), { r: 1, g: 2, b: 3 });
53 assert.deepEqual(groundAverageColor(GroundType.grass, "summer"), { r: 4, g: 5, b: 6 });
54 assert.deepEqual(groundAverageColor(GroundType.grass, "missing"), { r: 1, g: 2, b: 3 });
55 assert.deepEqual(blockAverageColor(BlockType.flower, "blue"), { r: 0, g: 0, b: 9 });
56 assert.deepEqual(blockAverageColor(BlockType.flower, "nope"), { r: 9, g: 0, b: 0 });
57 assert.equal(blockAverageColor(9999), null);
58 assert.equal(groundAverageColor(null), null);
59});
60
61test("minimap pixels prefer the block colour and map clicks onto chunks", () =>
62{
63 installTileAverageColors({
64 grounds: {
65 grass: {
66 typeId: GroundType.grass,
67 averageColor: { r: 10, g: 200, b: 20 },
68 stateColors: {}
69 }
70 },
71 blocks: {
72 flower: {
73 typeId: BlockType.flower,
74 averageColor: { r: 200, g: 20, b: 40 },
75 stateColors: { red: { r: 200, g: 20, b: 40 } }
76 }
77 }
78 });
79 const grounds = new Array(CHUNK_SIZE * CHUNK_SIZE).fill({ typeId: GroundType.grass, state: null });
80 const blocks = new Array(CHUNK_SIZE * CHUNK_SIZE).fill(null);
81 blocks[0] = { typeId: BlockType.flower, state: "red" };
82 const rgba = renderChunkMinimapRgba({ grounds, blocks });
83 assert.equal(rgba[0], 200);
84 assert.equal(rgba[1], 20);
85 assert.equal(rgba[4], 10);
86 assert.equal(rgba[5], 200);
87
88 assert.equal(CHUNK_SIZE, 16);
89 assert.deepEqual(minimapChunkAtPixel(0, 0, 5, -3), { chunkX: 5 - 12, chunkY: -3 - 12 });
90 assert.deepEqual(minimapChunkAtPixel(12 * 16, 12 * 16, 5, -3), { chunkX: 5, chunkY: -3 });
91 assert.deepEqual(minimapChunkAtPixel(24 * 16, 24 * 16, 0, 0), { chunkX: 12, chunkY: 12 });
92 assert.equal(minimapChunkAtPixel(25 * 16, 0, 0, 0), null);
93 assert.equal(minimapChunkAtPixel(-1, 0, 0, 0), null);
94});
95
96test("every ground and block colour comes from its sprites", () =>
97{
98 const catalog = buildSpriteCatalog(ASSET_ROOT);
99 for (const def of Object.values(GROUND_DEFINITIONS))
100 {
101 const color = groundAverageColor(def.id);
102 assert.ok(color, `missing ground colour for ${def.key}`);
103 assert.deepEqual(color, catalog.grounds[def.key].averageColor);
104 for (const state of catalog.grounds[def.key].states)
105 {
106 assert.ok(groundAverageColor(def.id, state), `${def.key}:${state}`);
107 }
108 }
109 for (const def of Object.values(BLOCK_DEFINITIONS))
110 {
111 const color = blockAverageColor(def.id);
112 assert.ok(color, `missing block colour for ${def.key}`);
113 const entry = catalog.blocks[def.key];
114 assert.ok(entry, def.key);
115 assert.deepEqual(color, entry.averageColor);
116 for (const state of entry.states)
117 { assert.ok(blockAverageColor(def.id, state), `${def.key}:${state}`); }
118 }
119
120 const summer = groundAverageColor(GroundType.grass, "summer");
121 const winter = groundAverageColor(GroundType.grass, "winter");
122 assert.ok(summer.g > summer.r && summer.g > summer.b, JSON.stringify(summer));
123 assert.notDeepEqual(summer, winter);
124 assert.deepEqual(groundAverageColor(GroundType.grass), summer);
125
126 const water = groundAverageColor(GroundType.water);
127 const lava = groundAverageColor(GroundType.lava);
128 const ice = groundAverageColor(GroundType.water, "water-winter");
129 assert.ok(water.b > water.r + 20, JSON.stringify(water));
130 assert.ok(lava.r > lava.g && lava.r > lava.b, JSON.stringify(lava));
131 assert.notDeepEqual(water, ice);
132
133 const red = blockAverageColor(BlockType.flower, "red");
134 const blue = blockAverageColor(BlockType.flower, "blue");
135 assert.ok(red.r > blue.r, JSON.stringify({ red, blue }));
136 assert.ok(blue.b > red.b, JSON.stringify({ red, blue }));
137});