admin/RustRaptor
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
1b52466f4c49dac091615e8d83b40fb35c95c491
RustRaptor/tests/machine_gun_ground.rs
T

716 lines
30 KiB
Rust
Raw Blame History

//! Starter forward guns must damage ground enemies and destructible terrain.
use raptor_replica::{
assets::Catalog,
content::{ContentId, ContentPack, Registry},
mod_selection,
modding::{self, ActiveMods, ScriptRuntime},
persistence::Pilot,
simulation::{Input, World},
};
use serde_json::json;
use std::path::PathBuf;
fn starter() -> Pilot {
let mut pilot = Pilot::default();
pilot.inventory.insert("base:energy".into(), 75);
pilot.credits = 10_000;
pilot
}
fn fixture(legacy_terrain: bool) -> Registry {
let mut layout = vec![0; 90];
layout[4 * 9 + 4] = 1;
let pack: ContentPack = serde_json::from_value(json!({
"weapons":[{"id":"base:projectile_forward_guns","name":"Forward Guns","damage":1,"speed":8,"cooldown":2,"behavior":"straight","target":"all","legacy":0,"art":{"asset":42,"logical_width":4,"logical_height":8,"frames":4}}],
"items":[
{"id":"base:forward_guns","name":"Forward Guns","price":0,"weapon":"base:projectile_forward_guns","legacy":0},
{"id":"base:energy","name":"Energy","price":10000,"max_count":100,"initial_count":25,"legacy":16}
],
"enemies":[{"id":"base:ground","name":"Ground emplacement","health":12,"speed":0,"ground":true,"reward":120}],
"missions":[{"id":"base:sector_1_wave_1","name":"Ground range","duration":10000,"auto_complete":false,"columns":9,"layout":layout,"legacy_map":if legacy_terrain {Some(123)} else {None},
"tiles":[
{"art":{"asset":60,"logical_width":32,"logical_height":32}},
{"art":{"asset":61,"logical_width":32,"logical_height":32},"health":2,"reward":230,"destroyed":{"asset":62,"logical_width":32,"logical_height":32}}
]}
]
})).unwrap();
let mut registry = Registry::default();
registry.apply(pack, "base").unwrap();
registry.validate().unwrap();
registry
}
fn shoot(world: &mut World, registry: &Registry, scripts: &mut ScriptRuntime, ticks: usize) {
assert_eq!(world.player.selected, None);
assert_eq!(
world
.player
.inventory
.keys()
.filter(|id| registry.items[*id].weapon.is_some())
.count(),
1,
"the test must exercise only the default machine gun"
);
for _ in 0..ticks {
world
.step(
Input {
fire: true,
..Input::default()
},
registry,
scripts,
)
.unwrap();
}
}
#[test]
fn starter_machine_gun_destroys_ground_enemy_and_awards_its_reward() {
let mut registry = fixture(false);
registry
.missions
.get_mut(&Pilot::default().mission)
.unwrap()
.layout
.fill(0);
let pilot = starter();
let mut world = World::new(&pilot.mission, &pilot, &registry).unwrap();
let entity = world
.spawn(&"base:ground".into(), 144, 72, &registry)
.unwrap();
let mut scripts = ScriptRuntime::new();
shoot(&mut world, &registry, &mut scripts, 30);
assert!(!world.enemies.iter().any(|enemy| enemy.entity == entity));
assert_eq!(world.player.credits, pilot.credits + 120);
}
#[test]
fn starter_machine_gun_destroys_json_terrain_and_rewards_it_once() {
let registry = fixture(false);
let pilot = starter();
let mut world = World::new(&pilot.mission, &pilot, &registry).unwrap();
let mut scripts = ScriptRuntime::new();
let mut explosion_sounds = 0;
for _ in 0..60 {
shoot(&mut world, &registry, &mut scripts, 1);
explosion_sounds += world
.sound_events
.iter()
.filter(|sound| sound.asset == 139)
.count();
}
let position = 4 * 9 + 4;
assert!(
world.terrain_dead[position],
"forward gun damage never destroys mod terrain (health {})",
world.terrain_health[position]
);
assert_eq!(world.player.credits, pilot.credits + 230);
assert_eq!(
explosion_sounds, 1,
"terrain destruction should emit one original ground-explosion sound"
);
let health = world.terrain_health[position];
shoot(&mut world, &registry, &mut scripts, 30);
assert_eq!(world.terrain_health[position], health);
assert_eq!(world.player.credits, pilot.credits + 230);
}
#[test]
fn short_json_maps_use_their_actual_screen_position_for_forward_gun_hits() {
let mut registry = fixture(false);
let mission = registry
.missions
.get_mut(&Pilot::default().mission)
.unwrap();
mission.layout = vec![0; 36];
mission.layout[9 + 4] = 1;
let pilot = starter();
let mut world = World::new(&pilot.mission, &pilot, &registry).unwrap();
shoot(&mut world, &registry, &mut ScriptRuntime::new(), 25);
assert!(world.terrain_dead[9 + 4]);
assert_eq!(world.player.credits, pilot.credits + 230);
}
#[test]
fn starter_machine_gun_keeps_native_delayed_terrain_destruction() {
let registry = fixture(true);
let pilot = starter();
let mut world = World::new(&pilot.mission, &pilot, &registry).unwrap();
let mut scripts = ScriptRuntime::new();
shoot(&mut world, &registry, &mut scripts, 60);
assert!(world.terrain_dead[4 * 9 + 4]);
assert!(world.terrain_settled[4 * 9 + 4]);
assert_eq!(world.player.credits, pilot.credits + 230);
}
#[test]
fn json_terrain_collision_matches_its_visible_rows_after_the_native_scroll_limit() {
let mut registry = fixture(false);
let mission = registry
.missions
.get_mut(&Pilot::default().mission)
.unwrap();
mission.layout.fill(0);
mission.layout[4] = 1;
let pilot = starter();
let mut world = World::new(&pilot.mission, &pilot, &registry).unwrap();
let mut scripts = ScriptRuntime::new();
for _ in 0..180 {
world
.step(Input::default(), &registry, &mut scripts)
.unwrap();
}
// The first row is now at screen y=60, rather than the repeating native
// terrain-window y=-4. It must be hittable at its displayed position.
assert_eq!(world.scroll, 180);
shoot(&mut world, &registry, &mut scripts, 25);
assert!(world.terrain_dead[4]);
assert_eq!(world.player.credits, pilot.credits + 230);
}
#[test]
fn json_terrain_that_scrolled_offscreen_cannot_absorb_forward_gun_shots() {
let mut registry = fixture(false);
let mission = registry
.missions
.get_mut(&Pilot::default().mission)
.unwrap();
mission.layout.fill(0);
mission.layout[9 + 4] = 1;
let pilot = starter();
let mut world = World::new(&pilot.mission, &pilot, &registry).unwrap();
let mut scripts = ScriptRuntime::new();
for _ in 0..400 {
world
.step(Input::default(), &registry, &mut scripts)
.unwrap();
}
shoot(&mut world, &registry, &mut scripts, 60);
assert_eq!(world.terrain_health[9 + 4], 2);
assert!(!world.terrain_dead[9 + 4]);
assert_eq!(world.player.credits, pilot.credits);
}
#[test]
fn health_based_mod_terrain_does_not_require_replacement_artwork_to_be_destructible() {
let mut registry = fixture(false);
registry
.missions
.get_mut(&Pilot::default().mission)
.unwrap()
.tiles[1]
.destroyed = None;
let pilot = starter();
let mut world = World::new(&pilot.mission, &pilot, &registry).unwrap();
shoot(&mut world, &registry, &mut ScriptRuntime::new(), 60);
assert!(world.terrain_dead[4 * 9 + 4]);
assert_eq!(world.player.credits, pilot.credits + 230);
}
fn catalog() -> Catalog {
let path = std::env::var_os("RAPTOR_TEST_DATA")
.map(PathBuf::from)
.unwrap_or_else(|| PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../data"));
Catalog::open(&path).unwrap()
}
#[test]
#[ignore = "requires locally installed original catalog and packaged campaign definitions"]
fn real_forward_guns_damage_classic_and_iron_coast_ground_units() {
let catalog = catalog();
let base = Registry::base(&catalog).unwrap();
let discovery = modding::discover(&PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("mods"));
let mut enabled = Vec::new();
for mission in [
"iron_coast_mission_1",
"iron_coast_mission_2",
"iron_coast_mission_3",
"iron_coast_mission_5",
] {
enabled = mod_selection::plan_enable(&discovery, &enabled, mission).unwrap();
}
// Asset decoding is covered by package validation. This combat check loads
// actual definitions and callbacks without requantizing every unrelated
// terrain PNG before it can exercise a single enemy collision.
let mut active = ActiveMods {
registry: base.clone(),
pins: Vec::new(),
scripts: ScriptRuntime::new(),
};
for id in &enabled {
let package = &discovery.mods[id];
let content: ContentPack = serde_json::from_slice(
&std::fs::read(package.root.join(&package.manifest.content)).unwrap(),
)
.unwrap();
active
.registry
.asset_roots
.insert(id.clone(), package.root.clone());
active.registry.apply(content, id).unwrap();
for script in &package.manifest.scripts {
active
.scripts
.add(
id,
script,
&std::fs::read_to_string(package.root.join(script)).unwrap(),
)
.unwrap();
}
}
active.registry.validate().unwrap();
// A quiet JSON mission leaves enemy definitions, original gun art, damage,
// movement and scripts intact while isolating their actual collisions.
let mission: ContentPack = serde_json::from_value(json!({"missions":[{"id":"test:ground_range","name":"Ground range","duration":10000,"auto_complete":false}]})).unwrap();
active.registry.apply(mission, "test").unwrap();
// Retain the original ten-case kill assertions. Additional native enemies
// include the 100-health secret cow; a starter pilot may die in this fixed
// firing lane, so those cases check damage without claiming combat wins.
let must_destroy: std::collections::BTreeSet<_> = base.missions
[&ContentId::from("base:sector_1_wave_1")]
.spawns
.iter()
.map(|spawn| spawn.enemy.clone())
.filter(|id| base.enemies[id].ground && !base.enemies[id].boss)
.collect();
let mut ground: Vec<_> = base
.missions
.values()
.filter(|mission| mission.legacy_map.is_some())
.flat_map(|mission| mission.spawns.iter())
.map(|spawn| spawn.enemy.clone())
.filter(|id| base.enemies[id].ground && !base.enemies[id].boss)
.collect();
ground.sort();
ground.dedup();
assert!(
ground.len() > 5,
"exercise every native ground unit referenced by the 27 maps"
);
eprintln!(
"Auditing {} original non-boss ground definitions",
ground.len()
);
ground.extend(
[
"iron_coast_turret:unit",
"iron_coast_mission_1:depot",
"iron_coast_mission_2:relay",
"iron_coast_mission_3:convoy",
"iron_coast_mission_5:foundry",
]
.map(ContentId::from),
);
let mut observations = Vec::new();
let mut undamaged = Vec::new();
for id in ground {
let pilot = Pilot {
mission: "test:ground_range".into(),
..starter()
};
let mut attempts = Vec::new();
let mut final_world = None;
let mut final_entity = 0;
let mut lowest = active.registry.enemies[&id].health;
let initial = lowest;
for attempt in 0..2 {
let mut world = World::new(&pilot.mission, &pilot, &active.registry).unwrap();
let entity = world.spawn(&id, 144, 24, &active.registry).unwrap();
lowest = initial;
for _ in 0..120 {
// Normal bounded absolute mouse movement aligns the ship with the
// observed ground target; health and projectiles are never injected.
let target = world.enemies.iter().find(|enemy| enemy.entity == entity);
let Some(enemy) = target else {
break;
};
// The first attempt preserves the original ten-case firing lane.
// If it cannot reach an additional native target, a second ordinary
// input strategy uses a closer lane and leads horizontal movement.
// Narrow moving units can outrun shots aimed at their old position;
// hostile secret units can kill a stationary pilot before a distant
// shot reaches them. Neither case establishes a collision defect.
let y = if attempt == 0 { 160 } else { 80 };
let lead = if attempt == 0 {
0
} else {
let velocity = active.registry.enemies[&id].legacy.as_ref().map_or(
0,
|legacy| match legacy.fields[21] {
4 => -active.registry.enemies[&id].speed,
5 => active.registry.enemies[&id].speed,
_ => 0,
},
);
let flight_steps = ((y + 16 - enemy.y - enemy.height / 2).max(0) + 11) / 12;
velocity * flight_steps
};
let x = (enemy.x + enemy.width / 2 - 16 + lead).clamp(5, 282);
world
.step(
Input {
fire: true,
absolute: Some([x, y]),
..Input::default()
},
&active.registry,
&mut active.scripts,
)
.unwrap();
if let Some(enemy) = world.enemies.iter().find(|enemy| enemy.entity == entity) {
lowest = lowest.min(enemy.health);
}
}
attempts.push(json!({
"control": if attempt == 0 { "current-position aim at y160" } else { "movement lead at y80" },
"lowest_observed_health": lowest,
"ticks": world.tick,
"outcome": format!("{:?}", world.outcome),
"remaining_shield": world.player.shield
}));
final_entity = entity;
final_world = Some(world);
if lowest < initial {
break;
}
}
let world = final_world.unwrap();
let entity = final_entity;
if lowest >= initial {
undamaged.push(format!(
"{id}: health {initial}, tick {}, outcome {:?}",
world.tick, world.outcome
));
}
let target_present = world.enemies.iter().any(|enemy| enemy.entity == entity);
let destroyed = !target_present && lowest <= 0;
if must_destroy.contains(&id) || active.registry.enemies[&id].legacy.is_none() {
assert!(
destroyed,
"starter machine gun did not destroy {id}; lowest health {lowest}, outcome {:?}",
world.outcome
);
}
if destroyed {
assert_eq!(
world.player.credits,
pilot.credits + active.registry.enemies[&id].reward,
"incorrect kill reward for {id}"
);
}
observations.push(json!({
"id": id,
"name": active.registry.enemies[&id].name,
"initial_health": initial,
"lowest_observed_health": lowest,
"destroyed": destroyed,
"escaped": !target_present && !destroyed,
"outcome": format!("{:?}", world.outcome),
"ticks": world.tick,
"reward": world.player.credits - pilot.credits,
"remaining_shield": world.player.shield
,"attempts": attempts
}));
}
if let Some(path) = std::env::var_os("RAPTOR_GROUND_REPORT") {
std::fs::write(path, serde_json::to_vec_pretty(&observations).unwrap()).unwrap();
}
assert!(
undamaged.is_empty(),
"Ground definitions never damaged: {undamaged:?}"
);
}
#[test]
#[ignore = "requires locally installed original catalog"]
fn real_forward_guns_damage_every_classic_destructible_terrain_definition() {
use std::collections::BTreeMap;
let catalog = catalog();
let mut registry = Registry::base(&catalog).unwrap();
// Buildings, parked cars and other scenery are native terrain, not EnemyDef.
// Use every intact/destruction pair actually referenced by the 27 maps.
let mut definitions = BTreeMap::new();
for mission in registry
.missions
.values()
.filter(|m| m.legacy_map.is_some())
{
for tile in &mission.tiles {
if tile.destroyed.is_some() {
definitions
.entry(tile.art.asset.unwrap())
.or_insert_with(|| tile.clone());
}
}
}
assert!(definitions.len() > 100);
eprintln!(
"Auditing {} original destructible terrain definitions",
definitions.len()
);
let mission_id = ContentId::from("base:sector_1_wave_1");
let background = registry.missions[&mission_id]
.tiles
.iter()
.find(|tile| tile.destroyed.is_none())
.unwrap()
.clone();
let mut observations = Vec::new();
for (asset, tile) in definitions {
let mission = registry.missions.get_mut(&mission_id).unwrap();
mission.spawns.clear();
mission.auto_complete = false;
mission.duration = 10000;
mission.tiles = vec![background.clone(), tile.clone()];
mission.layout = vec![0; 90];
let position = 4 * 9 + 4;
mission.layout[position] = 1;
let pilot = starter();
let mut world = World::new(&mission_id, &pilot, &registry).unwrap();
let mut scripts = ScriptRuntime::new();
let mut sounds = 0;
for _ in 0..100 {
shoot(&mut world, &registry, &mut scripts, 1);
sounds += world.sound_events.iter().filter(|s| s.asset == 139).count();
}
assert!(
world.terrain_dead[position],
"classic tile {asset:05x} was not destroyed; health {} from {}",
world.terrain_health[position], tile.health
);
assert!(
world.terrain_settled[position],
"classic tile {asset:05x} never settled"
);
assert_eq!(
world.player.credits,
pilot.credits + tile.reward,
"classic tile {asset:05x} reward"
);
assert_eq!(sounds, 1, "classic tile {asset:05x} ground-explosion sound");
observations.push(json!({"asset":format!("{asset:05x}"),"original_health":tile.health,"reward":tile.reward,"destroyed":true,"settled":true,"ticks":world.tick}));
}
if let Some(path) = std::env::var_os("RAPTOR_TERRAIN_REPORT") {
std::fs::write(path, serde_json::to_vec_pretty(&observations).unwrap()).unwrap();
}
}
#[test]
#[ignore = "requires locally installed original catalog"]
fn real_wave_6_and_7_early_terrain_hits_match_visible_original_map_positions() {
let catalog = catalog();
let mut registry = Registry::base(&catalog).unwrap();
let mut observations = Vec::new();
let mut destroyed_count = 0;
let mut static_count = 0;
for wave in [6, 7] {
let id = ContentId::new(format!("base:sector_1_wave_{wave}")).unwrap();
let original = registry.missions[&id].clone();
// Keep the complete original layout, art, tile rules and native map
// identity. Only enemy spawns are suppressed to isolate terrain hits.
let mut quiet = original.clone();
quiet.spawns.clear();
quiet.auto_complete = false;
registry.missions.insert(id.clone(), quiet);
for row in 130..150 {
for col in 0..9 {
let position = row * 9 + col;
let tile = &original.tiles[original.layout[position]];
let asset = tile.art.asset.unwrap();
// Include every destructible object in the early map section,
// plus the explicitly static industrial/fence artwork nearby.
let destructible = tile.destroyed.is_some();
let static_landmark = matches!(asset, 0x1045c..=0x1045f);
if !destructible && !static_landmark {
continue;
}
let pilot = Pilot {
mission: id.clone(),
..starter()
};
let mut world = World::new(&id, &pilot, &registry).unwrap();
let mut scripts = ScriptRuntime::new();
let rows = original.layout.len() / 9;
// This is exactly scene()'s original terrain row position:
// 200 - rows*32 + scroll + row*32. Advance ordinary idle
// steps until the tested row is at y=40, then fire normally.
let idle = (40 - (200 - rows as i32 * 32 + row as i32 * 32)).max(0);
for _ in 0..idle {
world
.step(Input::default(), &registry, &mut scripts)
.unwrap();
}
assert_eq!(200 - rows as i32 * 32 + world.scroll + row as i32 * 32, 40);
let initial_health = world.terrain_health[position];
for _ in 0..70 {
world
.step(
Input {
fire: true,
absolute: Some([16 + col as i32 * 32, 160]),
..Input::default()
},
&registry,
&mut scripts,
)
.unwrap();
}
if destructible {
assert!(
world.terrain_dead[position],
"wave{wave} row{row} col{col} asset{asset:05x} remains alive at its displayed position, health {}",
world.terrain_health[position]
);
assert!(world.terrain_settled[position]);
destroyed_count += 1;
} else {
assert_eq!(world.terrain_health[position], initial_health);
assert!(!world.terrain_dead[position]);
static_count += 1;
}
observations.push(json!({"wave":wave,"row":row,"col":col,"asset":format!("{asset:05x}"),"destructible":destructible,"initial_health":initial_health,"final_health":world.terrain_health[position],"dead":world.terrain_dead[position],"settled":world.terrain_settled[position],"idle_steps":idle,"normal_fire_steps":70,"credits_gained":world.player.credits-pilot.credits}));
}
}
}
assert_eq!(destroyed_count, 17);
assert!(static_count >= 4);
if let Some(path) = std::env::var_os("RAPTOR_EARLY_TERRAIN_REPORT") {
std::fs::write(path, serde_json::to_vec_pretty(&observations).unwrap()).unwrap();
}
}
#[test]
#[ignore = "requires locally installed original catalog"]
fn real_wave_6_and_7_early_ground_spawns_use_original_visible_positions() {
let catalog = catalog();
let mut registry = Registry::base(&catalog).unwrap();
let mut observations = Vec::new();
for wave in [6, 7] {
let id = ContentId::new(format!("base:sector_1_wave_{wave}")).unwrap();
let original = registry.missions[&id].clone();
let early: Vec<_> = original
.spawns
.iter()
.filter(|spawn| {
// Native difficulty codes 0..2 are disabled secret placements.
// These four early ordinary emplacements are enabled at all levels.
spawn.tick <= 600
&& spawn.difficulty == 3
&& registry.enemies[&spawn.enemy].ground
&& !registry.enemies[&spawn.enemy].boss
})
.cloned()
.collect();
assert_eq!(early.len(), 2);
for spawn in early {
let mut isolated = original.clone();
isolated.spawns = vec![spawn.clone()];
isolated.auto_complete = false;
registry.missions.insert(id.clone(), isolated);
let pilot = Pilot {
mission: id.clone(),
..starter()
};
let mut world = World::new(&id, &pilot, &registry).unwrap();
let mut scripts = ScriptRuntime::new();
let def = &registry.enemies[&spawn.enemy];
let art = def.art.as_ref().unwrap();
assert_eq!(def.legacy.as_ref().unwrap().fields[21], 3);
let expected_x = spawn.x + 16 - art.logical_width as i32 / 2;
let expected_y = spawn.y - art.logical_height as i32 / 2 + 1;
let mut observed_spawn = None;
let mut first_damage = None;
let mut entity = None;
let mut lowest = def.health;
let mut last_health = None;
for _ in 0..spawn.tick + 400 {
// Capped mouse movement is achievable with ordinary controls.
// Full original terrain remains present, including objects
// that can intercept bullets before the emplacement is hit.
let desired = (expected_x + art.logical_width as i32 / 2 - 16).clamp(5, 282);
let x = world.player.x + (desired - world.player.x).clamp(-4, 4);
world
.step(
Input {
fire: true,
absolute: Some([x, 160]),
..Input::default()
},
&registry,
&mut scripts,
)
.unwrap();
if let Some(enemy) = world
.enemies
.iter()
.find(|enemy| enemy.definition == spawn.enemy)
{
if entity.is_none() {
entity = Some(enemy.entity);
assert_eq!([enemy.x, enemy.y], [expected_x, expected_y]);
assert_eq!(enemy.age, 1);
assert_eq!(world.tick, spawn.tick + 1);
observed_spawn = Some(
json!({"world_tick":world.tick,"position":[enemy.x,enemy.y],"previous_position":[enemy.px,enemy.py],"width":enemy.width,"height":enemy.height}),
);
}
lowest = lowest.min(enemy.health);
last_health = Some(enemy.health);
if first_damage.is_none() && enemy.health < def.health {
let hit_points: Vec<_> = world
.projectiles
.iter()
.filter(|projectile| {
projectile.weapon == ContentId::from("base:projectile_forward_guns")
&& projectile.legacy.as_ref().is_some_and(|shot| shot.hit)
&& projectile.x > enemy.x
&& projectile.x < enemy.x + enemy.width - 1
&& projectile.y > enemy.y
&& projectile.y < enemy.y + enemy.height - 1
})
.map(|projectile| [projectile.x, projectile.y])
.collect();
assert!(
!hit_points.is_empty(),
"first damage lacks a default-gun collision point"
);
first_damage = Some(
json!({"world_tick":world.tick,"health":enemy.health,"logical_bounds":[enemy.x,enemy.y,enemy.width,enemy.height],"interpolation_start":[enemy.px,enemy.py],"hit_points":hit_points}),
);
}
} else if entity.is_some() {
break;
}
}
assert!(entity.is_some(), "wave {wave} never spawns {}", spawn.enemy);
assert!(
lowest < def.health,
"wave {wave} default gun never damages {}",
spawn.enemy
);
assert!(
last_health.is_some_and(|health| health <= 0),
"wave {wave} target escaped rather than being destroyed: {} / health {last_health:?}",
spawn.enemy
);
assert!(
!world
.enemies
.iter()
.any(|enemy| Some(enemy.entity) == entity)
);
assert_eq!(format!("{:?}", world.outcome), "Playing");
assert!(world.player.credits >= pilot.credits + def.reward);
observations.push(json!({"wave":wave,"id":spawn.enemy,"name":def.name,"native_spawn_tick":spawn.tick,"native_spawn_position":[spawn.x,spawn.y],"observed_spawn":observed_spawn,"first_damage":first_damage,"initial_health":def.health,"lowest_observed_health":lowest,"destroyed":true,"finished_tick":world.tick,"remaining_shield":world.player.shield,"credits_gained":world.player.credits-pilot.credits}));
}
}
assert_eq!(observations.len(), 4);
if let Some(path) = std::env::var_os("RAPTOR_EARLY_SPAWN_REPORT") {
std::fs::write(path, serde_json::to_vec_pretty(&observations).unwrap()).unwrap();
}
}
Reference in new issue View Git Blame Copy Permalink