| 1 | 'use strict'; |
| 2 | |
| 3 | const { describe, it } = require('node:test'); |
| 4 | const assert = require('node:assert/strict'); |
| 5 | const Planet = require('../src/planet.js'); |
| 6 | |
| 7 | describe('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 | |
| 58 | describe('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 | |
| 95 | describe('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 | |
| 135 | describe('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 | |
| 188 | describe('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 | }); |
projects-timfalken-com meteors