254 lines
9.6 KiB
JavaScript
254 lines
9.6 KiB
JavaScript
/**
|
|
* Ship behavior test (dev tool, run with Node — no browser needed):
|
|
*
|
|
* node dev/ship-behavior.test.mjs
|
|
*
|
|
* Stubs just enough of Phaser + a scene to run the REAL Ship.update()
|
|
* loop from js/entities/Ship.js, then asserts the flight feel:
|
|
* arrives and stops, respects maxSpeed, tracks its heading, stops facing
|
|
* the direction it was traveling, can be re-targeted mid-flight, coasts
|
|
* to rest, hard-brakes on stop(). Heading assertions account for the
|
|
* ship's art render offset (ship.artOffset — data/ship.json → artFacing),
|
|
* which is a presentation concern, not flight behavior.
|
|
*
|
|
* The harness integrates acceleration→velocity→position the way the
|
|
* Arcade physics world does (after the scene's update).
|
|
*/
|
|
import { pathToFileURL } from 'node:url';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { dirname, join } from 'node:path';
|
|
|
|
const __dirname = dirname(fileURLToPath(import.meta.url));
|
|
const TAU = Math.PI * 2;
|
|
const wrap = (a) => ((a % TAU) + TAU) % TAU;
|
|
|
|
class V2 {
|
|
constructor(x = 0, y = 0) { this.x = x; this.y = y; }
|
|
set(x, y) { this.x = x; this.y = y; return this; }
|
|
length() { return Math.hypot(this.x, this.y); }
|
|
scale(s) { this.x *= s; this.y *= s; return this; }
|
|
}
|
|
|
|
class Sprite {
|
|
constructor(scene, x, y, key) {
|
|
this.scene = scene; this.x = x; this.y = y; this.key = key;
|
|
this.rotation = 0; this.scaleX = 1; this.scaleY = 1; this.body = null;
|
|
}
|
|
setCollideWorldBounds() { return this; }
|
|
setScale(s) { this.scaleX = this.scaleY = s; return this; }
|
|
}
|
|
|
|
const graphicsStub = {
|
|
fillStyle() {}, beginPath() {}, moveTo() {}, lineTo() {}, closePath() {},
|
|
fillPath() {}, fillCircle() {}, generateTexture() {}, destroy() {},
|
|
};
|
|
|
|
// Mirror of Phaser.Math.Angle.RotateTo (radians, step-based, shortest path).
|
|
const rotateTo = (cur, tgt, step) => {
|
|
let diff = wrap(tgt - cur);
|
|
if (diff > Math.PI) diff -= TAU;
|
|
if (Math.abs(diff) <= step) return tgt;
|
|
return cur + Math.sign(diff) * step;
|
|
};
|
|
|
|
const PhaserStub = {
|
|
Physics: { Arcade: { Sprite } },
|
|
Math: {
|
|
Clamp: (v, min, max) => Math.max(min, Math.min(max, v)),
|
|
Angle: { Wrap: wrap, RotateTo: rotateTo },
|
|
},
|
|
Display: { Color: { ValueToColor: (v) => ({ color: parseInt(v.slice(1), 16) }) } },
|
|
};
|
|
globalThis.window = { Phaser: PhaserStub }; // js/vendor/phaser.js reads this
|
|
|
|
const scene = {
|
|
textures: { exists: () => true },
|
|
make: { graphics: () => graphicsStub },
|
|
add: { existing: (o) => o },
|
|
physics: {
|
|
add: {
|
|
existing: (o) => { o.body = { velocity: new V2(), acceleration: new V2() }; return o; },
|
|
},
|
|
},
|
|
scale: { width: 1280, height: 720 },
|
|
};
|
|
|
|
const { Ship } = await import(
|
|
pathToFileURL(join(__dirname, '../js/entities/Ship.js')).href
|
|
);
|
|
|
|
// Use the real data/*.json config (ship feel comes from data/ship.json).
|
|
const { config } = await import(pathToFileURL(join(__dirname, '../js/config/Config.js')).href);
|
|
const fs = await import('node:fs');
|
|
const dataDir = join(__dirname, '../data');
|
|
const configData = {};
|
|
for (const f of fs.readdirSync(dataDir)) {
|
|
if (!f.endsWith('.json') || f === 'manifest.json') continue;
|
|
configData[f.replace(/\.json$/i, '')] = JSON.parse(fs.readFileSync(join(dataDir, f), 'utf8'));
|
|
}
|
|
config.init(configData);
|
|
console.log('config loaded from data/:', Object.keys(configData).join(', '));
|
|
|
|
let failures = 0;
|
|
const check = (label, cond) => {
|
|
console.log(`${cond ? '✔' : '✘ FAIL'} ${label}`);
|
|
if (!cond) failures++;
|
|
};
|
|
|
|
const dt = 16.67;
|
|
// Physics-world step: acceleration → velocity → position.
|
|
const integrate = (ship) => {
|
|
const s = dt / 1000;
|
|
ship.body.velocity.x += ship.body.acceleration.x * s;
|
|
ship.body.velocity.y += ship.body.acceleration.y * s;
|
|
ship.x += ship.body.velocity.x * s;
|
|
ship.y += ship.body.velocity.y * s;
|
|
};
|
|
|
|
// --- Test 0: base stats (data/ship.json → stats) ---------------------------
|
|
{
|
|
const ship = new Ship(scene, 0, 0);
|
|
const s = config.section('ship.stats');
|
|
check('base stats loaded from config (hull/shields/cargo/minerals)',
|
|
ship.stats.hullIntegrity === s.hullIntegrity &&
|
|
ship.stats.shields === s.shields &&
|
|
ship.stats.cargoHold === s.cargoHold &&
|
|
ship.stats.mineralStorage === s.mineralStorage);
|
|
check('base stats are the shipped values (100 / 0 / 100 / 250)',
|
|
ship.stats.hullIntegrity === 100 &&
|
|
ship.stats.shields === 0 &&
|
|
ship.stats.cargoHold === 100 &&
|
|
ship.stats.mineralStorage === 250);
|
|
}
|
|
|
|
// --- Test 1: fly to a point, arrive and stop --------------------------------
|
|
{
|
|
const ship = new Ship(scene, 640, 360);
|
|
const target = { x: 1000, y: 300 };
|
|
ship.setTarget(target.x, target.y);
|
|
let maxSpeedSeen = 0;
|
|
let arrived = false;
|
|
for (let t = 0; t < 60 * 30; t++) {
|
|
ship.update(t * dt, dt);
|
|
integrate(ship);
|
|
maxSpeedSeen = Math.max(maxSpeedSeen, ship.body.velocity.length());
|
|
if (
|
|
Math.hypot(ship.x - target.x, ship.y - target.y) <= 8 &&
|
|
ship.body.velocity.length() <= 50 &&
|
|
ship.target === null
|
|
) { arrived = true; break; }
|
|
}
|
|
const distTo = Math.hypot(ship.x - target.x, ship.y - target.y);
|
|
check('arrives at target and stops (target cleared)', arrived);
|
|
check(`final position within arrive radius (dist=${distTo.toFixed(2)})`, distTo <= 8.5);
|
|
check('velocity is exactly zero on arrival', ship.body.velocity.length() === 0);
|
|
check(`speed never exceeded maxSpeed (max=${maxSpeedSeen.toFixed(1)} / cap ${ship.maxSpeed})`,
|
|
maxSpeedSeen <= ship.maxSpeed * 1.05 + 0.001);
|
|
}
|
|
|
|
// --- Test 2: heading tracks the direction of travel -------------------------
|
|
{
|
|
const ship = new Ship(scene, 200, 200);
|
|
ship.rotation = 2.5 + (ship.artOffset || 0); // start facing the wrong way (heading space)
|
|
ship.setTarget(600, 200); // fly straight right
|
|
for (let t = 0; t < 60; t++) { ship.update(t * dt, dt); integrate(ship); }
|
|
const hd0 = wrap(ship.rotation - (ship.artOffset || 0));
|
|
let hd = hd0 > Math.PI ? hd0 - TAU : hd0;
|
|
check(`rotates toward direction of travel (heading=${hd.toFixed(3)} rad, want ~0)`,
|
|
Math.abs(hd) < 0.3);
|
|
}
|
|
|
|
// --- Test 3: re-target mid-flight -------------------------------------------
|
|
{
|
|
const ship = new Ship(scene, 100, 100);
|
|
ship.setTarget(900, 100);
|
|
for (let t = 0; t < 30; t++) { ship.update(t * dt, dt); integrate(ship); }
|
|
ship.setTarget(100, 500);
|
|
for (let t = 30; t < 30 + 60 * 20; t++) { ship.update(t * dt, dt); integrate(ship); }
|
|
const d = Math.hypot(ship.x - 100, ship.y - 500);
|
|
check(`re-target mid-flight reaches new point (dist=${d.toFixed(2)})`, d <= 8.5);
|
|
}
|
|
|
|
// --- Test 4: coasting drift decays to rest ----------------------------------
|
|
{
|
|
const ship = new Ship(scene, 300, 300);
|
|
ship.body.velocity.set(200, 0);
|
|
let stopped = false;
|
|
for (let t = 0; t < 60 * 10; t++) {
|
|
ship.update(t * dt, dt);
|
|
integrate(ship);
|
|
if (ship.body.velocity.length() < 1) { stopped = true; break; }
|
|
}
|
|
check('coasting drift decays to rest', stopped);
|
|
}
|
|
|
|
// --- Test 5: stop() hard-brakes ---------------------------------------------
|
|
{
|
|
const ship = new Ship(scene, 300, 300);
|
|
ship.setTarget(800, 300);
|
|
for (let t = 0; t < 10; t++) { ship.update(t * dt, dt); integrate(ship); }
|
|
ship.stop();
|
|
check('stop() clears target and zeroes velocity',
|
|
ship.target === null && ship.body.velocity.length() === 0);
|
|
}
|
|
|
|
// --- Test 6: arrives facing the direction of travel ------------------------
|
|
{
|
|
const angDiff = (a, b) => {
|
|
let d = wrap(a - b);
|
|
if (d > Math.PI) d -= TAU;
|
|
return Math.abs(d);
|
|
};
|
|
|
|
// Straight trip from rest: must end facing the way it flew.
|
|
{
|
|
const ship = new Ship(scene, 100, 100);
|
|
const target = { x: 900, y: 100 };
|
|
ship.setTarget(target.x, target.y);
|
|
for (let t = 0; t < 60 * 30; t++) {
|
|
ship.update(t * dt, dt);
|
|
integrate(ship);
|
|
if (ship.target === null) break;
|
|
}
|
|
const want = Math.atan2(target.y - 100, target.x - 100);
|
|
check(`straight trip: stops facing direction of travel (heading=${wrap(ship.rotation - (ship.artOffset || 0)).toFixed(3)} rad, want ${want.toFixed(3)})`,
|
|
ship.target === null && angDiff(ship.rotation - (ship.artOffset || 0), want) < 0.25);
|
|
}
|
|
|
|
// Diagonal trip from rest: must end facing the diagonal it flew.
|
|
{
|
|
const ship = new Ship(scene, 100, 100);
|
|
const target = { x: 700, y: 500 };
|
|
ship.setTarget(target.x, target.y);
|
|
for (let t = 0; t < 60 * 30; t++) {
|
|
ship.update(t * dt, dt);
|
|
integrate(ship);
|
|
if (ship.target === null) break;
|
|
}
|
|
const want = Math.atan2(target.y - 100, target.x - 100);
|
|
check(`diagonal trip: stops facing direction of travel (heading=${wrap(ship.rotation - (ship.artOffset || 0)).toFixed(3)} rad, want ${want.toFixed(3)})`,
|
|
ship.target === null && angDiff(ship.rotation - (ship.artOffset || 0), want) < 0.25);
|
|
}
|
|
|
|
// Fast ship re-targeted close ahead: still ends facing its travel direction.
|
|
{
|
|
const ship = new Ship(scene, 100, 100);
|
|
ship.setTarget(2000, 100);
|
|
for (let t = 0; t < 40; t++) { ship.update(t * dt, dt); integrate(ship); }
|
|
const target = { x: 400, y: 100 };
|
|
ship.setTarget(target.x, target.y);
|
|
for (let t = 40; t < 40 + 60 * 30; t++) {
|
|
ship.update(t * dt, dt);
|
|
integrate(ship);
|
|
if (ship.target === null) break;
|
|
}
|
|
const want = Math.atan2(target.y - 100, target.x - 100);
|
|
const d = Math.hypot(ship.x - target.x, ship.y - target.y);
|
|
check(`fast re-target: arrives (dist=${d.toFixed(2)}) facing direction of travel (heading=${wrap(ship.rotation - (ship.artOffset || 0)).toFixed(3)} rad, want ${want.toFixed(3)})`,
|
|
ship.target === null && d <= 8.5 && angDiff(ship.rotation - (ship.artOffset || 0), want) < 0.25);
|
|
}
|
|
}
|
|
|
|
console.log(failures === 0 ? '\nAll ship behavior tests passed ✔' : `\n${failures} test(s) FAILED ✘`);
|
|
process.exit(failures === 0 ? 0 : 1);
|