BlueGit

projects-timfalken-com meteors

Files

meteors / test / planet.test.js

planet.test.js

planet.test.js 8.2 KiB Download Raw
1'use strict';
2
3const { describe, it } = require('node:test');
4const assert = require('node:assert/strict');
5const Planet = require('../src/planet.js');
6
7describe('Planet field and defaults', () =>
8{
9 it('has a 10 by 13 field', () =>
10 {
11 assert.equal(Planet.FIELD_WIDTH, 10);
12 assert.equal(Planet.FIELD_HEIGHT, 13);
13 });
14
15 it('default planet is Terra with mid-range physics', () =>
16 {
17 const p = Planet.defaultPlanet();
18 assert.equal(p.name, 'Terra');
19 assert.equal(p.people, 'Terrans');
20 assert.equal(p.jumpsToClear, 2);
21 assert.equal(p.fallTime, 3);
22 assert.equal(p.riseTime, 1.5);
23 assert.equal(p.colors.length, 5);
24 assert.equal(p.baseJumpHeight, 1.5 * 13 / 2);
25 assert.equal(p.fallSpeed, 0.5 * 13 / 3);
26 });
27
28 it('clamps gravity, air and mass to the stage-3 ranges', () =>
29 {
30 const lo = Planet.createPlanet({ jumpsToClear: 0, fallTime: 0, riseTime: 0 });
31 assert.equal(lo.jumpsToClear, 1);
32 assert.equal(lo.fallTime, 1);
33 assert.equal(lo.riseTime, 0.5);
34
35 const hi = Planet.createPlanet({ jumpsToClear: 9, fallTime: 99, riseTime: 99 });
36 assert.equal(hi.jumpsToClear, 4);
37 assert.equal(hi.fallTime, 5);
38 assert.equal(hi.riseTime, 3);
39 });
40
41 it('keeps colors and shapes data-driven with a unique shape per color', () =>
42 {
43 const colors = Planet.defaultColors();
44 assert.equal(colors.length, 5);
45 const shapes = new Set(colors.map((c) => c.shape));
46 const images = new Set(colors.map((c) => c.image));
47 assert.equal(shapes.size, 5);
48 assert.equal(images.size, 5);
49 for (const c of colors)
50 {
51 assert.ok(c.hex.startsWith('#'));
52 assert.ok(c.image.startsWith('images/'));
53 assert.ok(typeof c.name === 'string' && c.name.length > 0);
54 }
55 });
56});
57
58describe('Jump height rules', () =>
59{
60 const planet = Planet.defaultPlanet();
61 const base = planet.baseJumpHeight;
62
63 it('a horizontal match of 3 uses the base jump height', () =>
64 {
65 assert.equal(Planet.jumpHeight(planet, 3, false), base);
66 });
67
68 it('a vertical match of 3 is 120% of a horizontal row', () =>
69 {
70 assert.equal(Planet.jumpHeight(planet, 3, true), base * 1.2);
71 });
72
73 it('each extra block beyond 3 adds 5% jump height', () =>
74 {
75 assert.ok(Math.abs(Planet.jumpHeight(planet, 4, false) - base * 1.05) < 1e-12);
76 assert.ok(Math.abs(Planet.jumpHeight(planet, 5, false) - base * 1.10) < 1e-12);
77 assert.ok(Math.abs(Planet.jumpHeight(planet, 4, true) - base * (1.2 + 0.05)) < 1e-12);
78 assert.ok(Math.abs(Planet.jumpHeight(planet, 6, true) - base * (1.2 + 0.15)) < 1e-12);
79 });
80
81 it('at min gravity one horizontal-3 jump is 50% taller than the field', () =>
82 {
83 const easy = Planet.createPlanet({ jumpsToClear: 1 });
84 assert.equal(Planet.jumpHeight(easy, 3, false), 1.5 * 13);
85 assert.equal(Planet.JUMP_HEIGHT_SCALE, 1.5);
86 });
87
88 it('at max gravity four horizontal-3 jumps equal 1.5 times the field height', () =>
89 {
90 const hard = Planet.createPlanet({ jumpsToClear: 4 });
91 assert.equal(Planet.jumpHeight(hard, 3, false) * 4, 1.5 * 13);
92 });
93});
94
95describe('Launch and fall physics parameters', () =>
96{
97 it('a jump of height H peaks in riseTime at constant deceleration', () =>
98 {
99 const p = Planet.defaultPlanet();
100 const H = 6.5;
101 const v0 = Planet.launchVelocity(p, H);
102 const a = Planet.launchDeceleration(p, H);
103 assert.equal(v0, 2 * H / p.riseTime);
104 assert.equal(a, 2 * H / (p.riseTime * p.riseTime));
105 // v = v0 - a t; v=0 at t=riseTime; s = v0 t - 0.5 a t^2 = H
106 const t = p.riseTime;
107 assert.ok(Math.abs((v0 - a * t)) < 1e-12);
108 assert.ok(Math.abs((v0 * t - 0.5 * a * t * t) - H) < 1e-12);
109 });
110
111 it('apex time is independent of jump height (mass)', () =>
112 {
113 const p = Planet.defaultPlanet();
114 const a1 = Planet.launchDeceleration(p, 4);
115 const v1 = Planet.launchVelocity(p, 4);
116 const a2 = Planet.launchDeceleration(p, 10);
117 const v2 = Planet.launchVelocity(p, 10);
118 assert.ok(Math.abs(v1 / a1 - p.riseTime) < 1e-12);
119 assert.ok(Math.abs(v2 / a2 - p.riseTime) < 1e-12);
120 });
121
122 it('fall speed is half the field height over fallTime (t1122), ratios kept', () =>
123 {
124 const slow = Planet.createPlanet({ fallTime: 5 });
125 const fast = Planet.createPlanet({ fallTime: 1 });
126 assert.equal(Planet.DESCENT_SPEED_SCALE, 0.5);
127 assert.equal(slow.fallSpeed, 0.5 * 13 / 5);
128 assert.equal(fast.fallSpeed, 0.5 * 13);
129 assert.ok(fast.fallSpeed > slow.fallSpeed);
130 // Relative difference between planets is unchanged (1 / fallTime).
131 assert.ok(Math.abs(fast.fallSpeed / slow.fallSpeed - 5) < 1e-12);
132 });
133});
134
135describe('Power and display values', () =>
136{
137 it('easiest planet has power 0 and 60% miss chance', () =>
138 {
139 const easy = Planet.createPlanet({ jumpsToClear: 1, fallTime: 5, riseTime: 3 });
140 assert.equal(Planet.power(easy), 0);
141 assert.equal(Planet.missChance(easy), 0.60);
142 });
143
144 it('hardest planet has power 1 and 5% miss chance', () =>
145 {
146 const hard = Planet.createPlanet({ jumpsToClear: 4, fallTime: 1, riseTime: 0.5 });
147 assert.ok(Math.abs(Planet.power(hard) - 1) < 1e-12);
148 assert.ok(Math.abs(Planet.missChance(hard) - 0.05) < 1e-12);
149 });
150
151 it('display values are numeric gravity, density, newtons and power %', () =>
152 {
153 const p = Planet.defaultPlanet();
154 const d = Planet.displayValues(p);
155 assert.ok(d.gravity > 0);
156 assert.ok(d.density > 0);
157 assert.ok(d.newtons > 0);
158 assert.equal(typeof d.power, 'number');
159 assert.ok(d.power >= 0 && d.power <= 100);
160 // Mid-range Terra (jumps=2) shows Earth-like 9.81
161 assert.ok(Math.abs(d.gravity - 9.81) < 1e-9);
162 });
163
164 it('displayed Power is 1 − missChance / 0.60, so 0% miss shows as 100% Power', () =>
165 {
166 const easy = Planet.createPlanet({ jumpsToClear: 1, fallTime: 5, riseTime: 3 });
167 const hard = Planet.createPlanet({ jumpsToClear: 4, fallTime: 1, riseTime: 0.5 });
168 const terra = Planet.defaultPlanet();
169 // 60% miss → 0% Power; 5% miss → 92% (not 100 — the floor is 5%, not 0).
170 assert.equal(Planet.displayPower(easy), 0);
171 assert.equal(Planet.displayValues(easy).power, 0);
172 assert.equal(Planet.displayPower(hard), Math.round((1 - 0.05 / 0.60) * 100));
173 assert.equal(Planet.displayPower(hard), 92);
174 const terraMiss = Planet.missChance(terra);
175 assert.equal(Planet.displayPower(terra), Math.round((1 - terraMiss / 0.60) * 100));
176 assert.equal(Planet.displayValues(terra).power, 44);
177 // Gameplay power() and missChance() are unchanged.
178 assert.equal(Planet.power(easy), 0);
179 assert.ok(Math.abs(Planet.power(hard) - 1) < 1e-12);
180 assert.equal(Planet.missChance(easy), 0.60);
181 assert.ok(Math.abs(Planet.missChance(hard) - 0.05) < 1e-12);
182 // Monotonic: a lower miss chance means a higher displayed Power.
183 assert.ok(Planet.displayPower(hard) > Planet.displayPower(terra));
184 assert.ok(Planet.displayPower(terra) > Planet.displayPower(easy));
185 });
186});
187
188describe('Planet catalog', () =>
189{
190 it('has 8–12 named worlds, each with a people name and five unique shapes', () =>
191 {
192 const all = Planet.allPlanets();
193 assert.ok(all.length >= 8 && all.length <= 12, 'catalog size ' + all.length);
194 const ids = new Set();
195 const images = new Set();
196 for (const p of all)
197 {
198 assert.ok(p.id && p.name && p.people, p.id);
199 assert.ok(!ids.has(p.id), 'duplicate id ' + p.id);
200 ids.add(p.id);
201 assert.equal(p.colors.length, 5);
202 const shapes = new Set(p.colors.map((c) => c.shape));
203 assert.equal(shapes.size, 5, p.id + ' shapes');
204 for (const c of p.colors)
205 {
206 assert.ok(c.image.startsWith('images/block-' + p.id + '-'), c.image);
207 assert.ok(!images.has(c.image), 'duplicate image ' + c.image);
208 images.add(c.image);
209 }
210 assert.ok(p.jumpsToClear >= 1 && p.jumpsToClear <= 4);
211 assert.ok(p.fallTime >= 1 && p.fallTime <= 5);
212 assert.ok(p.riseTime >= 0.5 && p.riseTime <= 3);
213 }
214 assert.ok(ids.has('terra'));
215 assert.equal(Planet.defaultPlanet().id, 'terra');
216 assert.equal(Planet.planetById('cinder').name, 'Cinder');
217 });
218
219 it('Aurel is the easiest (gameplay Power 0, 60% miss, shown as 0%) and Cinder the hardest (gameplay Power 1, 5% miss, shown as 92%)', () =>
220 {
221 const aurel = Planet.planetById('aurel');
222 const cinder = Planet.planetById('cinder');
223 assert.equal(Planet.power(aurel), 0);
224 assert.equal(Planet.missChance(aurel), 0.60);
225 assert.ok(Math.abs(Planet.power(cinder) - 1) < 1e-12);
226 assert.ok(Math.abs(Planet.missChance(cinder) - 0.05) < 1e-12);
227 assert.equal(Planet.displayValues(aurel).power, 0);
228 assert.equal(Planet.displayValues(cinder).power, 92);
229 });
230});