291 lines
11 KiB
TypeScript
291 lines
11 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import { describe, it } from "node:test";
|
|
import * as THREE from "three";
|
|
import {
|
|
AircraftController,
|
|
ELECTRIC_AIRCRAFT_METRICS,
|
|
aircraftChaseCameraPose,
|
|
advanceAircraftFans,
|
|
buildElectricAircraft,
|
|
createElectricAircraftMaterials,
|
|
disposeElectricAircraft,
|
|
normalizeAircraftActions,
|
|
replayAircraftInputs,
|
|
setAircraftControlSurfaces,
|
|
setAircraftFanRotation,
|
|
} from "../aircraft/index.ts";
|
|
|
|
const ROUTE = [
|
|
{ id: "los-angeles", lat: 34.0522, lng: -118.2437, altitudeM: 1_300 },
|
|
{ id: "san-francisco", lat: 37.7749, lng: -122.4194, altitudeM: 1_700 },
|
|
] as const;
|
|
|
|
describe("procedural electric aircraft", () => {
|
|
it("builds an original metre-scale fixed wing facing -Z with articulated parts", () => {
|
|
const rig = buildElectricAircraft();
|
|
assert.equal(rig.root.name, "electric-aircraft");
|
|
assert.equal(rig.root.userData.forwardAxis, "-Z");
|
|
assert.equal(rig.root.userData.aircraftModel, "electric-vtail");
|
|
assert.equal(rig.fans.length, 6);
|
|
assert.equal(rig.ownsMaterials, true);
|
|
assert.ok(ELECTRIC_AIRCRAFT_METRICS.wingspan > ELECTRIC_AIRCRAFT_METRICS.length);
|
|
const bounds = new THREE.Box3().setFromObject(rig.root);
|
|
const size = bounds.getSize(new THREE.Vector3());
|
|
assert.ok(size.x > 10);
|
|
assert.ok(size.z > 7);
|
|
assert.ok(size.y > 1.5);
|
|
assert.ok(rig.leftAileron.position.z <= 0.6, "left aileron remains attached to tapered trailing edge");
|
|
assert.ok(rig.rightAileron.position.z <= 0.6, "right aileron remains attached to tapered trailing edge");
|
|
const wing = rig.root.getObjectByName("electric-aircraft:wing");
|
|
assert.ok(wing instanceof THREE.Mesh);
|
|
const normals = wing.geometry.getAttribute("normal");
|
|
assert.ok(normals && Array.from({ length: normals.count }, (_, index) => normals.getY(index)).some((y) => y > 0.5),
|
|
"wing has a readable upper airfoil surface");
|
|
assert.ok(normals && Array.from({ length: normals.count }, (_, index) => normals.getY(index)).some((y) => y < -0.5),
|
|
"wing is a closed prism that remains visible from below");
|
|
assert.ok(rig.root.getObjectByName("electric-aircraft:canopy-spine"));
|
|
assert.ok(rig.root.getObjectByName("electric-aircraft:nav-left"));
|
|
assert.ok(rig.root.getObjectByName("electric-aircraft:gear-door-left"));
|
|
disposeElectricAircraft(rig);
|
|
assert.equal(rig.root.children.length, 0);
|
|
});
|
|
|
|
it("distributes every fan blade evenly around its hub", () => {
|
|
const rig = buildElectricAircraft();
|
|
for (const fan of rig.fans) {
|
|
const blades = fan.children.filter((child) => child.name.includes(":blade-"));
|
|
assert.equal(blades.length, 5);
|
|
const centroid = blades.reduce(
|
|
(sum, blade) => sum.add(blade.position),
|
|
new THREE.Vector3(),
|
|
).multiplyScalar(1 / blades.length);
|
|
assert.ok(centroid.length() < 1e-12, `fan centroid ${centroid.toArray()}`);
|
|
for (const blade of blades) {
|
|
assert.ok(Math.abs(blade.position.length() - 0.25) < 1e-12);
|
|
const radial = new THREE.Vector3(0, 1, 0).applyQuaternion(blade.quaternion);
|
|
assert.ok(radial.angleTo(blade.position.clone().normalize()) < 1e-7);
|
|
}
|
|
}
|
|
disposeElectricAircraft(rig);
|
|
});
|
|
|
|
it("animates opposing ailerons, V-tail surfaces, and electric fans", () => {
|
|
const rig = buildElectricAircraft();
|
|
setAircraftControlSurfaces(rig, { roll: 0.8, pitch: 0.5, yaw: -0.4 });
|
|
assert.ok(rig.leftAileron.rotation.x > 0);
|
|
assert.ok(rig.rightAileron.rotation.x < 0);
|
|
assert.notEqual(rig.leftVTail.rotation.x, rig.rightVTail.rotation.x);
|
|
setAircraftFanRotation(rig, 1);
|
|
advanceAircraftFans(rig, 0.5);
|
|
assert.equal(rig.fans[0]?.rotation.z, 1.5);
|
|
assert.equal(rig.fans[1]?.rotation.z, 1.5);
|
|
disposeElectricAircraft(rig);
|
|
});
|
|
|
|
it("does not dispose caller-owned materials", () => {
|
|
const materials = createElectricAircraftMaterials();
|
|
let disposals = 0;
|
|
for (const material of Object.values(materials)) {
|
|
material.addEventListener("dispose", () => { disposals += 1; });
|
|
}
|
|
const rig = buildElectricAircraft({ materials });
|
|
assert.equal(rig.ownsMaterials, false);
|
|
disposeElectricAircraft(rig);
|
|
assert.equal(disposals, 0);
|
|
for (const material of Object.values(materials)) material.dispose();
|
|
});
|
|
});
|
|
|
|
describe("aircraft controller", () => {
|
|
it("normalizes device-neutral flight axes", () => {
|
|
assert.deepEqual(normalizeAircraftActions({
|
|
throttle: 5,
|
|
yaw: -4,
|
|
pitch: Number.NaN,
|
|
roll: 2,
|
|
modeRequest: "manual",
|
|
reset: true,
|
|
}), {
|
|
throttle: 1,
|
|
yaw: -1,
|
|
pitch: 0,
|
|
roll: 1,
|
|
modeRequest: "manual",
|
|
reset: true,
|
|
});
|
|
});
|
|
|
|
it("follows route and altitude deterministically in assisted mode", () => {
|
|
const options = {
|
|
route: ROUTE,
|
|
initialPosition: ROUTE[0],
|
|
initialHeadingDeg: 0,
|
|
initialAltitudeM: 900,
|
|
assistedAltitudeM: 1_300,
|
|
};
|
|
const a = new AircraftController(options);
|
|
const b = new AircraftController(options);
|
|
for (let index = 0; index < 600; index += 1) {
|
|
a.stepFixed();
|
|
b.stepFixed();
|
|
}
|
|
assert.deepEqual(a.snapshot(), b.snapshot());
|
|
assert.equal(a.state().mode, "assisted");
|
|
assert.equal(a.state().routeWaypointId, "san-francisco");
|
|
assert.ok(a.state().altitudeM > 900);
|
|
assert.ok(a.state().headingDeg > 180, "aircraft turns northwest toward San Francisco");
|
|
});
|
|
|
|
it("takes manual input immediately and resumes assistance without a state jump", () => {
|
|
const controller = new AircraftController({ route: ROUTE });
|
|
for (let index = 0; index < 120; index += 1) {
|
|
controller.stepFixed({ throttle: 0.8, roll: 0.7, pitch: -0.3 });
|
|
}
|
|
assert.equal(controller.state().mode, "manual");
|
|
const before = controller.snapshot();
|
|
controller.stepFixed({ modeRequest: "assisted", roll: 0.8 });
|
|
assert.equal(controller.state().mode, "manual", "manual controls beat simultaneous resume");
|
|
controller.stepFixed({ modeRequest: "assisted" });
|
|
assert.equal(controller.state().mode, "assisted");
|
|
assert.ok(Math.abs(controller.state().rollDeg - before.rollDeg) < 3);
|
|
assert.ok(Math.abs(controller.state().pitchDeg - before.pitchDeg) < 3);
|
|
});
|
|
|
|
it("enforces geographic, altitude, and speed boundaries", () => {
|
|
const controller = new AircraftController({
|
|
mode: "manual",
|
|
initialPosition: { lat: 100, lng: -200 },
|
|
initialAltitudeM: 100_000,
|
|
initialSpeedMps: 1_000,
|
|
maximumSpeedMps: 80,
|
|
});
|
|
assert.equal(controller.state().lat, 42.1);
|
|
assert.equal(controller.state().lng, -124.6);
|
|
assert.equal(controller.state().altitudeM, 6_000);
|
|
assert.equal(controller.state().speedMps, 80);
|
|
for (let index = 0; index < 180; index += 1) {
|
|
controller.stepFixed({ throttle: 1, pitch: 1, roll: 1 });
|
|
}
|
|
assert.ok(controller.state().lat >= 32.4 && controller.state().lat <= 42.1);
|
|
assert.ok(controller.state().lng >= -124.6 && controller.state().lng <= -114);
|
|
assert.ok(controller.state().altitudeM >= 75 && controller.state().altitudeM <= 6_000);
|
|
assert.ok(controller.state().speedMps <= 80);
|
|
assert.equal(controller.state().envelopeContact, true);
|
|
});
|
|
|
|
it("models deterministic wind, energy use, lift telemetry, and stalls", () => {
|
|
const options = {
|
|
mode: "manual" as const,
|
|
initialSpeedMps: 20,
|
|
minimumSpeedMps: 18,
|
|
stallSpeedMps: 25,
|
|
windNorthMps: 7,
|
|
windEastMps: -4,
|
|
turbulenceMps: 2,
|
|
batteryCapacityWh: 2_000,
|
|
fixedStepSeconds: 0.05,
|
|
};
|
|
const a = new AircraftController(options);
|
|
const b = new AircraftController(options);
|
|
for (let index = 0; index < 200; index += 1) {
|
|
a.stepFixed({ throttle: 0.15, pitch: 0.7, roll: 0.2 });
|
|
b.stepFixed({ throttle: 0.15, pitch: 0.7, roll: 0.2 });
|
|
}
|
|
assert.deepEqual(a.snapshot(), b.snapshot());
|
|
assert.equal(a.state().stalled, true);
|
|
assert.ok(a.state().angleOfAttackDeg > 0);
|
|
assert.ok(a.state().verticalSpeedMps < 0, "a deep low-speed stall loses altitude");
|
|
assert.ok(a.state().energyUsedWh > 0);
|
|
assert.ok(a.state().batteryWh < 2_000);
|
|
assert.notEqual(a.state().windNorthMps, 7, "deterministic turbulence perturbs scenario wind");
|
|
assert.ok(Number.isFinite(a.state().loadFactorG));
|
|
});
|
|
|
|
it("uses deterministic terrain contact and reports a hard landing", () => {
|
|
const controller = new AircraftController({
|
|
mode: "manual",
|
|
envelope: {
|
|
minLat: 30,
|
|
maxLat: 45,
|
|
minLng: -130,
|
|
maxLng: -110,
|
|
minAltitudeM: 0,
|
|
maxAltitudeM: 6_000,
|
|
},
|
|
initialAltitudeM: 104,
|
|
initialSpeedMps: 22,
|
|
minimumSpeedMps: 18,
|
|
stallSpeedMps: 26,
|
|
terrainElevationM: () => 100,
|
|
fixedStepSeconds: 0.1,
|
|
});
|
|
let touched = false;
|
|
let hard = false;
|
|
for (let index = 0; index < 120; index += 1) {
|
|
controller.stepFixed({ throttle: 0, pitch: -1 });
|
|
touched ||= controller.state().onGround;
|
|
hard ||= controller.state().hardLanding;
|
|
}
|
|
assert.equal(touched, true);
|
|
assert.equal(hard, true);
|
|
assert.equal(controller.state().groundClearanceM, 0);
|
|
assert.equal(controller.state().altitudeM, 100);
|
|
assert.equal(controller.state().verticalSpeedMps, 0);
|
|
});
|
|
|
|
it("resets exactly, caps sleeping-tab time, and replays bit-for-bit", () => {
|
|
const options = { route: ROUTE, initialAltitudeM: 1_200, initialSpeedMps: 48 } as const;
|
|
const controller = new AircraftController(options);
|
|
const spawn = controller.snapshot();
|
|
assert.ok(controller.tick(600) <= 15);
|
|
controller.stepFixed({ throttle: 1, roll: -1 });
|
|
controller.stepFixed({ reset: true });
|
|
assert.deepEqual(controller.snapshot(), spawn);
|
|
|
|
const frames = [
|
|
{ steps: 90, actions: { throttle: 0.9, roll: 0.4 } },
|
|
{ steps: 1, actions: { modeRequest: "assisted" as const } },
|
|
{ steps: 180 },
|
|
];
|
|
assert.deepEqual(
|
|
replayAircraftInputs(options, frames),
|
|
replayAircraftInputs(options, frames),
|
|
);
|
|
});
|
|
|
|
it("derives a finite geographic chase camera behind the aircraft", () => {
|
|
const controller = new AircraftController({ initialHeadingDeg: 0 });
|
|
const camera = aircraftChaseCameraPose(controller.state());
|
|
assert.ok(camera.position.lat < controller.state().lat);
|
|
assert.ok(camera.target.lat > controller.state().lat);
|
|
assert.ok(camera.position.altitudeM > controller.state().altitudeM);
|
|
assert.ok(Object.values(camera.position).every(Number.isFinite));
|
|
assert.ok(Object.values(camera.target).every(Number.isFinite));
|
|
});
|
|
|
|
it("rejects malformed route and envelope configuration", () => {
|
|
assert.throws(() => new AircraftController({
|
|
route: [{ id: "bad", lat: Number.NaN, lng: 0, altitudeM: 1_000 }],
|
|
}), /waypoints/);
|
|
assert.throws(() => new AircraftController({
|
|
route: [{ id: "outside-california", lat: 45, lng: -118, altitudeM: 1_000 }],
|
|
}), /waypoints/);
|
|
assert.throws(() => new AircraftController({
|
|
route: [{ id: "above-envelope", lat: 37, lng: -122, altitudeM: 8_000 }],
|
|
}), /waypoints/);
|
|
assert.throws(() => new AircraftController({
|
|
envelope: {
|
|
minLat: 40,
|
|
maxLat: 30,
|
|
minLng: -124,
|
|
maxLng: -114,
|
|
minAltitudeM: 10,
|
|
maxAltitudeM: 100,
|
|
},
|
|
}), /envelope/);
|
|
assert.throws(() => new AircraftController({
|
|
terrainElevationM: 3 as unknown as (lat: number, lng: number) => number,
|
|
}), /terrain/);
|
|
});
|
|
});
|