diff options
Diffstat (limited to 'crates/fparkan-runtime/src/lib.rs')
| -rw-r--r-- | crates/fparkan-runtime/src/lib.rs | 1572 |
1 files changed, 1564 insertions, 8 deletions
diff --git a/crates/fparkan-runtime/src/lib.rs b/crates/fparkan-runtime/src/lib.rs index b4c13df..e74976f 100644 --- a/crates/fparkan-runtime/src/lib.rs +++ b/crates/fparkan-runtime/src/lib.rs @@ -13,6 +13,7 @@ use fparkan_assets::{ PreparedControlNodeDataTable, PreparedControlTypedRecord, PreparedVisual, TerrainFormatError, TerrainPreparationError, TerrainWorld, TmaProfile, }; +use fparkan_msh::{node38_metadata, selected_slot, Group, Lod, NodeId}; use fparkan_path::{normalize_relative, NormalizedPath, PathError, PathPolicy}; use fparkan_prototype::{ build_prototype_graph_report, unit_component_tree, PrototypeGraph, PrototypeGraphFailure, @@ -134,9 +135,8 @@ pub struct BehaviorRegisteredObject { pub class_flags: u32, /// Native share field at record offset `+0x04`. pub share: f32, - /// Raw DWORDs at offsets `+0x08..+0x18`; the first controls whether - /// normalization treats this record as fixed, and the remaining words are - /// not yet assigned semantics. A normal native Add initializes all five to 0. + /// Raw DWORDs at offsets `+0x08..+0x18`: fixed-share flag, power demand, + /// power allocation, ore demand, and ore allocation. A native Add zeros them. pub native_tail: [u32; 5], } @@ -211,10 +211,23 @@ pub struct EffectiveControlDevice { pub descriptor_provenance: ControlDeviceRecordProvenance, } +/// Initial Control metadata projected from one node in AniMesh's global table. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub struct MissionControlNodeInitialMeshState { + /// Parent index in AniMesh's concatenated runtime-node table. + pub parent_index: i32, + /// Node38 header bits translated to the Control row's `+0x28` flags. + pub flags: u32, + /// Effective state count; an empty native state prefix is exposed as one. + pub stage_count: u32, +} + /// Initial row in the loaded global Control node-data provider. /// /// The native table is indexed independently of MSH model nodes. Its rows are /// appended in root/EXTO resource order and begin with a type-1 value of 1.0. +/// Mesh metadata uses the global row ordinal; `None` records that the matching +/// MSH projection was unavailable and does not affect provider queries. #[derive(Clone, Debug, PartialEq)] pub struct MissionControlNodeProviderRow { /// NDP resource that contributed the row. @@ -225,8 +238,16 @@ pub struct MissionControlNodeProviderRow { pub source_row_index: usize, /// Original NDP descriptor fields and provenance for this provider row. pub source_row: PreparedControlNodeDataRow, + /// Shared initial provider amount (`+0x08` and `+0x0c`) as raw bits. + /// + /// Control initializes both fields from the selector-3 result. On the + /// confirmed UnitDAT load path, the two scale factors are 1.0, so this is + /// the NDP row's `max_volume`; later mutations can change both fields. + pub initial_amount_bits: u32, /// Initial native provider selector-1 value (`+0x14`) as raw bits. pub initial_type1_value_bits: u32, + /// MSH state exposed at the same global ordinal, if the mesh projection exists. + pub initial_mesh_state: Option<MissionControlNodeInitialMeshState>, } /// Availability of the initial global Control node-data provider projection. @@ -457,19 +478,20 @@ pub struct MissionScriptBundle { pub package: ScriptPackage, /// Outcome of the restricted first-`Init` resolution for this bundle. pub init_execution: MissionScriptInitExecution, - /// Recovered per-AI Behavior state computed by a full mission startup. + /// Recovered per-AI Behavior scheduler and total state. /// Static previews leave this empty because they do not run script startup. pub behavior_warm_start: Option<BehaviorWarmStartState>, } -/// Initial Behavior distributor fields recovered from the original warm-start path. +/// Behavior distributor clock and totals tracked from warm start through resource ticks. #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub struct BehaviorWarmStartState { - /// Queue-clock value copied to distributor offset `+0x10` when it is zero. + /// Native offset `+0x10`: startup queue time, later replaced by the last due tick time. pub first_time_ms: u32, - /// Initial scheduled time written to distributor offset `+0x14`. + /// Native offset `+0x14`: current deadline, rescheduled after each due tick. pub next_deadline_ms: u32, - /// Opaque distributor words at offsets `+0x30..=+0x40`, cleared on first start. + /// Native totals at offsets `+0x30..=+0x40`: zeroed at startup, then power + /// available, ore available, ore in buffer, power usage, and ore usage. pub cleared_words: [u32; 5], } @@ -490,6 +512,35 @@ impl BehaviorWarmStartState { } } +fn behavior_elapsed_seconds(elapsed_ms: u32) -> f32 { + // The exact integer product is rounded once to f32; scaling by 2^-33 is + // exact and matches native FILD / FMUL / FSTP under the measured control word. + ((u64::from(elapsed_ms) * 0x0083_126f) as f32) * f32::from_bits(0x2f00_0000) +} + +fn schedule_behavior_distributor_tick( + state: &mut BehaviorWarmStartState, + queue_time_ms: u32, + rng_state: &mut u32, +) -> Option<f32> { + if state.first_time_ms == 0 { + let initialized = BehaviorWarmStartState::start(queue_time_ms, rng_state); + state.first_time_ms = initialized.first_time_ms; + state.next_deadline_ms = initialized.next_deadline_ms; + state.cleared_words = [0; 5]; + return None; + } + if state.next_deadline_ms != 0 && queue_time_ms <= state.next_deadline_ms { + return None; + } + + let elapsed_ms = queue_time_ms.wrapping_sub(state.first_time_ms); + let next = BehaviorWarmStartState::start(queue_time_ms, rng_state); + state.first_time_ms = next.first_time_ms; + state.next_deadline_ms = next.next_deadline_ms; + Some(behavior_elapsed_seconds(elapsed_ms)) +} + /// Numeric script defaults selected for the mission's first script bundle. /// /// GOG `ai.dll` first tries `<bundle-base>.var`, then falls back to the shared @@ -833,6 +884,13 @@ pub enum EngineError { /// Entry, field, or format diagnostic. message: String, }, + /// A Behavior resource tick could not resolve a required runtime value. + BehaviorDistributorTick { + /// TMA clan whose distributor could not complete its tick. + clan_index: usize, + /// Unsupported query, property, or arithmetic detail. + message: String, + }, /// World error. World(fparkan_world::WorldError), /// Reference movement input or terrain query failed. @@ -960,6 +1018,10 @@ impl std::fmt::Display for EngineError { entry, message, } => write!(f, "{path}:{entry}: Behavior profile failed: {message}"), + Self::BehaviorDistributorTick { + clan_index, + message, + } => write!(f, "Behavior resource tick for clan {clan_index}: {message}"), Self::World(source) => write!(f, "{source}"), Self::Movement(message) => write!(f, "reference movement: {message}"), Self::RegistrationTeardown { @@ -994,6 +1056,7 @@ impl std::error::Error for EngineError { | Self::Movement(_) | Self::PrototypeGraph { .. } | Self::BehaviorProfile { .. } + | Self::BehaviorDistributorTick { .. } | Self::RegistrationTeardown { .. } => None, } } @@ -1880,6 +1943,100 @@ pub fn query_loaded_mission_behavior_resource( } } +/// Runs due native Behavior resource-distributor ticks against the loaded mission. +/// +/// `queue_time_ms` is an explicit sample from the original wrapping 32-bit +/// queue clock. The method updates the distributor schedule, its five totals, +/// per-object row values, CurrentOre, and supported Control selector-1 state +/// atomically. Preview missions and loaded missions without visible Behavior +/// bundles have no due distributors and return `Ok(0)`. Otherwise it returns +/// the number of distributors whose schedule was due; this includes a due +/// tick with zero elapsed time, which leaves resource rows unchanged. +/// +/// # Errors +/// Returns an error when a live registered object reaches an unsupported +/// Behavior profile, Control query, or property state. On error, all +/// schedules, RNG state, totals, rows, ore values, and Control values remain +/// unchanged. +pub fn advance_loaded_mission_resources( + engine: &mut Engine, + queue_time_ms: u32, +) -> Result<usize, EngineError> { + let Some(loaded) = engine.loaded.as_ref() else { + return Ok(0); + }; + + let mut distributors = loaded.behavior_distributors.clone(); + let mut ore_states = loaded.behavior_ore_states.clone(); + let mut control_tables = loaded.control_device_tables.clone(); + let mut warm_starts = loaded + .script_bundles + .iter() + .map(|bundle| bundle.behavior_warm_start) + .collect::<Vec<_>>(); + let profiles = &loaded.behavior_profiles; + let world = &engine.world; + let mut rng_state = engine.behavior_rng_state; + let mut scheduled_ticks = 0; + + for distributor in distributors.iter_mut() { + if !distributor.super_ai_visible { + continue; + } + let bundle_index = loaded + .script_bundles + .iter() + .position(|bundle| bundle.clan_index == distributor.clan_index) + .ok_or_else(|| EngineError::BehaviorDistributorTick { + clan_index: distributor.clan_index, + message: "visible distributor has no matching script bundle".to_string(), + })?; + let Some(schedule) = warm_starts.get_mut(bundle_index).and_then(Option::as_mut) else { + return Err(EngineError::BehaviorDistributorTick { + clan_index: distributor.clan_index, + message: "visible distributor has no warm-start schedule".to_string(), + }); + }; + + let delta_seconds = + schedule_behavior_distributor_tick(schedule, queue_time_ms, &mut rng_state); + let Some(delta_seconds) = delta_seconds else { + continue; + }; + scheduled_ticks += 1; + if delta_seconds == 0.0 { + continue; + } + + let totals = advance_behavior_distributor_tick( + distributor, + delta_seconds, + world, + &mut ore_states, + profiles, + &mut control_tables, + ) + .map_err(|message| EngineError::BehaviorDistributorTick { + clan_index: distributor.clan_index, + message, + })?; + schedule.cleared_words = totals; + } + + let loaded = engine + .loaded + .as_mut() + .expect("loaded mission was checked above"); + loaded.behavior_distributors = distributors; + loaded.behavior_ore_states = ore_states; + loaded.control_device_tables = control_tables; + for (bundle, warm_start) in loaded.script_bundles.iter_mut().zip(warm_starts) { + bundle.behavior_warm_start = warm_start; + } + engine.behavior_rng_state = rng_state; + Ok(scheduled_ticks) +} + /// Sets native Control global-table selector 1 on rows whose selector-0 value /// is positive. Validation is completed before any row is changed. /// @@ -2059,6 +2216,387 @@ fn query_behavior_profile_ore_rate( ) } +#[derive(Clone, Copy, Default)] +struct BehaviorTickTotals { + power_available: f32, + ore_available: f32, + power_weighted_demand: f32, + power_demand: f32, + ore_weighted_demand: f32, + ore_demand: f32, + ore_in_buffer: f32, +} + +#[derive(Clone, Copy, Default)] +struct BehaviorAllocation { + priority: f32, + residual: f32, + consumption: f32, +} + +fn behavior_difference(lhs: f32, rhs: f32, field: &'static str) -> Result<f32, String> { + let range_probe = f64::from(lhs) - f64::from(rhs); + check_control_range_probe(None, field, range_probe).map_err(|error| format!("{error:?}"))?; + checked_control_float(0, field, lhs - rhs).map_err(|error| format!("{error:?}")) +} + +fn behavior_product(lhs: f32, rhs: f32, field: &'static str) -> Result<f32, String> { + checked_control_product(0, field, lhs, rhs).map_err(|error| format!("{error:?}")) +} + +fn behavior_allocation( + available: f32, + demand: f32, + weighted_demand: f32, +) -> Result<BehaviorAllocation, String> { + if available <= 0.0 || demand <= 0.0 { + Ok(BehaviorAllocation::default()) + } else if available <= weighted_demand { + Ok(BehaviorAllocation { + priority: checked_control_ratio("priority allocation", available, weighted_demand) + .map_err(|error| format!("{error:?}"))?, + residual: 0.0, + consumption: 1.0, + }) + } else if available < demand { + let residual_available = + behavior_difference(available, weighted_demand, "residual available")?; + let residual_demand = behavior_difference(demand, weighted_demand, "residual demand")?; + Ok(BehaviorAllocation { + priority: 1.0, + residual: checked_control_ratio( + "residual allocation", + residual_available, + residual_demand, + ) + .map_err(|error| format!("{error:?}"))?, + consumption: 1.0, + }) + } else { + Ok(BehaviorAllocation { + priority: 1.0, + residual: 1.0, + consumption: checked_control_ratio("source consumption", demand, available) + .map_err(|error| format!("{error:?}"))?, + }) + } +} + +fn behavior_add_total(total: &mut f32, value: f32, field: &'static str) -> Result<(), String> { + *total = checked_control_sum(0, field, *total, value).map_err(|error| format!("{error:?}"))?; + Ok(()) +} + +fn behavior_profile_for_handle<'a>( + profiles: &'a [BehaviorProfileState], + handle: ObjectHandle, +) -> Result<&'a BehaviorProfileState, String> { + profiles + .iter() + .find(|profile| profile.handle == handle) + .ok_or_else(|| format!("Behavior profile for object {handle:?} is unavailable")) +} + +fn behavior_ore_index_for_handle( + ore_states: &[BehaviorOreState], + handle: ObjectHandle, +) -> Result<usize, String> { + ore_states + .iter() + .position(|state| state.handle == handle) + .ok_or_else(|| format!("CurrentOre property for object {handle:?} is unavailable")) +} + +fn behavior_control_index_for_handle( + control_tables: &[MissionControlDeviceTableState], + handle: ObjectHandle, +) -> Result<usize, String> { + let index = control_tables + .iter() + .position(|table| table.handle == handle) + .ok_or_else(|| format!("Control interface for object {handle:?} is unavailable"))?; + match &control_tables[index].status { + MissionControlDeviceTableStatus::Available(_) => Ok(index), + MissionControlDeviceTableStatus::Unavailable(reason) => Err(format!( + "Control interface for object {handle:?} is unresolved: {reason:?}" + )), + } +} + +fn behavior_checked_property(state: &BehaviorOreState, maximum: bool) -> Result<f32, String> { + let (field, bits) = if maximum { + ("MaximumOre", state.maximum_ore_bits) + } else { + ("CurrentOre", state.current_ore_bits) + }; + checked_control_float(state.class_flags, field, f32::from_bits(bits)) + .map_err(|error| format!("{error:?}")) +} + +fn behavior_tick_resource_rate( + class_flags: u32, + handle: ObjectHandle, + selector: u32, + profiles: &[BehaviorProfileState], + control_tables: &[MissionControlDeviceTableState], +) -> Result<f32, String> { + let profile = behavior_profile_for_handle(profiles, handle)?; + match selector { + 0x1005 => checked_control_float( + class_flags, + "Transfer_Power_Out", + f32::from_bits(profile.transfer_power_out_bits), + ) + .map_err(|error| format!("{error:?}")), + 0x1002 => { + let table_index = behavior_control_index_for_handle(control_tables, handle)?; + query_behavior_profile_ore_rate( + &control_tables[table_index], + profile.transfer_ore_off_board_bits, + ) + .map_err(|error| format!("{error:?}")) + } + _ => Err(format!( + "unsupported Behavior resource selector {selector:#x}" + )), + } +} + +fn behavior_query_control( + control_tables: &[MissionControlDeviceTableState], + handle: ObjectHandle, + selector: u32, +) -> Result<f32, String> { + let table_index = behavior_control_index_for_handle(control_tables, handle)?; + query_control_device_table_resource(&control_tables[table_index], selector) + .map(|value| value.unwrap_or(0.0)) + .map_err(|error| format!("{error:?}")) +} + +fn advance_behavior_distributor_tick( + distributor: &mut BehaviorDistributorState, + delta_seconds: f32, + world: &World, + ore_states: &mut [BehaviorOreState], + profiles: &[BehaviorProfileState], + control_tables: &mut [MissionControlDeviceTableState], +) -> Result<[u32; 5], String> { + let mut totals = BehaviorTickTotals::default(); + + // Native pass one measures supply and demand, then records per-row demand. + for object in &mut distributor.registered_objects { + let Some(live_handle) = handle_by_original_id(world, object.original_id) else { + object.native_tail[1] = 0; + object.native_tail[3] = 0; + continue; + }; + if live_handle != object.handle { + return Err(format!( + "live original object {} maps to {live_handle:?}, expected {:?}", + object.original_id.0, object.handle + )); + } + let share = checked_control_float(object.class_flags, "Behavior share", object.share) + .map_err(|error| format!("{error:?}"))?; + + let power_source = matches!( + object.class_flags, + 0x8000_0002 | 0x8001_0000 | 0x8002_0000 | 0x8004_0000 + ); + let power_demand = if power_source { + let rate = behavior_tick_resource_rate( + object.class_flags, + live_handle, + 0x1005, + profiles, + control_tables, + )?; + let production = behavior_product(delta_seconds, rate, "power production")?; + behavior_add_total(&mut totals.power_available, production, "power available")?; + 0.0 + } else { + let total_power = behavior_query_control(control_tables, live_handle, 2)?; + let power_ratio = behavior_query_control(control_tables, live_handle, 1)?; + if total_power > 0.0 { + let used_power = behavior_product(power_ratio, total_power, "used power")?; + behavior_difference(total_power, used_power, "power demand")? + } else { + 0.0 + } + }; + object.native_tail[1] = power_demand.to_bits(); + behavior_add_total(&mut totals.power_demand, power_demand, "power demand")?; + behavior_add_total( + &mut totals.power_weighted_demand, + behavior_product(power_demand, share, "weighted power demand")?, + "weighted power demand", + )?; + + let ore_source = matches!(object.class_flags, 0x8000_0004 | 0x8000_0008); + let ore_index = behavior_ore_index_for_handle(ore_states, live_handle)?; + let current = behavior_checked_property(&ore_states[ore_index], false)?; + let ore_demand = if ore_source { + let rate = behavior_tick_resource_rate( + object.class_flags, + live_handle, + 0x1002, + profiles, + control_tables, + )?; + let production = behavior_product(delta_seconds, rate, "ore production")?; + let available = if current < production { + current + } else { + production + }; + behavior_add_total(&mut totals.ore_available, available, "ore available")?; + behavior_add_total(&mut totals.ore_in_buffer, current, "ore in buffer")?; + 0.0 + } else { + let maximum = behavior_checked_property(&ore_states[ore_index], true)?; + let deficit = behavior_difference(maximum, current, "ore deficit")?; + if deficit >= f32::from_bits(0x3c23_d70a) { + deficit + } else { + ore_states[ore_index].current_ore_bits = maximum.to_bits(); + 0.0 + } + }; + object.native_tail[3] = ore_demand.to_bits(); + behavior_add_total(&mut totals.ore_demand, ore_demand, "ore demand")?; + behavior_add_total( + &mut totals.ore_weighted_demand, + behavior_product(ore_demand, share, "weighted ore demand")?, + "weighted ore demand", + )?; + } + + let power_allocation = behavior_allocation( + totals.power_available, + totals.power_demand, + totals.power_weighted_demand, + )?; + let ore_allocation = behavior_allocation( + totals.ore_available, + totals.ore_demand, + totals.ore_weighted_demand, + )?; + + // Native pass two re-reads callbacks before applying each row in order. + for object in &mut distributor.registered_objects { + let Some(live_handle) = handle_by_original_id(world, object.original_id) else { + object.native_tail[2] = 0; + object.native_tail[4] = 0; + continue; + }; + if live_handle != object.handle { + return Err(format!( + "live original object {} maps to {live_handle:?}, expected {:?}", + object.original_id.0, object.handle + )); + } + object.native_tail[2] = 0; + object.native_tail[4] = 0; + + let power_source = matches!( + object.class_flags, + 0x8000_0002 | 0x8001_0000 | 0x8002_0000 | 0x8004_0000 + ); + if power_source { + let table_index = behavior_control_index_for_handle(control_tables, live_handle)?; + set_control_device_table_multiplier(&mut control_tables[table_index], 1.0) + .map_err(|error| format!("{error:?}"))?; + } else { + let table_index = behavior_control_index_for_handle(control_tables, live_handle)?; + let total_power = behavior_query_control(control_tables, live_handle, 2)?; + if total_power > 0.0 { + let power_ratio = behavior_query_control(control_tables, live_handle, 1)?; + let used_power = behavior_product(power_ratio, total_power, "used power")?; + let demand = behavior_difference(total_power, used_power, "power demand")?; + let share = object.share; + let priority_share = + behavior_product(share, power_allocation.priority, "priority power share")?; + let residual_share = behavior_product( + behavior_difference(1.0, share, "remaining share")?, + power_allocation.residual, + "residual power share", + )?; + let fraction = checked_control_sum( + 0, + "power allocation fraction", + residual_share, + priority_share, + ) + .map_err(|error| format!("{error:?}"))?; + let allocated = behavior_product(demand, fraction, "power allocation")?; + let updated = + checked_control_sum(0, "used plus allocated power", used_power, allocated) + .map_err(|error| format!("{error:?}"))?; + let new_ratio = + checked_control_ratio("new Control selector 1", updated, total_power) + .map_err(|error| format!("{error:?}"))?; + set_control_device_table_multiplier(&mut control_tables[table_index], new_ratio) + .map_err(|error| format!("{error:?}"))?; + object.native_tail[2] = allocated.to_bits(); + } + } + + let ore_source = matches!(object.class_flags, 0x8000_0004 | 0x8000_0008); + let ore_index = behavior_ore_index_for_handle(ore_states, live_handle)?; + let current = behavior_checked_property(&ore_states[ore_index], false)?; + if ore_source { + let rate = behavior_tick_resource_rate( + object.class_flags, + live_handle, + 0x1002, + profiles, + control_tables, + )?; + let production = behavior_product(delta_seconds, rate, "ore withdrawal rate")?; + let bounded_production = if current < production { + current + } else { + production + }; + let taken = behavior_product( + bounded_production, + ore_allocation.consumption, + "ore withdrawal", + )?; + ore_states[ore_index].current_ore_bits = + behavior_difference(current, taken, "remaining ore")?.to_bits(); + } else { + let maximum = behavior_checked_property(&ore_states[ore_index], true)?; + let capacity = behavior_difference(maximum, current, "ore capacity")?; + let share = object.share; + let priority_share = + behavior_product(share, ore_allocation.priority, "priority ore share")?; + let residual_share = behavior_product( + behavior_difference(1.0, share, "remaining share")?, + ore_allocation.residual, + "residual ore share", + )?; + let fraction = + checked_control_sum(0, "ore allocation fraction", residual_share, priority_share) + .map_err(|error| format!("{error:?}"))?; + let allocated = behavior_product(capacity, fraction, "ore allocation")?; + ore_states[ore_index].current_ore_bits = + checked_control_sum(0, "current plus allocated ore", current, allocated) + .map_err(|error| format!("{error:?}"))? + .to_bits(); + object.native_tail[4] = allocated.to_bits(); + } + } + + Ok([ + totals.power_available.to_bits(), + totals.ore_available.to_bits(), + totals.ore_in_buffer.to_bits(), + totals.power_demand.to_bits(), + totals.ore_demand.to_bits(), + ]) +} + fn set_control_device_table_multiplier( table: &mut MissionControlDeviceTableState, value: f32, @@ -2740,6 +3278,57 @@ fn build_control_device_projection( } } + let mut global_mesh_states = Vec::new(); + let mut global_node_cursor = 0_usize; + for component_index in active_components.iter().copied() { + let prototype = + prototype_for(component_index).ok_or(Unavailable::ComponentAlignmentMismatch)?; + let is_root = component_index == 0; + let is_ex_to = !is_root && prototype.source_type == Some(PROTOTYPE_TYPE_EXTO); + if !is_root && !is_ex_to { + continue; + } + + let visual = object_visuals + .get(component_index) + .and_then(|visual_id| assets.visual_by_id(*visual_id)); + let node_count = visual.map_or(0, |visual| visual.model_nodes); + let model = visual + .and_then(|visual| visual.model_id) + .and_then(|model_id| assets.model_by_id(model_id)); + let parent_base = if is_ex_to { + i32::try_from(global_node_cursor) + .ok() + .and_then(|count| count.checked_sub(1)) + .ok_or(Unavailable::UnsupportedExToNodeMapping { + unit_component_index: component_index, + })? + } else { + 0 + }; + let mount_node = if is_root { + Some(0) + } else { + native_component_mount_node( + &tree, + &component_ids, + &first_global_nodes, + component_index, + draft.unit_components[component_index].parent_or_link, + ) + }; + let first_source_node = usize::from(is_ex_to); + for source_node_index in first_source_node..node_count { + global_mesh_states.push(model.and_then(|model| { + initial_control_mesh_state(model, source_node_index, parent_base, mount_node) + })); + } + let contribution = node_count.saturating_sub(first_source_node); + global_node_cursor = global_node_cursor + .checked_add(contribution) + .ok_or(Unavailable::ComponentAlignmentMismatch)?; + } + let mut devices = Vec::new(); let mut node_provider_status = MissionControlNodeProviderTableStatus::Available(Vec::new()); let mut has_control_resource = false; @@ -2896,6 +3485,9 @@ fn build_control_device_projection( if !has_control_resource { return Err(Unavailable::NoControlResource); } + if let MissionControlNodeProviderTableStatus::Available(rows) = &mut node_provider_status { + attach_initial_mesh_states_by_global_ordinal(rows, &global_mesh_states); + } Ok(ControlDeviceProjection { devices, node_provider_status, @@ -2936,11 +3528,76 @@ fn append_control_node_provider_rows( unit_component_index, source_row_index, source_row: source_row.clone(), + initial_amount_bits: source_row.max_volume.to_bits(), initial_type1_value_bits: 0x3f80_0000, + initial_mesh_state: None, }); } } +fn control_flags_from_node38_header(header_flags: u16) -> u32 { + let mut flags = 0; + if header_flags & 0x0200 != 0 { + flags |= 0x01; + } + if header_flags & 0x0100 != 0 { + flags |= 0x02; + } + if header_flags & 0x0400 != 0 { + flags |= 0x04; + } + if header_flags & 0x0001 != 0 && header_flags & 0x0080 == 0 { + flags |= 0x08; + } + flags +} + +fn native_mesh_parent_index( + parent_or_link_raw: u16, + parent_base: i32, + mount_node: Option<u32>, +) -> Option<i32> { + if parent_or_link_raw == 0 { + i32::try_from(mount_node?).ok() + } else { + let relative_parent = if parent_or_link_raw == u16::MAX { + -1 + } else { + i32::from(parent_or_link_raw) + }; + parent_base.checked_add(relative_parent) + } +} + +fn initial_control_mesh_state( + model: &fparkan_assets::PreparedModel, + source_node_index: usize, + parent_base: i32, + mount_node: Option<u32>, +) -> Option<MissionControlNodeInitialMeshState> { + let node_index = u32::try_from(source_node_index).ok()?; + let node = node38_metadata(&model.validated, NodeId(node_index))?; + let stage_prefix = (0..3_u8) + .take_while(|state| { + selected_slot(&model.validated, NodeId(node_index), Lod(*state), Group(0)).is_some() + }) + .count(); + Some(MissionControlNodeInitialMeshState { + parent_index: native_mesh_parent_index(node.parent_or_link_raw, parent_base, mount_node)?, + flags: control_flags_from_node38_header(node.header_flags), + stage_count: u32::try_from(stage_prefix.max(1)).ok()?, + }) +} + +fn attach_initial_mesh_states_by_global_ordinal( + provider_rows: &mut [MissionControlNodeProviderRow], + global_mesh_states: &[Option<MissionControlNodeInitialMeshState>], +) { + for (ordinal, row) in provider_rows.iter_mut().enumerate() { + row.initial_mesh_state = global_mesh_states.get(ordinal).copied().flatten(); + } +} + fn add_behavior_registered_object( distributor: &mut BehaviorDistributorState, mut object: BehaviorRegisteredObject, @@ -3432,10 +4089,78 @@ mod tests { name: [0; 32], }, }, + initial_amount_bits: 100.0_f32.to_bits(), initial_type1_value_bits, + initial_mesh_state: None, } } + fn synthetic_node38( + header_flags: u16, + parent_or_link: u16, + group0_states: [bool; 3], + ) -> [u8; 38] { + let mut node = [0xff; 38]; + node[0..2].copy_from_slice(&header_flags.to_le_bytes()); + node[2..4].copy_from_slice(&parent_or_link.to_le_bytes()); + node[4..6].copy_from_slice(&u16::MAX.to_le_bytes()); + node[6..8].copy_from_slice(&0_u16.to_le_bytes()); + for (state, present) in group0_states.into_iter().enumerate() { + let slot = if present { 0_u16 } else { u16::MAX }; + let offset = 8 + state * 10; + node[offset..offset + 2].copy_from_slice(&slot.to_le_bytes()); + } + node + } + + fn synthetic_model_asset(nodes: &[[u8; 38]]) -> fparkan_msh::ModelAsset { + let mut nodes_raw = Vec::with_capacity(nodes.len() * 38); + for node in nodes { + nodes_raw.extend_from_slice(node); + } + fparkan_msh::ModelAsset { + node_stride: 38, + node_count: nodes.len(), + nodes_raw, + bounding_sphere_center: [0.0; 3], + bounding_sphere_radius: 0.0, + slots: vec![fparkan_msh::Slot { + tri_start: 0, + tri_count: 0, + batch_start: 0, + batch_count: 0, + aabb_min: [0.0; 3], + aabb_max: [0.0; 3], + sphere_center: [0.0; 3], + sphere_radius: 0.0, + opaque: [0; 5], + }], + positions: Vec::new(), + normals: None, + uv0: None, + uv1: None, + indices: Vec::new(), + batches: Vec::new(), + node_names: None, + animation: None, + } + } + + fn attach_synthetic_model( + assets: &mut MissionAssets, + component_index: usize, + nodes: &[[u8; 38]], + ) { + let model_id = AssetId::<fparkan_assets::PreparedModel>::new(100 + component_index as u64); + assets.visuals[component_index].model_id = Some(model_id); + assets.models.push(fparkan_assets::PreparedModel { + id: model_id, + source: synthetic_resource_key(500 + component_index), + validated: synthetic_model_asset(nodes), + mesh_dependencies: Vec::new(), + }); + } + fn synthetic_control_fixture( source_types: &[Option<u32>], kinds: &[u32], @@ -4272,6 +4997,79 @@ mod tests { } #[test] + fn behavior_elapsed_seconds_preserve_native_qword_conversion_rounding() { + let vectors = [ + (1, 0x3a83_126f), + (1_001, 0x3f80_20c5), + (16_777_217, 0x4683_1270), + (16_777_219, 0x4683_1271), + (u32::MAX, 0x4a83_126f), + (u32::MAX - 1, 0x4a83_126f), + ]; + for (elapsed_ms, expected_bits) in vectors { + assert_eq!( + behavior_elapsed_seconds(elapsed_ms).to_bits(), + expected_bits, + "elapsed={elapsed_ms}" + ); + } + } + + #[test] + fn behavior_distributor_scheduler_requires_a_strictly_later_unsigned_time() { + let original = BehaviorWarmStartState { + first_time_ms: 100, + next_deadline_ms: 200, + cleared_words: [0x11; 5], + }; + let mut state = original; + let mut rng_state = 1; + + assert_eq!( + schedule_behavior_distributor_tick(&mut state, 200, &mut rng_state), + None + ); + assert_eq!(state, original); + assert_eq!(rng_state, 1); + + let elapsed = schedule_behavior_distributor_tick(&mut state, 201, &mut rng_state) + .expect("deadline is passed"); + assert_eq!(elapsed.to_bits(), behavior_elapsed_seconds(101).to_bits()); + assert_eq!(state.first_time_ms, 201); + assert_eq!(state.next_deadline_ms, 403); + assert_eq!(state.cleared_words, [0x11; 5]); + assert_eq!(rng_state, 0x0029_e2c0); + } + + #[test] + fn behavior_distributor_scheduler_wraps_elapsed_but_keeps_unsigned_deadline_order() { + let mut state = BehaviorWarmStartState { + first_time_ms: u32::MAX - 15, + next_deadline_ms: 5, + cleared_words: [0; 5], + }; + let mut rng_state = 1; + + assert_eq!( + schedule_behavior_distributor_tick(&mut state, 5, &mut rng_state), + None + ); + assert_eq!(state.next_deadline_ms, 5); + let elapsed = schedule_behavior_distributor_tick(&mut state, 6, &mut rng_state) + .expect("current time is unsigned-greater than deadline"); + assert_eq!(elapsed.to_bits(), behavior_elapsed_seconds(22).to_bits()); + assert_eq!(state.first_time_ms, 6); + + let before = state; + assert_eq!( + schedule_behavior_distributor_tick(&mut state, 1, &mut rng_state), + None, + "unsigned 1 is not strictly later than the current deadline" + ); + assert_eq!(state, before); + } + + #[test] fn mission_script_start_stops_before_warming_later_bundles() { fn push_u32(bytes: &mut Vec<u8>, value: u32) { bytes.extend_from_slice(&value.to_le_bytes()); @@ -4626,6 +5424,155 @@ mod tests { } #[test] + fn synthetic_node_provider_projection_joins_flat_mesh_metadata_by_global_ordinal() { + let mut controls = vec![ + Some(control_with_synthetic_node_data(0, Vec::new(), 3)), + Some(control_with_synthetic_node_data(1, Vec::new(), 3)), + ]; + controls[0] + .as_mut() + .expect("root component control") + .node_data + .as_mut() + .expect("root NDP") + .rows[0] + .max_volume = 0.0; + let (draft, mut assets, prototypes) = synthetic_control_fixture( + // Even if the root's registry prototype is typed EXTO, its model + // contributes every source node; only mounted EXTO rows skip node 0. + &[Some(PROTOTYPE_TYPE_EXTO), Some(PROTOTYPE_TYPE_EXTO)], + &[1, 1], + &[1, 0], + &[0, 1], + &[2, 3], + controls, + ); + attach_synthetic_model( + &mut assets, + 0, + &[ + synthetic_node38(0x0701, 0xffff, [true, true, false]), + synthetic_node38(0x0081, 0, [false, true, true]), + ], + ); + attach_synthetic_model( + &mut assets, + 1, + &[ + synthetic_node38(0, 0xffff, [true, false, false]), + synthetic_node38(0x0200, 0, [true, false, true]), + synthetic_node38(0x0400, 0xffff, [true, true, true]), + ], + ); + + let projection = build_control_device_projection( + 0, + &draft, + &assets, + Some(&(0..prototypes.len())), + &prototypes, + ) + .expect("synthetic Control projection"); + let MissionControlNodeProviderTableStatus::Available(rows) = + projection.node_provider_status + else { + panic!("synthetic provider rows should be available"); + }; + + assert_eq!(rows.len(), 5); + assert_eq!( + rows.iter() + .map(|row| (row.unit_component_index, row.source_row_index)) + .collect::<Vec<_>>(), + [(0, 0), (0, 1), (0, 2), (1, 1), (1, 2)] + ); + assert_eq!( + rows.iter() + .map(|row| row.initial_mesh_state) + .collect::<Vec<_>>(), + [ + Some(MissionControlNodeInitialMeshState { + parent_index: -1, + flags: 0x0f, + stage_count: 2, + }), + Some(MissionControlNodeInitialMeshState { + parent_index: 0, + flags: 0, + stage_count: 1, + }), + // This row is still from the root NDP. The native global + // ordinal has moved on to the first non-root EXTO mesh node. + Some(MissionControlNodeInitialMeshState { + parent_index: 1, + flags: 1, + stage_count: 1, + }), + Some(MissionControlNodeInitialMeshState { + parent_index: 0, + flags: 4, + stage_count: 3, + }), + None, + ] + ); + assert!(rows[..4].iter().all(|row| row.initial_mesh_state.is_some())); + assert_eq!( + rows.iter() + .map(|row| row.initial_amount_bits) + .collect::<Vec<_>>(), + [ + 0.0_f32.to_bits(), + 101.0_f32.to_bits(), + 102.0_f32.to_bits(), + 101.0_f32.to_bits(), + 102.0_f32.to_bits(), + ] + ); + assert_eq!(rows[0].initial_type1_value_bits, 1.0_f32.to_bits()); + } + + #[test] + fn missing_initial_mesh_metadata_keeps_provider_query_available() { + let mut device = synthetic_effective_control_device( + 26, + 26, + 2.0_f32.to_bits(), + Some(3.0_f32.to_bits()), + None, + ); + device.key = 0; + device.descriptor.fixed_words[1] = 0; + let provider = synthetic_node_provider_row(0, 0, 2.0_f32.to_bits()); + assert_eq!(provider.initial_mesh_state, None); + let table = synthetic_control_device_table_with_providers( + MissionControlDeviceTableStatus::Available(vec![device]), + MissionControlNodeProviderTableStatus::Available(vec![provider]), + ); + + assert_eq!( + query_control_device_table_selector(&table, 0, 0xe00) + .expect("NDP query remains independent of the MSH projection"), + Some(12.0) + ); + } + + #[test] + fn native_mesh_metadata_maps_control_flags_and_parent_words() { + assert_eq!(control_flags_from_node38_header(0x0701), 0x0f); + assert_eq!(control_flags_from_node38_header(0x0781), 0x07); + + assert_eq!(native_mesh_parent_index(0xffff, 0, None), Some(-1)); + assert_eq!(native_mesh_parent_index(0, 0, Some(0)), Some(0)); + assert_eq!(native_mesh_parent_index(0xffff, 21, None), Some(20)); + assert_eq!(native_mesh_parent_index(1, 21, None), Some(22)); + assert_eq!(native_mesh_parent_index(0xfffe, 21, None), Some(65_555)); + assert_eq!(native_mesh_parent_index(0x8000, 21, None), Some(32_789)); + assert_eq!(native_mesh_parent_index(0, 21, Some(7)), Some(7)); + assert_eq!(native_mesh_parent_index(0, 21, None), None); + } + + #[test] fn missing_node_provider_does_not_hide_aggregate_queries() { let controls = vec![Some(synthetic_component_control( 0, @@ -5178,6 +6125,128 @@ mod tests { assert_eq!(root_node_data.rows.len(), 22); assert_eq!(ext_node_data.rows.len(), 4); assert_eq!(provider_rows.len(), 25); + assert_eq!(provider_rows[0].initial_amount_bits, 1.0_f32.to_bits()); + assert_eq!(provider_rows[22].initial_amount_bits, 6000.0_f32.to_bits()); + assert_eq!( + provider_rows[0].initial_amount_bits, + provider_rows[0].source_row.max_volume.to_bits() + ); + assert_eq!( + provider_rows[22].initial_amount_bits, + provider_rows[22].source_row.max_volume.to_bits() + ); + let mission_assets = &engine + .loaded + .as_ref() + .expect("loaded mission state") + .mission_assets; + let visual_root_node_count = mission_assets + .visual_by_id(mission_assets.object_visuals[0][0]) + .expect("root visual") + .model_nodes; + assert_eq!(visual_root_node_count, 22); + let assert_mesh_node = + |component_index: usize, + source_node_index: usize, + expected_header: u16, + expected_parent: u16, + expected_slots: [u16; 15], + expected_state: MissionControlNodeInitialMeshState| { + let visual_id = mission_assets.object_visuals[0][component_index]; + let visual = mission_assets + .visual_by_id(visual_id) + .expect("component visual"); + let model = mission_assets + .model_by_id(visual.model_id.expect("component model")) + .expect("prepared model"); + let offset = source_node_index * model.validated.node_stride; + let raw_flags = u16::from_le_bytes( + model.validated.nodes_raw[offset..offset + 2] + .try_into() + .expect("raw header flags"), + ); + let raw_parent = u16::from_le_bytes( + model.validated.nodes_raw[offset + 2..offset + 4] + .try_into() + .expect("raw parent"), + ); + let raw_slots = std::array::from_fn::<_, 15, _>(|slot| { + u16::from_le_bytes( + model.validated.nodes_raw[offset + 8 + slot * 2..offset + 10 + slot * 2] + .try_into() + .expect("raw slot word"), + ) + }); + let global_index = if component_index == 0 { + source_node_index + } else { + visual_root_node_count + source_node_index - 1 + }; + assert_eq!(raw_flags, expected_header); + assert_eq!(raw_parent, expected_parent); + assert_eq!(raw_slots, expected_slots); + assert_eq!( + provider_rows[global_index].initial_mesh_state, + Some(expected_state) + ); + }; + assert_mesh_node( + 0, + 0, + 0x0000, + 0xffff, + [0xffff; 15], + MissionControlNodeInitialMeshState { + parent_index: -1, + flags: 0, + stage_count: 1, + }, + ); + assert_mesh_node( + 0, + 1, + 0x0110, + 0x0000, + [ + 0x000b, 0x0025, 0x0026, 0xffff, 0xffff, 0x0013, 0x0027, 0x0028, 0xffff, 0xffff, + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, + ], + MissionControlNodeInitialMeshState { + parent_index: 0, + flags: 2, + stage_count: 2, + }, + ); + assert_mesh_node( + 5, + 1, + 0x0000, + 0x0000, + [ + 0x0000, 0x0001, 0x0002, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, + ], + MissionControlNodeInitialMeshState { + parent_index: 9, + flags: 0, + stage_count: 1, + }, + ); + assert_mesh_node( + 5, + 2, + 0x0010, + 0x0001, + [ + 0x0004, 0x0007, 0x0008, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, + ], + MissionControlNodeInitialMeshState { + parent_index: 22, + flags: 0, + stage_count: 1, + }, + ); let expected_provider_sources = (0..root_node_data.rows.len()) .map(|row| (0, row)) .chain((1..ext_node_data.rows.len()).map(|row| (5, row))) @@ -5192,6 +6261,9 @@ mod tests { assert!(provider_rows .iter() .all(|row| row.initial_type1_value_bits == 1.0_f32.to_bits())); + assert!(provider_rows + .iter() + .all(|row| row.initial_mesh_state.is_some())); assert_eq!( ( entries[9].factory_tag, @@ -5837,6 +6909,259 @@ mod tests { ); } + #[test] + #[ignore = "requires licensed corpus"] + fn licensed_autodemo_resource_ticks_use_queue_time_and_real_generator_profile() { + let root = licensed_root("IS"); + let vfs: Arc<dyn Vfs> = Arc::new(DirectoryVfs::new(root)); + let mut engine = create(EngineServices::new(vfs)).expect("engine"); + load_mission( + &mut engine, + MissionRequest { + key: "MISSIONS/Autodemo.00/data.tma".to_string(), + mode: MissionMode::AutoDemo, + }, + 100_000, + ) + .expect("load licensed AutoDemo"); + + let deadlines = loaded_mission_script_bundles(&engine) + .expect("script bundles") + .iter() + .map(|bundle| { + ( + bundle.clan_index, + bundle + .behavior_warm_start + .expect("full load warm-start") + .next_deadline_ms, + ) + }) + .collect::<Vec<_>>(); + assert_eq!(deadlines, [(0, 100_202), (1, 100_200)]); + assert_eq!( + advance_loaded_mission_resources(&mut engine, 100_000) + .expect("no due resource tick at warm start"), + 0 + ); + assert_eq!( + advance_loaded_mission_resources(&mut engine, 100_200) + .expect("strict deadline equality is not due"), + 0 + ); + + assert_eq!( + advance_loaded_mission_resources(&mut engine, 100_201).expect("clan 1 resource tick"), + 1 + ); + let first_totals = loaded_mission_script_bundles(&engine) + .expect("bundles after first tick") + .iter() + .find(|bundle| bundle.clan_index == 1) + .and_then(|bundle| bundle.behavior_warm_start) + .expect("clan 1 scheduler") + .cleared_words; + assert!( + f32::from_bits(first_totals[0]) > 0.0, + "clan 1's real prof_generator.var contributes power" + ); + assert_eq!( + advance_loaded_mission_resources(&mut engine, 100_202) + .expect("clan 0 deadline equality is not due"), + 0 + ); + + assert_eq!( + advance_loaded_mission_resources(&mut engine, 100_203).expect("clan 0 resource tick"), + 1 + ); + let second_totals = loaded_mission_script_bundles(&engine) + .expect("bundles after second tick") + .iter() + .find(|bundle| bundle.clan_index == 0) + .and_then(|bundle| bundle.behavior_warm_start) + .expect("clan 0 scheduler") + .cleared_words; + assert!( + f32::from_bits(second_totals[0]) > 0.0, + "clan 0's real prof_generator.var contributes power" + ); + + let first_tick_time = 100_500; + let deadlines = loaded_mission_script_bundles(&engine) + .expect("bundles after one tick per clan") + .iter() + .map(|bundle| { + bundle + .behavior_warm_start + .expect("full load warm-start") + .next_deadline_ms + }) + .collect::<Vec<_>>(); + assert!(deadlines.iter().all(|deadline| *deadline < first_tick_time)); + assert_eq!( + advance_loaded_mission_resources(&mut engine, first_tick_time) + .expect("second resource tick for each clan"), + 2 + ); + let totals_at_100500 = loaded_mission_script_bundles(&engine) + .expect("bundles at 100500") + .iter() + .map(|bundle| { + ( + bundle.clan_index, + bundle.behavior_warm_start.expect("full load warm-start"), + ) + }) + .collect::<Vec<_>>(); + for (clan, warm_start) in &totals_at_100500 { + assert_eq!(warm_start.first_time_ms, first_tick_time); + let elapsed = if *clan == 0 { 297 } else { 299 }; + assert_eq!( + warm_start.cleared_words[0], + (behavior_elapsed_seconds(elapsed) * 10.0).to_bits(), + "clan {clan} recomputes power availability from the elapsed interval" + ); + } + + assert_eq!( + advance_loaded_mission_resources(&mut engine, 101_000) + .expect("third resource tick for each clan"), + 2 + ); + let totals_at_101000 = loaded_mission_script_bundles(&engine) + .expect("bundles at 101000") + .iter() + .map(|bundle| { + ( + bundle.clan_index, + bundle.behavior_warm_start.expect("full load warm-start"), + ) + }) + .collect::<Vec<_>>(); + for (clan, warm_start) in &totals_at_101000 { + assert_eq!(warm_start.first_time_ms, 101_000); + assert_eq!( + warm_start.cleared_words[0], + 5.0_f32.to_bits(), + "clan {clan} replaces totals with the latest interval" + ); + let previous = totals_at_100500 + .iter() + .find(|(previous_clan, _)| previous_clan == clan) + .expect("same clan totals at previous tick") + .1; + assert_ne!(warm_start.cleared_words[0], previous.cleared_words[0]); + } + + assert!(loaded_mission_behavior_profiles(&engine) + .expect("loaded profiles") + .iter() + .filter(|profile| profile.class_flags == 0x8000_0002) + .all(|profile| profile.transfer_power_out_bits == 10.0_f32.to_bits())); + + for clan in [0, 1] { + let distributor = loaded_mission_behavior_distributors(&engine) + .expect("loaded distributors") + .iter() + .find(|distributor| distributor.clan_index == clan) + .expect("loaded clan distributor"); + assert_eq!(distributor.registered_objects.len(), 2); + let generator = loaded_mission_behavior_distributors(&engine) + .expect("loaded distributors") + .iter() + .find(|distributor| distributor.clan_index == clan) + .and_then(|distributor| { + distributor + .registered_objects + .iter() + .find(|object| object.class_flags == 0x8000_0002) + }) + .expect("licensed AutoDemo generator row"); + let profile = loaded_mission_behavior_profiles(&engine) + .expect("loaded Behavior profiles") + .iter() + .find(|profile| profile.handle == generator.handle) + .expect("generator profile"); + let totals = totals_at_101000 + .iter() + .find(|(candidate, _)| *candidate == clan) + .expect("generator clan totals") + .1 + .cleared_words; + println!( + "licensed AutoDemo Behavior tick: clan={clan} ObjectId={} profile={} Transfer_Power_Out={} PowerAvailable={} at queue times 100201/100203,100500,101000; registered rows={}", + generator.original_id.0, + profile.profile_entry.as_deref().unwrap_or("<defaults>"), + f32::from_bits(profile.transfer_power_out_bits), + f32::from_bits(totals[0]), + distributor.registered_objects.len(), + ); + } + + let second_plant = { + let loaded = engine.loaded.as_mut().expect("loaded mission state"); + let second = loaded + .behavior_distributors + .iter() + .find(|distributor| distributor.clan_index == 1) + .expect("clan 1 distributor"); + let plant = second + .registered_objects + .iter() + .find(|object| object.class_flags == 0x8000_0010) + .expect("clan 1 plant") + .clone(); + loaded + .control_device_tables + .retain(|table| table.handle != plant.handle); + plant + }; + assert_eq!(second_plant.class_flags, 0x8000_0010); + let before_distributors = loaded_mission_behavior_distributors(&engine) + .expect("rollback distributor snapshot") + .to_vec(); + let before_ore_states = loaded_mission_behavior_ore_states(&engine) + .expect("rollback ore snapshot") + .to_vec(); + let before_controls = loaded_mission_control_device_tables(&engine) + .expect("rollback Control snapshot") + .to_vec(); + let before_warm_starts = loaded_mission_script_bundles(&engine) + .expect("rollback bundles") + .iter() + .map(|bundle| bundle.behavior_warm_start) + .collect::<Vec<_>>(); + let before_rng = engine.behavior_rng_state; + let error = advance_loaded_mission_resources(&mut engine, 102_000) + .expect_err("missing clan 1 plant Control table fails after clan 0 stages a tick"); + assert!(matches!( + error, + EngineError::BehaviorDistributorTick { clan_index: 1, .. } + )); + assert_eq!( + loaded_mission_behavior_distributors(&engine), + Some(before_distributors.as_slice()) + ); + assert_eq!( + loaded_mission_behavior_ore_states(&engine), + Some(before_ore_states.as_slice()) + ); + assert_eq!( + loaded_mission_control_device_tables(&engine), + Some(before_controls.as_slice()) + ); + assert_eq!( + loaded_mission_script_bundles(&engine) + .expect("bundles after failed transaction") + .iter() + .map(|bundle| bundle.behavior_warm_start) + .collect::<Vec<_>>(), + before_warm_starts + ); + assert_eq!(engine.behavior_rng_state, before_rng); + } + fn behavior_test_object( slot: u32, share: f32, @@ -6075,6 +7400,237 @@ mod tests { } #[test] + fn behavior_allocation_matches_shortage_middle_surplus_and_equality_branches() { + let shortage = behavior_allocation(1.0, 6.0, 3.0).expect("shortage allocation"); + assert_eq!(shortage.priority.to_bits(), 0x3eaa_aaab); + assert_eq!(shortage.residual.to_bits(), 0); + assert_eq!(shortage.consumption.to_bits(), 1.0_f32.to_bits()); + + let middle = behavior_allocation(0.25, 0.375, 0.1875).expect("middle allocation"); + assert_eq!(middle.priority.to_bits(), 1.0_f32.to_bits()); + assert_eq!(middle.residual.to_bits(), 0x3eaa_aaab); + assert_eq!(middle.consumption.to_bits(), 1.0_f32.to_bits()); + + let surplus = behavior_allocation(2.0, 0.375, 0.1875).expect("surplus allocation"); + assert_eq!(surplus.priority.to_bits(), 1.0_f32.to_bits()); + assert_eq!(surplus.residual.to_bits(), 1.0_f32.to_bits()); + assert_eq!(surplus.consumption.to_bits(), 0x3e40_0000); + + let exact = behavior_allocation(0.375, 0.375, 0.1875).expect("exact allocation"); + assert_eq!(exact.priority.to_bits(), 1.0_f32.to_bits()); + assert_eq!(exact.residual.to_bits(), 1.0_f32.to_bits()); + assert_eq!(exact.consumption.to_bits(), 1.0_f32.to_bits()); + } + + fn behavior_tick_test_object( + world: &mut World, + original_id: u32, + class_flags: u32, + share: f32, + ) -> BehaviorRegisteredObject { + let original_id = OriginalObjectId(original_id); + let handle = construct_object( + world, + ObjectDraft { + original_id: Some(original_id), + }, + ) + .expect("construct Behavior tick object"); + register_object(world, handle).expect("register Behavior tick object"); + BehaviorRegisteredObject { + original_id, + handle, + selector: 0, + class_flags, + share, + native_tail: [0; 5], + } + } + + fn behavior_tick_test_control_table( + original_id: u32, + handle: ObjectHandle, + ) -> MissionControlDeviceTableState { + let device = synthetic_effective_control_device( + 19, + 19, + 0.75_f32.to_bits(), + Some(0.5_f32.to_bits()), + None, + ); + MissionControlDeviceTableState { + original_id: Some(OriginalObjectId(original_id)), + handle, + status: MissionControlDeviceTableStatus::Available(vec![device]), + node_provider_status: MissionControlNodeProviderTableStatus::Available(Vec::new()), + } + } + + #[test] + fn behavior_power_source_also_contributes_ore_demand() { + let mut world = new_world(WorldConfig); + let producer = behavior_tick_test_object(&mut world, 1, 0x8000_0002, 0.5); + let recipient = behavior_tick_test_object(&mut world, 2, 0x8000_0001, 0.5); + let mut distributor = BehaviorDistributorState { + clan_index: 0, + super_ai_visible: true, + registered_objects: vec![producer.clone(), recipient.clone()], + }; + let mut ore_states = [producer.clone(), recipient.clone()] + .into_iter() + .map(|object| BehaviorOreState { + original_id: object.original_id, + handle: object.handle, + class_flags: object.class_flags, + current_ore_bits: 1.0_f32.to_bits(), + maximum_ore_bits: 10.0_f32.to_bits(), + }) + .collect::<Vec<_>>(); + let profiles = [BehaviorProfileState { + original_id: OriginalObjectId(1), + handle: producer.handle, + class_flags: producer.class_flags, + profile_entry: None, + transfer_ore_off_board_bits: 0x40a0_0000, + transfer_power_out_bits: 4.0_f32.to_bits(), + }]; + let mut control_tables = vec![ + behavior_tick_test_control_table(1, producer.handle), + behavior_tick_test_control_table(2, recipient.handle), + ]; + + let totals = advance_behavior_distributor_tick( + &mut distributor, + 1.0, + &world, + &mut ore_states, + &profiles, + &mut control_tables, + ) + .expect("tick supported power source and generic receiver"); + + assert_eq!( + totals[4], + 18.0_f32.to_bits(), + "both native classes compute the non-source ore demand" + ); + } + + #[test] + fn behavior_ore_source_also_contributes_power_demand() { + let mut world = new_world(WorldConfig); + let producer = behavior_tick_test_object(&mut world, 3, 0x8000_0004, 1.0); + let mut distributor = BehaviorDistributorState { + clan_index: 0, + super_ai_visible: true, + registered_objects: vec![producer.clone()], + }; + let mut ore_states = [producer.clone()] + .into_iter() + .map(|object| BehaviorOreState { + original_id: object.original_id, + handle: object.handle, + class_flags: object.class_flags, + current_ore_bits: 0.25_f32.to_bits(), + maximum_ore_bits: 10.0_f32.to_bits(), + }) + .collect::<Vec<_>>(); + let profiles = [BehaviorProfileState { + original_id: OriginalObjectId(3), + handle: producer.handle, + class_flags: producer.class_flags, + profile_entry: None, + transfer_ore_off_board_bits: 4.0_f32.to_bits(), + transfer_power_out_bits: 0.0_f32.to_bits(), + }]; + let mut ore_device = synthetic_effective_control_device( + 26, + 26, + 1.0_f32.to_bits(), + Some(1.0_f32.to_bits()), + None, + ); + ore_device.key = 0; + let producer_table = MissionControlDeviceTableState { + original_id: Some(OriginalObjectId(3)), + handle: producer.handle, + status: MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device( + 19, + 19, + 0.75_f32.to_bits(), + Some(0.5_f32.to_bits()), + None, + ), + ore_device, + ]), + node_provider_status: MissionControlNodeProviderTableStatus::Available(vec![ + synthetic_node_provider_row(0, 0, 1.0_f32.to_bits()), + ]), + }; + let mut control_tables = vec![producer_table]; + + let totals = advance_behavior_distributor_tick( + &mut distributor, + 1.0, + &world, + &mut ore_states, + &profiles, + &mut control_tables, + ) + .expect("tick supported ore source"); + + assert_eq!( + totals[3], + 0.375_f32.to_bits(), + "ore producers still query generic Control power demand" + ); + } + + #[test] + fn behavior_first_pass_clamps_tiny_deficits_and_overfull_stores() { + for (original_id, current, maximum, clamps) in [ + (4, 0.995_f32, 1.0_f32, true), + (5, 1.25, 1.0, true), + (6, 0.0, f32::from_bits(0x3c23_d70a), false), + ] { + let mut world = new_world(WorldConfig); + let object = behavior_tick_test_object(&mut world, original_id, 0x8000_0001, 0.5); + let mut distributor = BehaviorDistributorState { + clan_index: 0, + super_ai_visible: true, + registered_objects: vec![object.clone()], + }; + let mut ore_states = [BehaviorOreState { + original_id: object.original_id, + handle: object.handle, + class_flags: object.class_flags, + current_ore_bits: current.to_bits(), + maximum_ore_bits: maximum.to_bits(), + }]; + let mut control_tables = [MissionControlDeviceTableState { + original_id: Some(object.original_id), + handle: object.handle, + status: MissionControlDeviceTableStatus::Available(Vec::new()), + node_provider_status: MissionControlNodeProviderTableStatus::Available(Vec::new()), + }]; + + advance_behavior_distributor_tick( + &mut distributor, + 1.0, + &world, + &mut ore_states, + &[], + &mut control_tables, + ) + .expect("native low-deficit clamp path"); + + let expected = if clamps { maximum } else { current }; + assert_eq!(ore_states[0].current_ore_bits, expected.to_bits()); + } + } + + #[test] #[ignore = "requires licensed corpus"] fn licensed_campaign_preview_keeps_unsupported_init_without_partial_writes() { let root = licensed_root("IS"); |