feat(stress): add a deterministic particle demo with sequenced music

Move Storm Eagle playback and source assets to Stress Console and keep Dummy Boy silent. Exercise VM math, seeded Random and persistent typed particles with a projected tunnel, bounded 512-sprite heavy workload, reproducible replays and measured costs.
This commit is contained in:
2026-11-20 22:15:47 +00:00
parent 8510c5b00d
commit c2bf8d055c
42 changed files with 20688 additions and 232 deletions
@@ -0,0 +1,198 @@
mod support;
use pbxgen_stress::{Preset, DEFAULT_SEED};
use support::*;
#[test]
fn presets_replay_native_state_without_churn_or_sprite_overflow() {
for preset in [Preset::Light, Preset::Normal, Preset::Heavy] {
let mut a = vm(preset, DEFAULT_SEED);
let mut b = vm(preset, DEFAULT_SEED);
let mut other = vm(preset, DEFAULT_SEED + 1);
let mut na = Workload::default();
let mut nb = Workload::default();
let mut no = Workload::default();
let mut previous = vec![];
for f in 1..=6 {
let cycles = frame(&mut a, &mut na);
assert_eq!(cycles, frame(&mut b, &mut nb));
frame(&mut other, &mut no);
let state = particle_bits(&a);
assert_eq!(state, particle_bits(&b));
assert_ne!(state, particle_bits(&other));
assert_ne!(state, previous);
previous = state;
assert_eq!(previous.len(), preset.particles() as usize * 6);
assert_eq!(a.heap().len(), preset.particles() as usize + 2);
assert_eq!(na.submitted, f * (preset.particles() as usize + 128));
assert_eq!(na.sprites.sprite_count(), preset.particles() as usize + 128);
assert_eq!(na.sprites.dropped_sprites(), 0);
assert_eq!(na.errors, 0);
}
assert_eq!(na.binds, 1);
assert_eq!(na.plays, 1);
assert_eq!(na.camera, 6);
assert_eq!(na.text, 24);
let expected = match preset {
Preset::Light => 0xa0277985ff4cefcd,
Preset::Normal => 0x3a9cf871667c92ee,
Preset::Heavy => 0x57257956419e88d2,
};
assert_eq!(hash(&previous), expected, "guest numeric replay changed");
println!("replay={} hash={:016x}", preset.name(), hash(&previous));
}
}
#[test]
fn actual_intrinsic_execution_and_particle_rebirth() {
use prometeu_bytecode::{
decode_next, isa::core::CoreOpCode, load_limits::LoadBudget, registry_codec::PbxEnvelope,
};
use prometeu_hal::HostContext;
use prometeu_vm::LogicalFrameEndingReason as End;
use std::collections::BTreeMap;
let bytes = pbxgen_stress::build_program_with(Preset::Light, 42);
let mut budget = LoadBudget::new(Default::default());
let envelope = PbxEnvelope::parse(&bytes, &mut budget).unwrap();
let section = envelope.section(2).unwrap();
let code = section.bytes;
let mut sites = BTreeMap::new();
let mut pc = 0;
while pc < code.len() {
let i = decode_next(pc, code).unwrap();
if i.opcode == CoreOpCode::Intrinsic {
sites.insert(pc, i.imm_u32().unwrap());
}
pc = i.next_pc;
}
let mut v = vm(Preset::Light, 42);
for &pc in sites.keys() {
v.insert_breakpoint(pc);
}
let mut n = Workload::default();
v.prepare_boot_call().unwrap();
let mut calls = BTreeMap::<u32, usize>::new();
loop {
if let Some(&id) = sites.get(&v.pc()) {
*calls.entry(id).or_default() += 1;
v.step(&mut n, &mut HostContext::new(None)).unwrap();
continue;
}
let r = v.run_budget(250_000, &mut n, &mut HostContext::new(None)).unwrap();
match r.reason {
End::Breakpoint | End::BudgetExhausted => {}
End::EndOfRom => break,
x => panic!("{x:?}"),
}
}
println!("executed_intrinsic_calls={calls:?}");
for (owner, name, min) in [
("random", "new", 1),
("random", "nextf", 256),
("random", "range", 64),
("random", "next", 64),
("mathf", "sin", 192),
("mathf", "cos", 192),
("mathf", "atan2", 64),
("mathf", "sqrt", 64),
("mathf", "clamp", 256),
("vec2", "dot", 64),
("vec2", "length", 64),
] {
let id = prometeu_vm::lookup_intrinsic(owner, name, 1).unwrap().id;
assert!(calls.get(&id).copied().unwrap_or(0) >= min, "{owner}.{name}: {calls:?}");
}
for pc in sites.keys() {
v.remove_breakpoint(*pc);
}
// Every initial lifetime is <225 frames: all particles must eventually be reborn.
for _ in 1..230 {
frame(&mut v, &mut n);
}
let lifetimes: Vec<_> = particle_bits(&v).as_chunks::<6>().0.iter().map(|s| s[4]).collect();
assert!(lifetimes.iter().all(|&life| (1..225).contains(&life)));
assert_eq!(v.heap().len(), 66);
assert_eq!(n.plays, 1);
assert_eq!(n.errors, 0);
}
#[test]
fn sprite_overflow_is_a_separate_bounded_controller_case() {
let mut n = Workload::default();
let mut v = vm(Preset::Heavy, 42);
frame(&mut v, &mut n);
let sprite = prometeu_hal::sprite::Sprite {
glyph: prometeu_hal::glyph::Glyph { glyph_id: 0, palette_id: 8 },
x: 0,
y: 0,
layer: 3,
bank_id: 0,
active: false,
flip_x: false,
flip_y: false,
priority: 3,
};
for _ in n.sprites.sprite_count()..512 {
assert!(n.sprites.emit_sprite(sprite));
}
assert!(!n.sprites.emit_sprite(sprite));
assert_eq!(n.sprites.sprite_count(), 512);
assert_eq!(n.sprites.dropped_sprites(), 1);
}
#[test]
fn guest_reports_a_failed_submission_instead_of_discarding_status() {
let mut v = vm(Preset::Light, 42);
let mut n = Workload { reject_first_sprite: true, ..Default::default() };
frame(&mut v, &mut n);
assert_eq!(n.errors, 1);
frame(&mut v, &mut n);
assert_eq!(n.errors, 1, "frame status must reset after the failed frame");
}
#[test]
fn faster_travel_changes_actual_guest_positions() {
use prometeu_bytecode::{
decode_next, isa::core::CoreOpCode, load_limits::LoadBudget, registry_codec::PbxEnvelope,
};
use prometeu_hal::HostContext;
use prometeu_vm::LogicalFrameEndingReason as End;
let bytes = pbxgen_stress::build_program_with(Preset::Light, DEFAULT_SEED);
let mut budget = LoadBudget::new(Default::default());
let envelope = PbxEnvelope::parse(&bytes, &mut budget).unwrap();
let code = envelope.section(2).unwrap().bytes;
let mut pc = 0;
let before_update = loop {
let op = decode_next(pc, code).unwrap();
if op.opcode == CoreOpCode::Hostcall && op.imm_u32().unwrap() == 2 {
break pc;
}
pc = op.next_pc;
};
let mut v = vm(Preset::Light, DEFAULT_SEED);
let mut n = Workload::default();
v.insert_breakpoint(before_update);
v.prepare_boot_call().unwrap();
assert_eq!(
v.run_budget(1_000_000, &mut n, &mut HostContext::new(None)).unwrap().reason,
End::Breakpoint
);
let initial = particle_bits(&v);
v.remove_breakpoint(before_update);
assert_eq!(
v.run_budget(1_000_000, &mut n, &mut HostContext::new(None)).unwrap().reason,
End::EndOfRom
);
let updated = particle_bits(&v);
assert_eq!(initial.len(), updated.len());
for (before, after) in initial.as_chunks::<6>().0.iter().zip(updated.as_chunks::<6>().0) {
for (position, velocity) in [(0, 2), (1, 3)] {
let old = f64::from_bits(before[position]);
let speed = f64::from_bits(after[velocity]);
let actual = f64::from_bits(after[position]);
assert!(
(actual - (old + 1.5 * speed)).abs() < 1e-10,
"light preset has one pass: position must advance by 1.5 times velocity"
);
}
}
}