xeno/Portfolio
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f9b515c3a04c50f92e39c4fa987bfd76637b183d
Portfolio/tests/unit/traffic-model.test.ts

704 lines
29 KiB
TypeScript
Raw Blame History

import { describe, expect, it } from 'vitest';
import type { EnvironmentChapter } from '@/journey/types';
import {
BRAKE_GLOBAL_PER_SECOND,
BRAKE_MIN_ON_SECONDS,
BRAKE_MIN_SPACING_SECONDS,
CENTRE_DEADLINE_Z,
CENTRE_ENTRY_Z,
FADE_IN_SECONDS,
FORCED_LANE_CHANGE_SECONDS,
HERO_HALF_WIDTH,
HERO_NOSE_Z,
HERO_TAIL_Z,
INDICATOR_DUTY,
INDICATOR_HZ,
TRAFFIC_ASPHALT_HALF_WIDTH,
TRAFFIC_BEHIND,
TRAFFIC_CONVOY_GAP_MAX,
TRAFFIC_LITE_CONVOY_NEAR_Z,
TRAFFIC_LITE_DROUGHT_SECONDS,
TRAFFIC_LITE_STAGE_SECONDS,
TRAFFIC_DENSITY,
TRAFFIC_ENTRY_FAR_Z,
TRAFFIC_ENTRY_NEAR_Z,
TRAFFIC_ENTRY_NEAR_SPAN,
TRAFFIC_EXIT_NOSE_Z,
TRAFFIC_KINDS,
TRAFFIC_LANE_X,
TRAFFIC_NEAR_CAMERA_SIDE,
TRAFFIC_NEAR_OPEN,
TRAFFIC_PENDING,
TRAFFIC_TRUCK,
TRAFFIC_VISIBLE,
createFlashDetector,
createTrafficModel,
indicatorBlink,
type TrafficConfig,
type TrafficFrame,
type TrafficInput,
} from '@/scene/world/traffic-model';
const CRUISE = 18 + 0.18 * 54;
const CHAPTERS: EnvironmentChapter[] = ['deep-night', 'systems', 'infrastructure', 'builds', 'pre-dawn', 'destination'];
const input = (patch: Partial<TrafficInput> = {}): TrafficInput => ({
dt: 1 / 60,
heroSpeed: CRUISE,
chapter: 'deep-night',
sweeping: false,
flash: false,
cameraX: -5.6,
engineOff: 0,
...patch,
});
const drawn = (f: TrafficFrame, i: number): boolean => f.active[i] !== TRAFFIC_PENDING && f.active[i] !== TRAFFIC_BEHIND;
const size = (f: TrafficFrame, i: number) => TRAFFIC_KINDS[f.kind[i]!]!;
/** Invariants 1-4 and the lamp limits for one frame; returns a message or null. */
function violation(f: TrafficFrame): string | null {
let corridor = 0;
let indicators = 0;
for (let i = 0; i < f.count; i += 1) {
if (f.active[i] === TRAFFIC_PENDING) continue;
const { halfWidth, length } = size(f, i);
const x = f.x[i]!;
const z = f.z[i]!;
if (!Number.isFinite(x) || !Number.isFinite(z)) return `vehicle ${i} non-finite`;
if (Math.abs(x) + halfWidth > TRAFFIC_ASPHALT_HALF_WIDTH) return `vehicle ${i} off the asphalt at x ${x}`;
const inCorridor = Math.abs(x) < HERO_HALF_WIDTH + halfWidth;
if (inCorridor && z > HERO_NOSE_Z && z - length < HERO_TAIL_Z) return `vehicle ${i} overlaps the hero at x ${x} z ${z}`;
if (inCorridor && f.active[i] !== TRAFFIC_BEHIND) corridor += 1;
if (f.indicator[i] !== 0) indicators += 1;
for (let j = i + 1; j < f.count; j += 1) {
if (f.active[j] === TRAFFIC_PENDING) continue;
const other = size(f, j);
const lateral = Math.abs(x - f.x[j]!) < halfWidth + other.halfWidth;
const along = z > f.z[j]! - other.length && f.z[j]! > z - length;
if (lateral && along) return `vehicles ${i} and ${j} overlap (x ${x}/${f.x[j]} z ${z}/${f.z[j]})`;
}
}
if (corridor > 1) return `${corridor} vehicles in the centre lane`;
if (indicators > 2) return `${indicators} indicators at once`;
return null;
}
/** A small deterministic generator for the drive scripts. */
function rng(seed: number) {
let s = seed % 2147483647 || 1;
return () => {
s = (s * 48271) % 2147483647;
return (s - 1) / 2147483646;
};
}
describe('traffic model: long randomised drives', () => {
it('never overlaps, stays on the asphalt and keeps the lamp limits (20 seeds x 10 min)', () => {
for (let seed = 1; seed <= 20; seed += 1) {
const pool = ([12, 10, 6] as const)[seed % 3]!;
const model = createTrafficModel({ pool, seed: seed * 7919, lite: pool === 6 });
const random = rng(seed * 104729);
const step = input();
let time = 0;
let hero = CRUISE;
let target = CRUISE;
let nextSpeed = 0;
let nextChapter = 20;
let nextFlash = 3;
let sweepUntil = -1;
const onsetsAt: number[] = [];
const lastOnset = new Float64Array(pool).fill(Number.NEGATIVE_INFINITY);
const brakeWas = new Uint8Array(pool);
const brakeOnAt = new Float64Array(pool);
const lastZ = new Float64Array(pool);
let previousOnsets = 0;
const end = 600;
while (time < end) {
const dt = random() < 0.01 ? 0.1 : 1 / 60;
time += dt;
if (time >= nextSpeed) {
const roll = random();
target = roll < 0.35 ? CRUISE : roll < 0.6 ? 120 : 18 + random() * 102;
if (random() < 0.4) hero = target; // instant steps
nextSpeed = time + 0.3 + random() * 3.7;
}
hero += (target - hero) * Math.min(1, dt * 3);
if (time >= nextChapter) {
step.chapter = CHAPTERS[Math.floor(random() * CHAPTERS.length)]!;
// A chapter entry: lite stages a pass (the invariants hold through it).
step.cue = true;
nextChapter = time + 20 + random() * 40;
if (random() < 0.4) sweepUntil = time + 0.5 + random();
}
step.flash = time >= nextFlash;
if (step.flash) nextFlash = time + 0.6 + random() * 5;
step.sweeping = time < sweepUntil;
step.engineOff = time > end - 30 ? Math.min(1, (time - (end - 30)) / 10) : 0;
if (step.engineOff > 0) step.chapter = 'destination';
step.heroSpeed = hero * (1 - step.engineOff);
step.cameraX = Math.sin(time * 0.05) * 5.6;
step.dt = dt;
const f = model.step(step);
step.cue = false;
const problem = violation(f);
if (problem) throw new Error(`seed ${seed} t ${time.toFixed(2)}: ${problem}`);
const events = model.events();
if (events.brakeOnsets > previousOnsets) {
for (let k = previousOnsets; k < events.brakeOnsets; k += 1) onsetsAt.push(time);
previousOnsets = events.brakeOnsets;
}
for (let i = 0; i < pool; i += 1) {
const on = f.brake[i]! > 0 ? 1 : 0;
const respawned = Math.abs(f.z[i]! - lastZ[i]!) > 20;
lastZ[i] = f.z[i]!;
if (on === 1 && brakeWas[i] === 0 && !respawned) {
expect(time - lastOnset[i]!).toBeGreaterThanOrEqual(BRAKE_MIN_SPACING_SECONDS - 1e-6);
lastOnset[i] = time;
brakeOnAt[i] = time;
}
if (on === 0 && brakeWas[i] === 1 && f.active[i] !== TRAFFIC_PENDING && !respawned) {
// The lamp has ramped down to zero: it was held on for the minimum first.
expect(time - brakeOnAt[i]!).toBeGreaterThanOrEqual(BRAKE_MIN_ON_SECONDS);
}
brakeWas[i] = on;
}
}
for (let k = BRAKE_GLOBAL_PER_SECOND; k < onsetsAt.length; k += 1) {
expect(onsetsAt[k]! - onsetsAt[k - BRAKE_GLOBAL_PER_SECOND]!).toBeGreaterThanOrEqual(1 - 1e-6);
}
const events = model.events();
expect(events.laneChanges, `seed ${seed} lane changes`).toBeGreaterThan(0);
expect(events.passes, `seed ${seed} passes`).toBeGreaterThan(0);
expect(events.brakeOnsets, `seed ${seed} brake onsets`).toBeGreaterThan(0);
expect(events.emergencyExits, `seed ${seed} emergency exits`).toBeLessThanOrEqual(1);
}
});
});
describe('traffic model: adversarial', () => {
/** Drive the model until a car is in the centre lane, then return it. */
function withCentreCar(config: TrafficConfig) {
const model = createTrafficModel(config);
const step = input({ chapter: 'infrastructure' });
for (let t = 0; t < 400; t += 1 / 60) {
const f = model.step(step);
for (let i = 0; i < f.count; i += 1) {
if (drawn(f, i) && Math.abs(f.x[i]!) < 0.5) return { model, step, index: i };
}
}
throw new Error('no overtake in 400 s');
}
it('a right-lane car pulls into the centre to pass a truck at idle', () => {
const { model, index } = withCentreCar({ pool: 12, seed: 3, lite: false });
expect(model.frame.kind[index]).toBe(0);
expect(model.frame.z[index]!).toBeLessThan(-150);
});
it('an instant step to 120 u/s with a car in the centre still never overlaps', () => {
for (const seed of [3, 11, 29, 41]) {
const { model, step, index } = withCentreCar({ pool: 12, seed, lite: false });
step.heroSpeed = 120;
for (let t = 0; t < 12; t += 1 / 60) {
const f = model.step(step);
expect(violation(f)).toBeNull();
}
expect(Math.abs(model.frame.x[index]!) > 4 || model.frame.active[index] !== TRAFFIC_VISIBLE).toBe(true);
}
});
it('0.1 s frames at 120 u/s keep every invariant', () => {
const model = createTrafficModel({ pool: 12, seed: 5, lite: false });
const step = input({ chapter: 'infrastructure', dt: 0.1, heroSpeed: 120 });
for (let k = 0; k < 3000; k += 1) {
step.heroSpeed = k % 40 < 20 ? 120 : CRUISE;
expect(violation(model.step(step))).toBeNull();
}
});
it('clamps dt and ignores non-finite input', () => {
const model = createTrafficModel({ pool: 10, seed: 9, lite: false });
model.step(input());
const before = Array.from(model.frame.z);
model.step(input({ dt: Number.NaN, heroSpeed: Number.NaN, cameraX: Number.POSITIVE_INFINITY, engineOff: Number.NaN }));
expect(Array.from(model.frame.z)).toEqual(before);
model.step(input({ dt: 5 }));
for (let i = 0; i < model.frame.count; i += 1) {
if (model.frame.active[i] === TRAFFIC_PENDING) continue;
// At most one 0.1 s step of relative motion (40 u/s fast lane - 27.7 + jitter).
expect(Math.abs(model.frame.z[i]! - before[i]!)).toBeLessThan(4);
}
expect(violation(model.frame)).toBeNull();
});
});
describe('traffic model: determinism and allocation', () => {
it('the same seed and inputs give the same frames', () => {
const run = () => {
const model = createTrafficModel({ pool: 12, seed: 77, lite: false });
const out: number[] = [];
for (let k = 0; k < 3600; k += 1) {
const f = model.step(input({ heroSpeed: k % 600 < 300 ? CRUISE : 90, chapter: k < 1800 ? 'systems' : 'infrastructure' }));
if (k % 60 === 0) out.push(...f.z, ...f.x, ...f.active);
}
return out;
};
expect(run()).toEqual(run());
});
it('returns the same preallocated frame every step', () => {
const model = createTrafficModel({ pool: 6, seed: 2, lite: true });
const first = model.step(input());
const z = first.z;
for (let k = 0; k < 600; k += 1) expect(model.step(input())).toBe(first);
expect(first.z).toBe(z);
expect(model.frame).toBe(first);
});
it('freezes its tables', () => {
expect(Object.isFrozen(TRAFFIC_LANE_X)).toBe(true);
expect(Object.isFrozen(TRAFFIC_KINDS)).toBe(true);
expect(Object.isFrozen(TRAFFIC_DENSITY)).toBe(true);
expect(Object.isFrozen(TRAFFIC_DENSITY.infrastructure)).toBe(true);
});
it('reset replays the run', () => {
const model = createTrafficModel({ pool: 10, seed: 13, lite: false });
const take = () => {
for (let k = 0; k < 1200; k += 1) model.step(input({ chapter: 'builds' }));
return Array.from(model.frame.z);
};
const a = take();
model.reset();
expect(take()).toEqual(a);
});
});
describe('traffic model: density', () => {
const visible = (f: TrafficFrame, side: number, truck?: boolean): number => {
let count = 0;
for (let i = 0; i < f.count; i += 1) {
if (f.active[i] !== TRAFFIC_VISIBLE) continue;
if (Math.sign(f.x[i]!) !== side) continue;
if (truck !== undefined && (f.kind[i] === TRAFFIC_TRUCK) !== truck) continue;
count += 1;
}
return count;
};
it('converges to each chapter target within 30 s at cruise', () => {
for (const chapter of CHAPTERS) {
const model = createTrafficModel({ pool: 12, seed: 21, lite: false });
let f = model.frame;
for (let t = 0; t < 30; t += 1 / 60) f = model.step(input({ chapter }));
const want = TRAFFIC_DENSITY[chapter];
// Vehicles mid-pass on the hero's side may sit in the centre, so allow one short.
expect(visible(f, -1), `${chapter} left`).toBeGreaterThanOrEqual(want.left - 1);
expect(visible(f, -1), `${chapter} left`).toBeLessThanOrEqual(want.left + 1);
expect(visible(f, 1) + visible(f, 0), `${chapter} right`).toBeGreaterThanOrEqual(want.right - 1);
}
});
it('never despawns a drawn vehicle on screen when the chapter thins out', () => {
const model = createTrafficModel({ pool: 12, seed: 4, lite: false });
for (let t = 0; t < 30; t += 1 / 60) model.step(input({ chapter: 'infrastructure' }));
for (let t = 0; t < 20; t += 1 / 60) {
const before = Array.from(model.frame.active);
const z = Array.from(model.frame.z);
const f = model.step(input({ chapter: 'destination' }));
for (let i = 0; i < f.count; i += 1) {
if (before[i] === TRAFFIC_VISIBLE && f.active[i] === TRAFFIC_PENDING) {
// Leaving is only allowed at the far haze or behind the camera.
expect(z[i]! < -600 || z[i]! - size(f, i).length > TRAFFIC_EXIT_NOSE_Z - 1).toBe(true);
}
}
}
});
it('empties the road once the engine is off', () => {
const model = createTrafficModel({ pool: 12, seed: 8, lite: false });
for (let t = 0; t < 120; t += 1 / 60) model.step(input({ chapter: 'destination', engineOff: 1, heroSpeed: 0 }));
// Nothing new enters; what is left drives off.
const events = model.events();
let drawnNow = 0;
for (let i = 0; i < model.frame.count; i += 1) if (drawn(model.frame, i)) drawnNow += 1;
expect(drawnNow).toBeLessThanOrEqual(2);
expect(events.laneChanges).toBe(0);
});
it('the low tier caps trucks and lanes', () => {
const model = createTrafficModel({ pool: 6, seed: 6, lite: true });
let maxTrucks = 0;
let maxRight = 0;
for (let t = 0; t < 300; t += 1 / 60) {
const f = model.step(input({ chapter: 'infrastructure', heroSpeed: t % 40 < 10 ? 90 : CRUISE }));
maxTrucks = Math.max(maxTrucks, visible(f, 1, true) + visible(f, -1, true));
maxRight = Math.max(maxRight, visible(f, 1));
}
expect(maxTrucks).toBeLessThanOrEqual(2);
expect(maxRight).toBeLessThanOrEqual(5);
});
});
describe('traffic model: interaction', () => {
it('a flash sends a centre-lane car back to its lane', () => {
for (const seed of [3, 11, 29]) {
const model = createTrafficModel({ pool: 12, seed, lite: false });
const step = input({ chapter: 'infrastructure' });
let index = -1;
for (let t = 0; t < 400 && index < 0; t += 1 / 60) {
const f = model.step(step);
for (let i = 0; i < f.count; i += 1) if (drawn(f, i) && Math.abs(f.x[i]!) < 0.5 && f.z[i]! > -320) index = i;
}
if (index < 0) continue;
model.step(input({ chapter: 'infrastructure', flash: true }));
for (let t = 0; t < 2.5; t += 1 / 60) model.step(step);
expect(Math.abs(model.frame.x[index]!), `seed ${seed}`).toBeGreaterThan(4);
return;
}
throw new Error('no centre-lane car within flash reach');
});
it('sweeping starts no manoeuvre', () => {
const model = createTrafficModel({ pool: 12, seed: 3, lite: false });
for (let t = 0; t < 300; t += 1 / 60) model.step(input({ chapter: 'infrastructure', sweeping: true }));
expect(model.events().laneChanges).toBe(0);
});
it('nothing in the centre lane survives past the deadline', () => {
const model = createTrafficModel({ pool: 12, seed: 17, lite: false });
for (let t = 0; t < 600; t += 1 / 60) {
const f = model.step(input({ chapter: 'infrastructure', heroSpeed: Math.floor(t / 7) % 2 ? 110 : CRUISE }));
for (let i = 0; i < f.count; i += 1) {
if (f.active[i] !== TRAFFIC_VISIBLE) continue;
if (Math.abs(f.x[i]!) < HERO_HALF_WIDTH + size(f, i).halfWidth) expect(f.z[i]!).toBeLessThan(CENTRE_DEADLINE_Z + 160);
}
}
});
});
describe('traffic model: idle choreography', () => {
it('a left-lane car passes the reader within 60 s and a right-lane truck is passed', () => {
const model = createTrafficModel({ pool: 12, seed: 1, lite: false });
const mid = new Float64Array(12).fill(Number.NaN);
let leftPass = false;
let truckPassed = false;
for (let t = 0; t < 90; t += 1 / 60) {
const f = model.step(input({ chapter: 'deep-night' }));
for (let i = 0; i < f.count; i += 1) {
if (f.active[i] === TRAFFIC_PENDING) {
mid[i] = Number.NaN;
continue;
}
const now = f.z[i]! - size(f, i).length / 2;
const was = mid[i]!;
if (Number.isFinite(was)) {
if (t < 60 && f.x[i]! < -3 && was > 2 && now <= 2) leftPass = true;
if (f.kind[i] === TRAFFIC_TRUCK && f.x[i]! > 3 && was < 2 && now >= 2) truckPassed = true;
}
mid[i] = now;
}
}
expect(leftPass).toBe(true);
expect(truckPassed).toBe(true);
});
});
describe('traffic model: lamps', () => {
it('indicators blink at 1.5 Hz with a 40 % duty', () => {
const period = 1 / INDICATOR_HZ;
let on = 0;
let rises = 0;
let was = 0;
const samples = 6000;
for (let k = 0; k < samples; k += 1) {
const level = indicatorBlink((k / samples) * period * 4);
if (level > 0.5) on += 1;
if (level > 0.5 && was <= 0.5) rises += 1;
was = level;
}
expect(on / samples).toBeCloseTo(INDICATOR_DUTY, 1);
expect(rises).toBe(4);
expect(indicatorBlink(0.02)).toBeGreaterThan(0);
});
it('the high-mount stop lamp is dark at steady cruise', () => {
const model = createTrafficModel({ pool: 12, seed: 31, lite: false });
for (let t = 0; t < 30; t += 1 / 60) model.step(input({ chapter: 'deep-night' }));
let lit = 0;
for (let i = 0; i < model.frame.count; i += 1) if (drawn(model.frame, i) && model.frame.brake[i]! > 0.5) lit += 1;
expect(lit).toBeLessThanOrEqual(1);
});
it('a queue behind a truck lights brake lamps, with hysteresis', () => {
const model = createTrafficModel({ pool: 12, seed: 2, lite: false });
for (let t = 0; t < 120; t += 1 / 60) model.step(input({ chapter: 'infrastructure' }));
expect(model.events().brakeOnsets).toBeGreaterThan(0);
// Brake levels stay in range.
for (let i = 0; i < model.frame.count; i += 1) {
expect(model.frame.brake[i]!).toBeGreaterThanOrEqual(0);
expect(model.frame.brake[i]!).toBeLessThanOrEqual(1);
}
});
});
describe('traffic model: near limit', () => {
it('latches a camera-side truck to the near band and leaves cars open', () => {
const model = createTrafficModel({ pool: 12, seed: 12, lite: false });
// Camera over the right lane: right-lane trucks are camera side.
let latched = false;
for (let t = 0; t < 200 && !latched; t += 1 / 60) {
const f = model.step(input({ chapter: 'infrastructure', cameraX: 4.5 }));
for (let i = 0; i < f.count; i += 1) {
if (!drawn(f, i)) continue;
if (f.kind[i] !== TRAFFIC_TRUCK) expect(f.nearLimit[i]).toBe(TRAFFIC_NEAR_OPEN);
else if (f.x[i]! > 3 && f.z[i]! > -40) {
expect(f.nearLimit[i]).toBe(TRAFFIC_NEAR_CAMERA_SIDE);
latched = true;
}
}
}
expect(latched).toBe(true);
});
it('a truck on the far side of the camera stays open', () => {
const model = createTrafficModel({ pool: 12, seed: 12, lite: false });
for (let t = 0; t < 200; t += 1 / 60) {
const f = model.step(input({ chapter: 'infrastructure', cameraX: -5.6 }));
for (let i = 0; i < f.count; i += 1) {
if (drawn(f, i) && f.x[i]! > 3) expect(f.nearLimit[i]).toBe(TRAFFIC_NEAR_OPEN);
}
}
});
it('keeps every lane on the asphalt and clear of the hero', () => {
for (const side of [0, 2]) {
for (const kind of TRAFFIC_KINDS) {
const x = TRAFFIC_LANE_X[side]!;
expect(Math.abs(x) + kind.halfWidth + 0.1).toBeLessThanOrEqual(TRAFFIC_ASPHALT_HALF_WIDTH);
expect(Math.abs(x) - kind.halfWidth - 0.1).toBeGreaterThanOrEqual(HERO_HALF_WIDTH);
}
}
expect(HERO_TAIL_Z - HERO_NOSE_Z).toBe(16);
});
});
describe('traffic model: the interaction is in frame', () => {
/** Centre-lane entries and exits (rear z) of right-lane cars over a cruise. */
function passes(config: TrafficConfig, seconds: number) {
const model = createTrafficModel(config);
const step = input({ chapter: 'infrastructure' });
const prev = new Float64Array(config.pool);
const entries: number[] = [];
const exits: number[] = [];
for (let t = 0; t < seconds; t += 1 / 60) {
const f = model.step(step);
for (let i = 0; i < f.count; i += 1) {
const x = f.active[i] === TRAFFIC_VISIBLE ? f.x[i]! : 9;
// A pull-out from the right lane (not a pooled slot reappearing in another lane).
if (prev[i]! > 3 && prev[i]! !== 9 && x <= 3) entries.push(f.z[i]!);
if (Math.abs(prev[i]!) <= 3 && Math.abs(x) > 3 && x !== 9) exits.push(f.z[i]!);
prev[i] = x;
}
}
return { entries, exits };
}
it('overtakes start 150-215 m ahead and end before the deadline, on every tier', () => {
const configs: TrafficConfig[] = [
{ pool: 12, seed: 3, lite: false },
{ pool: 12, seed: 9, lite: false },
{ pool: 6, seed: 5, lite: true },
{ pool: 6, seed: 8, lite: true },
];
for (const config of configs) {
const { entries, exits } = passes(config, 240);
expect(entries.length, `seed ${config.seed} entries`).toBeGreaterThanOrEqual(2);
for (const z of entries) {
expect(z, `seed ${config.seed} entry`).toBeGreaterThan(-215);
expect(z, `seed ${config.seed} entry`).toBeLessThan(CENTRE_ENTRY_Z + 20);
}
for (const z of exits) expect(z, `seed ${config.seed} exit`).toBeLessThan(CENTRE_DEADLINE_Z + 1);
}
});
it('a right car joining a truck in the haze fades in, in the haze, and the road refills from the near entry', () => {
const model = createTrafficModel({ pool: 6, seed: 5, lite: true });
const step = input({ chapter: 'infrastructure' });
const seen = new Uint8Array(6);
let faded = 0;
const fading = new Float64Array(6).fill(-1);
for (let t = 0; t < 400; t += 1 / 60) {
const f = model.step(step);
for (let i = 0; i < f.count; i += 1) {
if (f.active[i] !== TRAFFIC_VISIBLE) {
seen[i] = 0;
continue;
}
if (!seen[i]) {
seen[i] = 1;
if (t === 0) continue;
if (f.z[i]! > TRAFFIC_ENTRY_FAR_Z + 1 && f.z[i]! < TRAFFIC_EXIT_NOSE_Z - 1) {
// Nearer than the far entry: screen-doored in, at the haze. Lite
// queues its convoy car (and stages its truck) a little nearer:
// the rear of a car behind a truck at the window's near edge.
const liteNear = TRAFFIC_LITE_CONVOY_NEAR_Z + TRAFFIC_KINDS[0]!.length + TRAFFIC_CONVOY_GAP_MAX;
expect(f.z[i]!, `vehicle ${i} at ${t.toFixed(1)} s`).toBeLessThan(Math.max(TRAFFIC_ENTRY_NEAR_Z, liteNear) + 2);
expect(f.z[i]!).toBeGreaterThan(TRAFFIC_ENTRY_NEAR_Z - TRAFFIC_ENTRY_NEAR_SPAN - 50);
expect(f.dither[i]!).toBeGreaterThan(0.9);
fading[i] = t;
faded += 1;
} else expect(f.dither[i]!).toBe(0);
} else if (fading[i]! >= 0) {
if (t - fading[i]! > FADE_IN_SECONDS + 0.05) {
expect(f.dither[i]!).toBe(0);
fading[i] = -1;
} else expect(f.dither[i]!).toBeLessThanOrEqual(1);
}
}
}
expect(faded).toBeGreaterThan(2);
});
it('a yield the reader forces is a swerve that clears the corridor in under a second', () => {
for (const seed of [3, 11, 29]) {
const model = createTrafficModel({ pool: 12, seed, lite: false });
const step = input({ chapter: 'infrastructure' });
let index = -1;
for (let t = 0; t < 400 && index < 0; t += 1 / 60) {
const f = model.step(step);
for (let i = 0; i < f.count; i += 1) if (drawn(f, i) && Math.abs(f.x[i]!) < 0.3 && f.z[i]! > -200) index = i;
}
if (index < 0) continue;
step.heroSpeed = 120;
let clearAt = -1;
for (let t = 0; t < 3 && clearAt < 0; t += 1 / 60) {
const f = model.step(step);
expect(violation(f)).toBeNull();
if (Math.abs(f.x[index]!) >= 4.47 || f.active[index] !== TRAFFIC_VISIBLE) clearAt = t;
}
expect(clearAt, `seed ${seed}`).toBeGreaterThanOrEqual(0);
expect(clearAt, `seed ${seed}`).toBeLessThan(FORCED_LANE_CHANGE_SECONDS * 0.71 + 0.25);
expect(model.events().emergencyExits).toBe(0);
return;
}
throw new Error('no centre-lane car to force');
});
});
describe('flash detector', () => {
it('ignores the intro sweep (a climb from dark) and fires on a flash from the dipped beam', () => {
const detect = createFlashDetector();
const fired: number[] = [];
// Sweep: 0 -> 1 over 96 frames, held at 1, then the fall to the dipped 0.72.
for (let k = 0; k <= 96; k += 1) if (detect(k / 96)) fired.push(k);
for (let k = 0; k < 5; k += 1) if (detect(1)) fired.push(100 + k);
let i = 1;
for (let k = 0; k < 120; k += 1) {
i = 0.72 + (i - 0.72) * 0.9;
if (detect(i)) fired.push(200 + k);
}
expect(fired).toEqual([]);
// A flash: 0.72 -> 1 (rise), hold, fall.
i = 0.72;
for (let k = 0; k < 30; k += 1) {
i = 1 + (i - 1) * 0.8;
if (detect(i)) fired.push(300 + k);
}
for (let k = 0; k < 25; k += 1) if (detect(1)) fired.push(400 + k);
expect(fired.length).toBe(1);
// Nothing more until it has fallen back below 0.85.
for (let k = 0; k < 20; k += 1) {
i = 0.9 + (i - 0.9) * 0.8;
if (detect(i)) fired.push(500 + k);
}
expect(fired.length).toBe(1);
for (let k = 0; k < 60; k += 1) {
i = 0.72 + (i - 0.72) * 0.8;
if (detect(i)) fired.push(600 + k);
}
for (let k = 0; k < 30; k += 1) {
i = 1 + (i - 1) * 0.8;
if (detect(i)) fired.push(700 + k);
}
expect(fired.length).toBe(2);
});
});
describe('traffic model: lite passes (phones)', () => {
const LIVE: EnvironmentChapter[] = ['deep-night', 'systems', 'infrastructure', 'builds', 'pre-dawn'];
it('stages a pass at each chapter entry: a car pulls out within 30 s, 20 s on average', () => {
// A truck staged at the haze takes ~15 s to reach the 150-215 m entry band.
const waits: number[] = [];
for (const seed of [1, 5, 8, 13, 21]) {
const model = createTrafficModel({ pool: 6, seed, lite: true });
const step = input();
for (let t = 0; t < 5; t += 1 / 60) model.step(step);
for (let entry = 0; entry < 8; entry += 1) {
step.chapter = LIVE[(entry + seed) % LIVE.length]!;
step.cue = true;
const before = model.events().laneChanges;
let waited = 0;
while (model.events().laneChanges === before && waited < 40) {
const f = model.step(step);
step.cue = false;
waited += 1 / 60;
const problem = violation(f);
if (problem) throw new Error(`seed ${seed} entry ${entry}: ${problem}`);
}
expect(waited, `seed ${seed} entry ${entry} (${step.chapter})`).toBeLessThan(30);
waits.push(waited);
// Read the chapter for a while before the next entry.
for (let t = 0; t < 12; t += 1 / 60) model.step(step);
}
}
expect(waits.reduce((a, b) => a + b, 0) / waits.length).toBeLessThan(20);
expect(TRAFFIC_LITE_STAGE_SECONDS).toBeGreaterThanOrEqual(15);
});
it('never goes long without a pass at a steady cruise (the drought rule)', () => {
for (const seed of [2, 5, 8, 17, 3, 11, 29, 42]) {
const model = createTrafficModel({ pool: 6, seed, lite: true });
const step = input({ chapter: 'systems' });
let last = 0;
let longest = 0;
let changes = 0;
for (let t = 0; t < 600; t += 1 / 60) {
const f = model.step(step);
const problem = violation(f);
if (problem) throw new Error(`seed ${seed} t ${t.toFixed(1)}: ${problem}`);
if (model.events().laneChanges !== changes) {
changes = model.events().laneChanges;
longest = Math.max(longest, t - last);
last = t;
}
}
longest = Math.max(longest, 600 - last);
// Lane changes count the return too: drought, then ~15 s for a staged truck to reach the band, then the pass.
// (Without staging this runs 82-88 s on these seeds.)
expect(longest, `seed ${seed}`).toBeLessThan(55);
}
expect(TRAFFIC_LITE_DROUGHT_SECONDS).toBeLessThanOrEqual(15);
});
it('staging stays inside the low-tier caps and never with the engine off', () => {
const model = createTrafficModel({ pool: 6, seed: 6, lite: true });
const step = input({ chapter: 'infrastructure' });
let maxRight = 0;
for (let t = 0; t < 300; t += 1 / 60) {
step.cue = Math.floor(t * 60) % 600 === 0;
const f = model.step(step);
let right = 0;
for (let i = 0; i < f.count; i += 1) if (f.active[i] === TRAFFIC_VISIBLE && f.x[i]! > 0) right += 1;
maxRight = Math.max(maxRight, right);
}
expect(maxRight).toBeLessThanOrEqual(5);
const parked = createTrafficModel({ pool: 6, seed: 6, lite: true });
for (let t = 0; t < 60; t += 1 / 60) parked.step(input({ chapter: 'destination', engineOff: 1, heroSpeed: 0, cue: t < 0.02 }));
expect(parked.events().laneChanges).toBe(0);
});
});
Reference in New Issue View Git Blame Copy Permalink