diff options
Diffstat (limited to 'crates/fparkan-runtime/src')
| -rw-r--r-- | crates/fparkan-runtime/src/lib.rs | 2890 |
1 files changed, 2884 insertions, 6 deletions
diff --git a/crates/fparkan-runtime/src/lib.rs b/crates/fparkan-runtime/src/lib.rs index 3964f78..cd7f2c2 100644 --- a/crates/fparkan-runtime/src/lib.rs +++ b/crates/fparkan-runtime/src/lib.rs @@ -1,20 +1,24 @@ #![forbid(unsafe_code)] //! Runtime orchestration for mission loading and world stepping. +#[cfg(test)] +use fparkan_assets::PreparedControlResourcePair; use fparkan_assets::{ decode_mission_land_path, decode_mission_payload, decode_nres_payload, derive_mission_land_paths, extend_graph_report_with_visual_dependencies, mission_script_bundle_bases, prepare_terrain_world, AssetError as AssetPreparationError, AssetId, AssetManager, BuildCategory, MissionAssetPlan, MissionDocument, MissionError, - MissionTerrainPaths, NresError, PreparedVisual, TerrainFormatError, TerrainPreparationError, - TerrainWorld, TmaProfile, + MissionTerrainPaths, NresError, PreparedComponentControl, PreparedControlEffectSection, + PreparedControlNodeDataRow, PreparedControlNodeDataTable, PreparedControlTypedRecord, + PreparedVisual, TerrainFormatError, TerrainPreparationError, TerrainWorld, TmaProfile, }; use fparkan_path::{normalize_relative, NormalizedPath, PathError, PathPolicy}; use fparkan_prototype::{ - build_prototype_graph_report, PrototypeGraph, PrototypeGraphFailure, PrototypeGraphReport, - UnitComponentRecord, UNIT_DAT_BAS_PLACEMENT_FLAG, + build_prototype_graph_report, unit_component_tree, PrototypeGraph, PrototypeGraphFailure, + PrototypeGraphReport, UnitComponentRecord, UnitComponentTreeNode, PROTOTYPE_TYPE_EXTO, + UNIT_DAT_BAS_PLACEMENT_FLAG, }; -use fparkan_resource::{resource_name, CachedResourceRepository, ResourceRepository}; +use fparkan_resource::{resource_name, CachedResourceRepository, ResourceKey, ResourceRepository}; use fparkan_script::{ Handler19DwordWrite, Handler19InitInput, Handler19InitResolution, Handler19ResolveError, ScriptInstruction, ScriptPackage, VarSet, VarSetDefault, VmHostCallbackCommand, @@ -134,6 +138,223 @@ pub struct BehaviorRegisteredObject { pub native_tail: [u32; 5], } +/// Native `CurrentOre`/`MaximumOre` state for one full Unit DAT mission object. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub struct BehaviorOreState { + /// Stable identity from the source TMA object order. + pub original_id: OriginalObjectId, + /// Corresponding live Rust world object. + pub handle: ObjectHandle, + /// Class word recovered from the root Unit DAT header. + pub class_flags: u32, + /// Raw bits of the `CurrentOre` float property. + pub current_ore_bits: u32, + /// Raw bits of the read-only `MaximumOre` float property. + pub maximum_ore_bits: u32, +} + +/// Origin of a Control descriptor retained in the effective table projection. +#[derive(Clone, Debug, PartialEq)] +pub struct ControlDeviceRecordProvenance { + /// Unit DAT component index that supplied the descriptor. + pub unit_component_index: usize, + /// Zero-based record index in that component's CTLD typed-record list. + pub typed_record_index: usize, + /// CTLD resource that supplied the descriptor. + pub source: ResourceKey, +} + +/// Common fields known for one row in a host object's Control device table. +/// +/// The row index is its position in the containing `Vec`. This stores the +/// confirmed base fields and latest raw descriptor, not tag-specific callbacks. +#[derive(Clone, Debug, PartialEq)] +pub struct EffectiveControlDevice { + /// Factory tag of the original device instance; INTO does not replace it. + pub factory_tag: u32, + /// Native component ID that first appended this row. + pub component_id: u32, + /// Current common key field. INTO preserves the receiver's key. + pub key: u32, + /// Sixteen raw DWORD coefficients copied by the common setter. + pub coefficient_bits: Option<[u32; 16]>, + /// Multiplier bits when the factory default is confirmed. + pub multiplier_bits: Option<u32>, + /// Class-9-only scale used by its selector-0 getter. + pub class9_selector0_scale_bits: Option<u32>, + /// Current native word at `+0x50` when it is known. + pub native_word_50_bits: Option<u32>, + /// Current raw descriptor, including typed values and string bytes. + pub descriptor: PreparedControlTypedRecord, + /// Source location that created the original factory instance. + pub factory_provenance: ControlDeviceRecordProvenance, + /// Source location of the descriptor currently applied to the row. + pub descriptor_provenance: ControlDeviceRecordProvenance, +} + +/// 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. +#[derive(Clone, Debug, PartialEq)] +pub struct MissionControlNodeProviderRow { + /// NDP resource that contributed the row. + pub source: ResourceKey, + /// Unit DAT component that contributed the row. + pub unit_component_index: usize, + /// Index in that component's original NDP table. + pub source_row_index: usize, + /// Original NDP descriptor fields and provenance for this provider row. + pub source_row: PreparedControlNodeDataRow, + /// Initial native provider selector-1 value (`+0x14`) as raw bits. + pub initial_type1_value_bits: u32, +} + +/// Availability of the initial global Control node-data provider projection. +#[derive(Clone, Debug, PartialEq)] +pub enum MissionControlNodeProviderTableStatus { + /// Rows in native append order, without padding to the MSH node count. + Available(Vec<MissionControlNodeProviderRow>), + /// Provider lookup is not modeled for this object's available inputs. + Unavailable(MissionControlNodeProviderTableUnavailableReason), +} + +/// Why the global Control node-data provider could not be projected. +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum MissionControlNodeProviderTableUnavailableReason { + /// A root or mounted EXTO Control resource has no resolved NDP sidecar. + MissingNodeData { + /// Unit DAT component needing the provider rows. + unit_component_index: usize, + /// Explicitly requested sidecar when the reference was known. + source: Option<ResourceKey>, + }, + /// A mounted EXTO needs a first NDP row for the native skip-first path. + MissingExToRootRow { unit_component_index: usize }, + /// The Control component traversal itself was incomplete. + DeviceTableUnavailable(MissionControlDeviceTableUnavailableReason), +} + +/// Why a loaded Control resource query or write could not be represented. +#[derive(Debug, Eq, PartialEq)] +pub enum ControlResourceAccessError { + /// The requested world object handle is invalid, stale, or deleted. + World(fparkan_world::WorldError), + /// No mission is currently loaded. + MissionUnavailable, + /// The live object is not part of the loaded mission projection. + ObjectUnavailable { handle: ObjectHandle }, + /// The object's Control table could not be completely projected. + TableUnavailable(MissionControlDeviceTableUnavailableReason), + /// This wrapper only implements native resource selectors 1 and 2. + UnsupportedSelector(u32), + /// A selected row has a factory class whose getter has not been checked. + UnsupportedFactoryTag { factory_tag: u32 }, + /// A device index does not exist in the object's native Control table. + DeviceIndexOutOfRange { + /// Requested global Control device index. + device_index: usize, + /// Projected device count. + device_count: usize, + }, + /// The node provider table could not be projected. + NodeProviderTableUnavailable(MissionControlNodeProviderTableUnavailableReason), + /// A device's native provider key exceeds the actual appended NDP rows. + NodeProviderKeyOutOfRange { + /// Current native device key, used directly as a provider row index. + key: u32, + /// Actual global provider row count. + row_count: usize, + }, + /// A native tag has an e00 callback that has not been implemented here. + UnsupportedCurrentTag { tag: u32 }, + /// A selected row lacks a value needed by the native getter or setter. + UnsupportedField { + factory_tag: u32, + field: &'static str, + }, + /// A native float operand or intermediate is not finite. + NonFiniteValue { + factory_tag: u32, + field: &'static str, + }, + /// A native float operand is subnormal and is outside the checked domain. + SubnormalValue { + factory_tag: u32, + field: &'static str, + }, + /// A range probe places a nonzero arithmetic result outside normal f32 range. + UnsupportedFloatRange { + factory_tag: Option<u32>, + field: &'static str, + }, +} + +/// Why the base Control device table could not be projected for an object. +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum MissionControlDeviceTableUnavailableReason { + /// The mission root has no decoded Unit DAT component tree. + NoUnitDatTree, + /// Unit DAT child counts do not form a valid preorder tree. + InvalidUnitComponentTree, + /// Prototype, visual, and component data are not aligned. + ComponentAlignmentMismatch, + /// No component explicitly references a Control resource. + NoControlResource, + /// An explicit Control resource could not be prepared. + ControlResourceUnavailable { unit_component_index: usize }, + /// A Control resource belongs to a non-geometric prototype. + NonGeometricControlResource { unit_component_index: usize }, + /// The parser stopped before the component's typed record list completed. + IncompleteTypedRecordList { + unit_component_index: usize, + first_unparsed_record: usize, + }, + /// An INTO descriptor has no first typed record for its one native override call. + MissingOverrideRecord { unit_component_index: usize }, + /// Native wrapping produced a non-sentinel index outside the current table. + OverrideIndexOutOfRange { + unit_component_index: usize, + target_index: u32, + }, + /// The receiver tag does not have a verified common override method. + UnsupportedOverrideReceiver { factory_tag: u32 }, + /// The EXTO key needs a global model-node mapping that is not available. + UnsupportedExToNodeMapping { unit_component_index: usize }, + /// An unknown component kind prevents calculating EXTO global node offsets. + UnknownComponentKindForExTo { + unit_component_index: usize, + source_type: Option<u32>, + }, +} + +/// Availability of the confirmed common-field Control table projection. +#[derive(Clone, Debug, PartialEq)] +pub enum MissionControlDeviceTableStatus { + /// Rows in native global-table order. + Available(Vec<EffectiveControlDevice>), + /// No complete table is exposed when required source state is unsupported. + Unavailable(MissionControlDeviceTableUnavailableReason), +} + +/// Control device table projection attached to one loaded mission object. +#[derive(Clone, Debug, PartialEq)] +pub struct MissionControlDeviceTableState { + /// Stable identity from the source TMA object order. + pub original_id: Option<OriginalObjectId>, + /// Corresponding live Rust world object. + pub handle: ObjectHandle, + /// Complete base projection, or an explicit unsupported boundary. + pub status: MissionControlDeviceTableStatus, + /// Initial global NDP provider rows used by indexed Control selectors. + pub node_provider_status: MissionControlNodeProviderTableStatus, +} + +struct ControlDeviceProjection { + devices: Vec<EffectiveControlDevice>, + node_provider_status: MissionControlNodeProviderTableStatus, +} + /// Resource distributor state associated with one TMA clan's constructed AI. #[derive(Clone, Debug, PartialEq)] pub struct BehaviorDistributorState { @@ -148,6 +369,8 @@ pub struct BehaviorDistributorState { const LAST_SUPER_AI_TABLE_INDEX: u32 = 63; const BEHAVIOR_REGISTRATION_KEY_FLAG: u32 = 0x8000_0000; +#[cfg(test)] +const PROTOTYPE_TYPE_INTO: u32 = u32::from_le_bytes(*b"INTO"); /// Native terrain adjustment selected for a mission object's BAS geometry. #[derive(Clone, Copy, Debug, Eq, PartialEq)] @@ -464,6 +687,8 @@ struct LoadedMissionState { asset_plan: MissionAssetPlan, object_drafts: Vec<MissionObjectDraft>, behavior_distributors: Vec<BehaviorDistributorState>, + behavior_ore_states: Vec<BehaviorOreState>, + control_device_tables: Vec<MissionControlDeviceTableState>, script_bundles: Vec<MissionScriptBundle>, script_varset: Option<MissionScriptVarSet>, script_init_states: Vec<MissionScriptInitState>, @@ -1045,6 +1270,64 @@ fn load_mission_with_options( Vec::new() }; + let behavior_ore_states = if options.asset_scope == MissionAssetScope::Full { + // Property callbacks also run for Unit DAT objects that do not join a distributor. + object_drafts + .iter() + .zip(&handles) + .filter_map(|(draft, handle)| { + Some(initialize_behavior_ore_state( + draft.original_id?, + *handle, + draft.unit_dat_header_flags?, + &draft.properties, + )) + }) + .collect() + } else { + Vec::new() + }; + + let control_device_tables = if options.asset_scope == MissionAssetScope::Full { + object_drafts + .iter() + .zip(&handles) + .enumerate() + .map(|(object_index, (draft, handle))| { + let projection = build_control_device_projection( + object_index, + draft, + &mission_assets, + prototype_graph + .root_prototype_request_spans + .get(object_index), + &resolved_prototypes, + ); + match projection { + Ok(projection) => MissionControlDeviceTableState { + original_id: draft.original_id, + handle: *handle, + status: MissionControlDeviceTableStatus::Available(projection.devices), + node_provider_status: projection.node_provider_status, + }, + Err(reason) => MissionControlDeviceTableState { + original_id: draft.original_id, + handle: *handle, + status: MissionControlDeviceTableStatus::Unavailable(reason.clone()), + node_provider_status: + MissionControlNodeProviderTableStatus::Unavailable( + MissionControlNodeProviderTableUnavailableReason::DeviceTableUnavailable( + reason, + ), + ), + }, + } + }) + .collect() + } else { + Vec::new() + }; + let mut next_behavior_rng_state = engine.behavior_rng_state; if options.asset_scope == MissionAssetScope::Full { let queue_time_ms = queue_time_ms.expect("full mission loading requires a queue time"); @@ -1120,6 +1403,8 @@ fn load_mission_with_options( asset_plan: mission_asset_plan, object_drafts, behavior_distributors, + behavior_ore_states, + control_device_tables, script_bundles: loaded_scripts.bundles, script_varset: loaded_scripts.varset, script_init_states: loaded_scripts.init_states, @@ -1402,6 +1687,372 @@ pub fn loaded_mission_behavior_distributors( .map(|state| state.behavior_distributors.as_slice()) } +/// Returns native ore properties attached to full Unit DAT mission objects. +#[must_use] +pub fn loaded_mission_behavior_ore_states(engine: &Engine) -> Option<&[BehaviorOreState]> { + engine + .loaded + .as_ref() + .map(|state| state.behavior_ore_states.as_slice()) +} + +/// Returns the base Control device table projections for loaded mission objects. +#[must_use] +pub fn loaded_mission_control_device_tables( + engine: &Engine, +) -> Option<&[MissionControlDeviceTableState]> { + engine + .loaded + .as_ref() + .map(|state| state.control_device_tables.as_slice()) +} + +/// Queries native Control global-table selector 1 (weighted ratio) or 2 (sum). +/// `Ok(None)` preserves the original false/no-result behavior for an empty or +/// zero-denominator table. Other unsupported native paths are reported as errors. +/// Inputs and intermediates must be finite and normal, or exact zero. +/// +/// # Errors +/// Returns an error for an invalid object handle, unavailable mission/table, +/// unsupported selector or factory, missing state, or an unsupported float range. +pub fn query_loaded_mission_control_resource( + engine: &Engine, + handle: ObjectHandle, + selector: u32, +) -> Result<Option<f32>, ControlResourceAccessError> { + transform_state(&engine.world, handle).map_err(ControlResourceAccessError::World)?; + let loaded = engine + .loaded + .as_ref() + .ok_or(ControlResourceAccessError::MissionUnavailable)?; + let table = loaded + .control_device_tables + .iter() + .find(|table| table.handle == handle) + .ok_or(ControlResourceAccessError::ObjectUnavailable { handle })?; + query_control_device_table_resource(table, selector) +} + +/// Queries one loaded Control device through its original factory getter. +/// +/// Selector `0xe00` is currently modeled for current descriptor tag 26 with +/// factory tag 26. The loaded NDP provider value is its initial native state; +/// later Control updates are not synchronized into this snapshot. +/// +/// # Errors +/// Returns an error for an invalid handle, unavailable mission/table/provider, +/// an out-of-range device/provider key, or a factory/tag/float path that is not +/// supported by the current reconstruction. +pub fn query_loaded_mission_control_device_selector( + engine: &Engine, + handle: ObjectHandle, + device_index: usize, + selector: u32, +) -> Result<Option<f32>, ControlResourceAccessError> { + transform_state(&engine.world, handle).map_err(ControlResourceAccessError::World)?; + let loaded = engine + .loaded + .as_ref() + .ok_or(ControlResourceAccessError::MissionUnavailable)?; + let table = loaded + .control_device_tables + .iter() + .find(|table| table.handle == handle) + .ok_or(ControlResourceAccessError::ObjectUnavailable { handle })?; + query_control_device_table_selector(table, device_index, selector) +} + +/// Sets native Control global-table selector 1 on rows whose selector-0 value +/// is positive. Validation is completed before any row is changed. +/// +/// # Errors +/// Returns an error for an invalid object handle, unavailable mission/table, +/// missing state, a non-finite or subnormal value, or an unsupported float range. +pub fn set_loaded_mission_control_multiplier( + engine: &mut Engine, + handle: ObjectHandle, + value: f32, +) -> Result<(), ControlResourceAccessError> { + transform_state(&engine.world, handle).map_err(ControlResourceAccessError::World)?; + let loaded = engine + .loaded + .as_mut() + .ok_or(ControlResourceAccessError::MissionUnavailable)?; + let table = loaded + .control_device_tables + .iter_mut() + .find(|table| table.handle == handle) + .ok_or(ControlResourceAccessError::ObjectUnavailable { handle })?; + set_control_device_table_multiplier(table, value) +} + +fn query_control_device_table_resource( + table: &MissionControlDeviceTableState, + selector: u32, +) -> Result<Option<f32>, ControlResourceAccessError> { + if !matches!(selector, 1 | 2) { + return Err(ControlResourceAccessError::UnsupportedSelector(selector)); + } + let entries = match &table.status { + MissionControlDeviceTableStatus::Available(entries) => entries, + MissionControlDeviceTableStatus::Unavailable(reason) => { + return Err(ControlResourceAccessError::TableUnavailable(reason.clone())); + } + }; + + let mut numerator = 0.0_f32; + let mut denominator = 0.0_f32; + for entry in entries.iter().filter(|entry| entry.descriptor.tag == 19) { + let base = control_device_selector_zero(entry)?; + if base < 0.0 { + return Ok(Some(if selector == 1 { 1.0 } else { base })); + } + if selector == 2 { + denominator = checked_control_sum(entry.factory_tag, "sum", denominator, base)?; + } else { + let multiplier = control_device_float(entry, entry.multiplier_bits, "multiplier")?; + let weighted = checked_control_product( + entry.factory_tag, + "weighted value", + control_device_coefficient(entry)?, + multiplier, + )?; + numerator = checked_control_sum(entry.factory_tag, "numerator", numerator, weighted)?; + denominator = checked_control_sum(entry.factory_tag, "denominator", denominator, base)?; + } + } + + if selector == 2 { + return Ok((denominator > 0.0).then_some(denominator)); + } + if denominator <= 0.0 { + return Ok(None); + } + checked_control_ratio("ratio", numerator, denominator).map(Some) +} + +fn query_control_device_table_selector( + table: &MissionControlDeviceTableState, + device_index: usize, + selector: u32, +) -> Result<Option<f32>, ControlResourceAccessError> { + if selector != 0xe00 { + return Err(ControlResourceAccessError::UnsupportedSelector(selector)); + } + let devices = match &table.status { + MissionControlDeviceTableStatus::Available(devices) => devices, + MissionControlDeviceTableStatus::Unavailable(reason) => { + return Err(ControlResourceAccessError::TableUnavailable(reason.clone())); + } + }; + let device = + devices + .get(device_index) + .ok_or(ControlResourceAccessError::DeviceIndexOutOfRange { + device_index, + device_count: devices.len(), + })?; + match device.descriptor.tag { + 26 => {} + 5 | 10 | 21 => { + return Err(ControlResourceAccessError::UnsupportedCurrentTag { + tag: device.descriptor.tag, + }); + } + _ => return Ok(None), + } + if device.factory_tag != 26 { + return Err(ControlResourceAccessError::UnsupportedFactoryTag { + factory_tag: device.factory_tag, + }); + } + + let providers = match &table.node_provider_status { + MissionControlNodeProviderTableStatus::Available(providers) => providers, + MissionControlNodeProviderTableStatus::Unavailable(reason) => { + return Err(ControlResourceAccessError::NodeProviderTableUnavailable( + reason.clone(), + )); + } + }; + let key = usize::try_from(device.key).map_err(|_| { + ControlResourceAccessError::NodeProviderKeyOutOfRange { + key: device.key, + row_count: providers.len(), + } + })?; + let provider = + providers + .get(key) + .ok_or(ControlResourceAccessError::NodeProviderKeyOutOfRange { + key: device.key, + row_count: providers.len(), + })?; + let provider_value = checked_control_float( + device.factory_tag, + "node provider value", + f32::from_bits(provider.initial_type1_value_bits), + )?; + let coefficient = control_device_coefficient(device)?; + let multiplier = control_device_float(device, device.multiplier_bits, "multiplier")?; + let provider_weighted = checked_control_product( + device.factory_tag, + "provider times coefficient", + provider_value, + coefficient, + )?; + checked_control_product( + device.factory_tag, + "then multiplier", + provider_weighted, + multiplier, + ) + .map(Some) +} + +fn set_control_device_table_multiplier( + table: &mut MissionControlDeviceTableState, + value: f32, +) -> Result<(), ControlResourceAccessError> { + let entries = match &mut table.status { + MissionControlDeviceTableStatus::Available(entries) => entries, + MissionControlDeviceTableStatus::Unavailable(reason) => { + return Err(ControlResourceAccessError::TableUnavailable(reason.clone())); + } + }; + + let mut has_target = false; + let mut target_factory_tag = 0; + for entry in entries.iter() { + if entry.descriptor.tag != 19 { + continue; + } + let base = control_device_selector_zero(entry)?; + if base > 0.0 { + has_target = true; + target_factory_tag = entry.factory_tag; + } + } + if !has_target { + return Ok(()); + } + checked_control_float(target_factory_tag, "multiplier", value)?; + for entry in entries + .iter_mut() + .filter(|entry| entry.descriptor.tag == 19) + { + if control_device_selector_zero(entry)? > 0.0 { + entry.multiplier_bits = Some(value.to_bits()); + } + } + Ok(()) +} + +fn control_device_selector_zero( + entry: &EffectiveControlDevice, +) -> Result<f32, ControlResourceAccessError> { + let value = match entry.factory_tag { + 9 => { + let coefficient = control_device_coefficient(entry)?; + let scale = control_device_float( + entry, + entry.class9_selector0_scale_bits, + "class-9 selector-0 scale", + )?; + checked_control_product(entry.factory_tag, "selector-0 value", coefficient, scale)? + } + 15 | 19 | 25 => control_device_coefficient(entry)?, + factory_tag => { + return Err(ControlResourceAccessError::UnsupportedFactoryTag { factory_tag }); + } + }; + checked_control_float(entry.factory_tag, "selector-0 value", value) +} + +fn control_device_coefficient( + entry: &EffectiveControlDevice, +) -> Result<f32, ControlResourceAccessError> { + let words = entry + .coefficient_bits + .ok_or(ControlResourceAccessError::UnsupportedField { + factory_tag: entry.factory_tag, + field: "coefficient", + })?; + control_device_float(entry, Some(words[0]), "coefficient") +} + +fn control_device_float( + entry: &EffectiveControlDevice, + bits: Option<u32>, + field: &'static str, +) -> Result<f32, ControlResourceAccessError> { + let bits = bits.ok_or(ControlResourceAccessError::UnsupportedField { + factory_tag: entry.factory_tag, + field, + })?; + checked_control_float(entry.factory_tag, field, f32::from_bits(bits)) +} + +fn checked_control_float( + factory_tag: u32, + field: &'static str, + value: f32, +) -> Result<f32, ControlResourceAccessError> { + if !value.is_finite() { + return Err(ControlResourceAccessError::NonFiniteValue { factory_tag, field }); + } + if value.is_subnormal() { + return Err(ControlResourceAccessError::SubnormalValue { factory_tag, field }); + } + Ok(value) +} + +fn checked_control_product( + factory_tag: u32, + field: &'static str, + lhs: f32, + rhs: f32, +) -> Result<f32, ControlResourceAccessError> { + let range_probe = f64::from(lhs) * f64::from(rhs); + check_control_range_probe(Some(factory_tag), field, range_probe)?; + checked_control_float(factory_tag, field, lhs * rhs) +} + +fn checked_control_ratio( + field: &'static str, + numerator: f32, + denominator: f32, +) -> Result<f32, ControlResourceAccessError> { + let range_probe = f64::from(numerator) / f64::from(denominator); + check_control_range_probe(None, field, range_probe)?; + checked_control_float(0, field, numerator / denominator) +} + +fn checked_control_sum( + factory_tag: u32, + field: &'static str, + lhs: f32, + rhs: f32, +) -> Result<f32, ControlResourceAccessError> { + let range_probe = f64::from(lhs) + f64::from(rhs); + check_control_range_probe(Some(factory_tag), field, range_probe)?; + checked_control_float(factory_tag, field, lhs + rhs) +} + +fn check_control_range_probe( + factory_tag: Option<u32>, + field: &'static str, + range_probe: f64, +) -> Result<(), ControlResourceAccessError> { + let absolute = range_probe.abs(); + let minimum_normal = f64::from(f32::MIN_POSITIVE); + let maximum = f64::from(f32::MAX); + if range_probe != 0.0 && (absolute < minimum_normal || absolute > maximum) { + return Err(ControlResourceAccessError::UnsupportedFloatRange { factory_tag, field }); + } + Ok(()) +} + fn behavior_clan_for_selector( selector: u32, clan_count: usize, @@ -1418,6 +2069,612 @@ fn has_behavior_registration_key(class_flags: u32) -> bool { class_flags & BEHAVIOR_REGISTRATION_KEY_FLAG != 0 } +fn native_behavior_ore_defaults(class_flags: u32) -> (u32, u32) { + match class_flags { + 0x8000_0004 => (0, 0x43fa_0000), + 0x8000_0008 => (0, 0x457a_0000), + 0x0100_2000 => (0, 0x44fa_0000), + 0x0100_4000 => (0x44fa_0000, 0x44fa_0000), + _ => (0, 0), + } +} + +fn initialize_behavior_ore_state( + original_id: OriginalObjectId, + handle: ObjectHandle, + class_flags: u32, + properties: &[MissionObjectProperty], +) -> BehaviorOreState { + let (mut current_ore_bits, maximum_ore_bits) = native_behavior_ore_defaults(class_flags); + if let Some(property) = properties + .iter() + .find(|property| property.name_raw.as_slice() == b"CurrentOre") + { + current_ore_bits = property.raw_value[1]; + } + BehaviorOreState { + original_id, + handle, + class_flags, + current_ore_bits, + maximum_ore_bits, + } +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +enum ControlTableTarget { + Append, + Override(u32), +} + +fn native_control_target_action(target: u32) -> ControlTableTarget { + if target == u32::MAX { + ControlTableTarget::Append + } else { + ControlTableTarget::Override(target) + } +} + +fn native_component_target_index( + source_type: Option<u32>, + devices: &[EffectiveControlDevice], + parent_component_id: u32, + raw_local_index: i32, +) -> u32 { + if source_type == Some(PROTOTYPE_TYPE_EXTO) { + // AniMesh writes EXTO's mount node to descriptor C4; C8 remains -1, + // the Control append sentinel. + u32::MAX + } else { + native_into_table_target_index(devices, parent_component_id, raw_local_index) + } +} + +fn native_component_mount_node( + tree: &[UnitComponentTreeNode], + component_ids: &[Option<u32>], + first_global_nodes: &[Option<u32>], + component_index: usize, + raw_local_index: i32, +) -> Option<u32> { + tree.get(component_index) + .and_then(|node| node.parent_index) + .and_then(|parent_index| { + let parent_id = component_ids.get(parent_index).copied().flatten()?; + let parent_first = first_global_nodes + .get(parent_index) + .copied() + .flatten() + .unwrap_or(u32::MAX); + Some( + parent_first + .wrapping_add(raw_local_index as u32) + .wrapping_sub(u32::from(parent_id != 0)), + ) + }) +} + +fn native_into_table_target_index( + devices: &[EffectiveControlDevice], + parent_component_id: u32, + raw_local_index: i32, +) -> u32 { + let first_parent_device = devices + .iter() + .position(|device| device.component_id == parent_component_id) + .and_then(|index| u32::try_from(index).ok()) + .unwrap_or(u32::MAX); + first_parent_device.wrapping_add(raw_local_index as u32) +} + +fn native_into_append_key(raw_key: u32) -> u32 { + if raw_key == 0 { + u32::MAX + } else { + raw_key + } +} + +fn native_ex_to_append_key( + raw_key: u32, + component_id: u32, + mount_node: Option<u32>, + first_global_node: Option<u32>, +) -> Option<u32> { + if raw_key == 0 { + return mount_node; + } + if component_id == 0 { + return Some(raw_key); + } + let mount_node = mount_node?; + if mount_node == u32::MAX { + return Some(raw_key); + } + let first_global_node = first_global_node.unwrap_or(u32::MAX); + Some(raw_key.wrapping_add(first_global_node).wrapping_sub(1)) +} + +fn active_unit_component_order( + records: &[UnitComponentRecord], + tree: &[UnitComponentTreeNode], +) -> Vec<usize> { + if records.is_empty() || tree.is_empty() { + return Vec::new(); + } + let mut order = vec![0]; + let mut pending = tree[0].children.iter().rev().copied().collect::<Vec<_>>(); + while let Some(node_index) = pending.pop() { + let Some(node) = tree.get(node_index) else { + continue; + }; + let component_index = node.record_index; + let Some(component) = records.get(component_index) else { + continue; + }; + if component.kind == 0 { + // The native raw-kind guard returns before visiting this subtree. + continue; + } + order.push(component_index); + pending.extend(node.children.iter().rev().copied()); + } + order +} + +fn control_device_record_provenance( + component_index: usize, + record_index: usize, + control: &PreparedComponentControl, +) -> ControlDeviceRecordProvenance { + ControlDeviceRecordProvenance { + unit_component_index: component_index, + typed_record_index: record_index, + source: control.source.clone(), + } +} + +fn append_effective_control_device( + devices: &mut Vec<EffectiveControlDevice>, + component_id: u32, + key: u32, + component_index: usize, + record_index: usize, + control: &PreparedComponentControl, + descriptor: &PreparedControlTypedRecord, +) { + let provenance = control_device_record_provenance(component_index, record_index, control); + let mut coefficient_words = [0; 16]; + coefficient_words.copy_from_slice(&descriptor.fixed_words[11..27]); + let coefficient_bits = + control_factory_uses_common_setter(descriptor.tag).then_some(coefficient_words); + let (multiplier_bits, default_word_50) = native_control_factory_defaults(descriptor.tag); + let native_word_50_bits = if descriptor.fixed_words[6] == u32::MAX { + default_word_50 + } else { + Some(descriptor.fixed_words[6]) + }; + devices.push(EffectiveControlDevice { + factory_tag: descriptor.tag, + component_id, + key, + coefficient_bits, + multiplier_bits, + class9_selector0_scale_bits: (descriptor.tag == 9).then_some(0x3f80_0000), + native_word_50_bits, + descriptor: descriptor.clone(), + factory_provenance: provenance.clone(), + descriptor_provenance: provenance, + }); +} + +fn apply_effective_control_override( + device: &mut EffectiveControlDevice, + descriptor: &PreparedControlTypedRecord, + component_index: usize, + record_index: usize, + control: &PreparedComponentControl, +) { + let mut coefficient_words = [0; 16]; + coefficient_words.copy_from_slice(&descriptor.fixed_words[11..27]); + device.coefficient_bits = Some(coefficient_words); + if descriptor.fixed_words[6] != u32::MAX { + device.native_word_50_bits = Some(descriptor.fixed_words[6]); + } + device.descriptor = descriptor.clone(); + device.descriptor_provenance = + control_device_record_provenance(component_index, record_index, control); +} + +fn control_factory_uses_common_setter(factory_tag: u32) -> bool { + matches!( + factory_tag, + 1 | 2 | 4 | 5 | 8 | 9 | 10 | 15 | 17 | 19 | 25 | 26 | 30 + ) +} + +fn native_control_factory_defaults(factory_tag: u32) -> (Option<u32>, Option<u32>) { + match factory_tag { + 1 | 4 => (Some(0x3f80_0000), Some(0x200)), + 5 | 8 | 26 => (Some(0x3f80_0000), Some(0x5)), + 10 => (Some(0x3f80_0000), Some(0x2000)), + 17 | 19 => (Some(0x3f80_0000), Some(0x20)), + 9 | 15 | 25 => (Some(0x3f80_0000), None), + _ => (None, None), + } +} + +#[cfg(test)] +fn build_control_device_table( + object_index: usize, + draft: &MissionObjectDraft, + assets: &MissionAssets, + prototype_span: Option<&std::ops::Range<usize>>, + prototypes: &[fparkan_prototype::EffectivePrototype], +) -> Result<Vec<EffectiveControlDevice>, MissionControlDeviceTableUnavailableReason> { + build_control_device_projection(object_index, draft, assets, prototype_span, prototypes) + .map(|projection| projection.devices) +} + +fn build_control_device_projection( + object_index: usize, + draft: &MissionObjectDraft, + assets: &MissionAssets, + prototype_span: Option<&std::ops::Range<usize>>, + prototypes: &[fparkan_prototype::EffectivePrototype], +) -> Result<ControlDeviceProjection, MissionControlDeviceTableUnavailableReason> { + use MissionControlDeviceTableUnavailableReason as Unavailable; + + draft + .unit_dat_header_flags + .ok_or(Unavailable::NoUnitDatTree)?; + if draft.unit_components.is_empty() { + return Err(Unavailable::InvalidUnitComponentTree); + } + let tree = match unit_component_tree(&draft.unit_components) { + Ok(tree) if !tree.is_empty() => tree, + _ => return Err(Unavailable::InvalidUnitComponentTree), + }; + let span = prototype_span.ok_or(Unavailable::ComponentAlignmentMismatch)?; + let component_controls = assets + .object_component_controls + .get(object_index) + .ok_or(Unavailable::ComponentAlignmentMismatch)?; + let object_visuals = assets + .object_visuals + .get(object_index) + .ok_or(Unavailable::ComponentAlignmentMismatch)?; + if span.start > span.end + || span.end > prototypes.len() + || span.end - span.start != draft.unit_components.len() + || component_controls.len() != draft.unit_components.len() + || object_visuals.len() != draft.unit_components.len() + { + return Err(Unavailable::ComponentAlignmentMismatch); + } + + let prototype_for = |component_index: usize| { + span.start + .checked_add(component_index) + .and_then(|index| prototypes.get(index)) + }; + let active_components = active_unit_component_order(&draft.unit_components, &tree); + if active_components.first() != Some(&0) { + return Err(Unavailable::InvalidUnitComponentTree); + } + + let has_ex_to = active_components.iter().any(|component_index| { + prototype_for(*component_index) + .is_some_and(|prototype| prototype.source_type == Some(PROTOTYPE_TYPE_EXTO)) + }); + if has_ex_to { + for component_index in active_components + .iter() + .copied() + .filter(|index| *index != 0) + { + let prototype = + prototype_for(component_index).ok_or(Unavailable::ComponentAlignmentMismatch)?; + if prototype.source_type.is_none() { + return Err(Unavailable::UnknownComponentKindForExTo { + unit_component_index: component_index, + source_type: None, + }); + } + } + } + + let mut component_ids = vec![None; draft.unit_components.len()]; + component_ids[0] = Some(0_u32); + let mut next_component_id = 1_u32; + for component_index in active_components.iter().copied().skip(1) { + component_ids[component_index] = Some(next_component_id); + let next = next_component_id + .checked_add(1) + .ok_or(Unavailable::ComponentAlignmentMismatch)?; + next_component_id = next; + } + + let mut first_global_nodes = vec![None; draft.unit_components.len()]; + if has_ex_to { + let root_prototype = prototype_for(0).ok_or(Unavailable::ComponentAlignmentMismatch)?; + let root_is_mesh = matches!( + root_prototype.geometry, + fparkan_prototype::PrototypeGeometry::Mesh(_) + ); + let root_node_count = object_visuals + .first() + .and_then(|visual_id| assets.visual_by_id(*visual_id)) + .map(|visual| visual.model_nodes) + .ok_or(Unavailable::UnsupportedExToNodeMapping { + unit_component_index: 0, + })?; + if !root_is_mesh || root_node_count == 0 { + return Err(Unavailable::UnsupportedExToNodeMapping { + unit_component_index: 0, + }); + } + let mut global_node_cursor = u32::try_from(root_node_count).map_err(|_| { + Unavailable::UnsupportedExToNodeMapping { + unit_component_index: 0, + } + })?; + first_global_nodes[0] = Some(0_u32); + for component_index in active_components.iter().copied().skip(1) { + let prototype = + prototype_for(component_index).ok_or(Unavailable::ComponentAlignmentMismatch)?; + match prototype.source_type { + Some(PROTOTYPE_TYPE_EXTO) => { + if !matches!( + prototype.geometry, + fparkan_prototype::PrototypeGeometry::Mesh(_) + ) { + return Err(Unavailable::UnsupportedExToNodeMapping { + unit_component_index: component_index, + }); + } + let Some(node_count) = object_visuals + .get(component_index) + .and_then(|visual_id| assets.visual_by_id(*visual_id)) + .map(|visual| visual.model_nodes) + else { + return Err(Unavailable::UnsupportedExToNodeMapping { + unit_component_index: component_index, + }); + }; + if node_count == 0 { + return Err(Unavailable::UnsupportedExToNodeMapping { + unit_component_index: component_index, + }); + } + if node_count > 1 { + first_global_nodes[component_index] = Some(global_node_cursor); + } + let contribution = u32::try_from(node_count - 1).map_err(|_| { + Unavailable::UnsupportedExToNodeMapping { + unit_component_index: component_index, + } + })?; + let next_cursor = + global_node_cursor + .checked_add(contribution) + .ok_or_else(|| Unavailable::UnsupportedExToNodeMapping { + unit_component_index: component_index, + })?; + global_node_cursor = next_cursor; + } + Some(_) => {} + None => { + return Err(Unavailable::UnknownComponentKindForExTo { + unit_component_index: component_index, + source_type: None, + }); + } + } + } + } + + let mut devices = Vec::new(); + let mut node_provider_status = MissionControlNodeProviderTableStatus::Available(Vec::new()); + let mut has_control_resource = false; + for component_index in active_components { + let prototype = + prototype_for(component_index).ok_or(Unavailable::ComponentAlignmentMismatch)?; + if prototype.control_resource.is_none() { + continue; + } + has_control_resource = true; + if matches!( + prototype.geometry, + fparkan_prototype::PrototypeGeometry::NonGeometric + ) { + return Err(Unavailable::NonGeometricControlResource { + unit_component_index: component_index, + }); + } + let control = component_controls[component_index].as_ref().ok_or( + Unavailable::ControlResourceUnavailable { + unit_component_index: component_index, + }, + )?; + if let PreparedControlEffectSection::Unsupported { + typed_record_index: Some(first_unparsed_record), + .. + } = &control.effect_section + { + return Err(Unavailable::IncompleteTypedRecordList { + unit_component_index: component_index, + first_unparsed_record: *first_unparsed_record, + }); + } + + let component_id = + component_ids[component_index].ok_or(Unavailable::ComponentAlignmentMismatch)?; + let is_root = component_index == 0; + let is_ex_to = prototype.source_type == Some(PROTOTYPE_TYPE_EXTO); + let raw_local_index = draft.unit_components[component_index].parent_or_link; + let parent_component_id = tree + .get(component_index) + .and_then(|node| node.parent_index) + .and_then(|parent_index| component_ids.get(parent_index).copied().flatten()) + .unwrap_or(u32::MAX); + let mount_node = if is_ex_to { + native_component_mount_node( + &tree, + &component_ids, + &first_global_nodes, + component_index, + raw_local_index, + ) + } else { + None + }; + if is_root { + append_control_node_provider_rows( + &mut node_provider_status, + component_index, + prototype.node_data_resource.as_ref(), + control.node_data.as_ref(), + false, + ); + } else if is_ex_to && mount_node.is_some_and(|node| node != u32::MAX) { + append_control_node_provider_rows( + &mut node_provider_status, + component_index, + prototype.node_data_resource.as_ref(), + control.node_data.as_ref(), + true, + ); + } + if is_root { + for (record_index, descriptor) in control.typed_records.iter().enumerate() { + append_effective_control_device( + &mut devices, + component_id, + descriptor.fixed_words[1], + component_index, + record_index, + control, + descriptor, + ); + } + continue; + } + + let native_target = native_component_target_index( + prototype.source_type, + &devices, + parent_component_id, + raw_local_index, + ); + match native_control_target_action(native_target) { + ControlTableTarget::Append => { + let first_global_node = first_global_nodes.get(component_index).copied().flatten(); + for (record_index, descriptor) in control.typed_records.iter().enumerate() { + let raw_key = descriptor.fixed_words[1]; + let key = if is_ex_to { + native_ex_to_append_key( + raw_key, + component_id, + mount_node, + first_global_node, + ) + .ok_or( + Unavailable::UnsupportedExToNodeMapping { + unit_component_index: component_index, + }, + )? + } else { + native_into_append_key(raw_key) + }; + append_effective_control_device( + &mut devices, + component_id, + key, + component_index, + record_index, + control, + descriptor, + ); + } + } + ControlTableTarget::Override(target_index) => { + let descriptor = + control + .typed_records + .first() + .ok_or(Unavailable::MissingOverrideRecord { + unit_component_index: component_index, + })?; + let target_index_usize = usize::try_from(target_index).map_err(|_| { + Unavailable::OverrideIndexOutOfRange { + unit_component_index: component_index, + target_index, + } + })?; + let device = devices.get_mut(target_index_usize).ok_or( + Unavailable::OverrideIndexOutOfRange { + unit_component_index: component_index, + target_index, + }, + )?; + if !matches!(device.factory_tag, 9 | 15 | 19 | 25) { + return Err(Unavailable::UnsupportedOverrideReceiver { + factory_tag: device.factory_tag, + }); + } + apply_effective_control_override(device, descriptor, component_index, 0, control); + } + } + } + if !has_control_resource { + return Err(Unavailable::NoControlResource); + } + Ok(ControlDeviceProjection { + devices, + node_provider_status, + }) +} + +fn append_control_node_provider_rows( + status: &mut MissionControlNodeProviderTableStatus, + unit_component_index: usize, + requested_source: Option<&ResourceKey>, + node_data: Option<&PreparedControlNodeDataTable>, + skip_first_row: bool, +) { + let MissionControlNodeProviderTableStatus::Available(rows) = status else { + return; + }; + let Some(node_data) = node_data else { + *status = MissionControlNodeProviderTableStatus::Unavailable( + MissionControlNodeProviderTableUnavailableReason::MissingNodeData { + unit_component_index, + source: requested_source.cloned(), + }, + ); + return; + }; + if skip_first_row && node_data.rows.is_empty() { + *status = MissionControlNodeProviderTableStatus::Unavailable( + MissionControlNodeProviderTableUnavailableReason::MissingExToRootRow { + unit_component_index, + }, + ); + return; + } + let first_row = usize::from(skip_first_row); + for (source_row_index, source_row) in node_data.rows.iter().enumerate().skip(first_row) { + rows.push(MissionControlNodeProviderRow { + source: node_data.source.clone(), + unit_component_index, + source_row_index, + source_row: source_row.clone(), + initial_type1_value_bits: 0x3f80_0000, + }); + } +} + fn add_behavior_registered_object( distributor: &mut BehaviorDistributorState, mut object: BehaviorRegisteredObject, @@ -1791,7 +3048,7 @@ fn read_vfs(vfs: &Arc<dyn Vfs>, path: &NormalizedPath) -> Result<Arc<[u8]>, Engi mod tests { use super::*; use fparkan_script::ScriptDispatchSelector; - use fparkan_vfs::{DirectoryVfs, MemoryVfs, VfsEntry, VfsMetadata}; + use fparkan_vfs::{DirectoryVfs, MemoryVfs, OverlayVfs, VfsEntry, VfsMetadata}; use std::path::{Path, PathBuf}; fn basement_draft(header_flags: Option<u32>, raw_after_name: u32) -> MissionObjectDraft { @@ -1811,6 +3068,764 @@ mod tests { } } + fn synthetic_resource_key(index: usize) -> ResourceKey { + ResourceKey { + archive: normalize_engine_path("test", &format!("synthetic/{index}.rlb")) + .expect("synthetic archive path"), + name: fparkan_path::ResourceName(format!("entry{index}").into_bytes()), + type_id: None, + } + } + + fn synthetic_control_record( + tag: u32, + key: u32, + first_coefficient: u32, + native_word_50: Option<u32>, + ) -> PreparedControlTypedRecord { + let mut fixed_words = [0; 44]; + fixed_words[1] = key; + fixed_words[6] = native_word_50.unwrap_or(u32::MAX); + fixed_words[11] = first_coefficient; + PreparedControlTypedRecord { + tag, + fixed_words, + values: Vec::new(), + string_bytes: Vec::new(), + gate_provider: fparkan_assets::PreparedControlGateProvider::NotApplicable, + } + } + + fn synthetic_component_control( + index: usize, + typed_records: Vec<PreparedControlTypedRecord>, + effect_section: PreparedControlEffectSection, + ) -> PreparedComponentControl { + PreparedComponentControl { + source: synthetic_resource_key(100 + index), + model_node_count: 0, + bindings: Vec::new(), + timeline_rows: Vec::new(), + typed_records, + node_data: None, + effect_section, + initial_effect_group: None, + point_list: None, + } + } + + fn synthetic_control_node_data_table( + index: usize, + row_count: usize, + ) -> PreparedControlNodeDataTable { + PreparedControlNodeDataTable { + source: synthetic_resource_key(300 + index), + rows: (0..row_count) + .map(|row_index| PreparedControlNodeDataRow { + raw_flags: u32::try_from(row_index).expect("row index fits u32"), + max_volume: (100 + row_index) as f32, + mobility_per_volume: (200 + row_index) as f32, + effect: PreparedControlResourcePair { + archive: [0; 32], + name: [0; 32], + }, + }) + .collect(), + } + } + + fn control_with_synthetic_node_data( + index: usize, + typed_records: Vec<PreparedControlTypedRecord>, + row_count: usize, + ) -> PreparedComponentControl { + let mut control = synthetic_component_control( + index, + typed_records, + PreparedControlEffectSection::Parsed(Vec::new()), + ); + control.node_data = Some(synthetic_control_node_data_table(index, row_count)); + control + } + + fn synthetic_node_provider_row( + component_index: usize, + source_row_index: usize, + initial_type1_value_bits: u32, + ) -> MissionControlNodeProviderRow { + MissionControlNodeProviderRow { + source: synthetic_resource_key(300 + component_index), + unit_component_index: component_index, + source_row_index, + source_row: PreparedControlNodeDataRow { + raw_flags: u32::try_from(source_row_index).expect("row index fits u32"), + max_volume: 100.0, + mobility_per_volume: 200.0, + effect: PreparedControlResourcePair { + archive: [0; 32], + name: [0; 32], + }, + }, + initial_type1_value_bits, + } + } + + fn synthetic_control_fixture( + source_types: &[Option<u32>], + kinds: &[u32], + child_counts: &[u32], + parent_or_links: &[i32], + model_nodes: &[usize], + controls: Vec<Option<PreparedComponentControl>>, + ) -> ( + MissionObjectDraft, + MissionAssets, + Vec<fparkan_prototype::EffectivePrototype>, + ) { + let component_count = source_types.len(); + assert_eq!(kinds.len(), component_count); + assert_eq!(child_counts.len(), component_count); + assert_eq!(parent_or_links.len(), component_count); + assert_eq!(model_nodes.len(), component_count); + assert_eq!(controls.len(), component_count); + + let unit_components = (0..component_count) + .map(|index| UnitComponentRecord { + archive_raw: [0; 32], + resource_raw: [0; 32], + kind: kinds[index], + parent_or_link: parent_or_links[index], + description_raw: [0; 32], + tail0: 0, + immediate_child_count: child_counts[index], + }) + .collect::<Vec<_>>(); + let mut assets = MissionAssets::default(); + let mut prototypes = Vec::with_capacity(component_count); + let mut visuals = Vec::with_capacity(component_count); + let mut visual_ids = Vec::with_capacity(component_count); + for index in 0..component_count { + let mesh = synthetic_resource_key(200 + index); + let visual_id = AssetId::new(index as u64); + visual_ids.push(visual_id); + visuals.push(PreparedVisual { + id: visual_id, + mesh: Some(mesh.clone()), + source_type: source_types[index], + model_id: None, + wear_id: None, + model_nodes: model_nodes[index], + model_slots: 0, + model_batches: 0, + material_count: 0, + material_ids: Vec::new(), + texture_ids: Vec::new(), + lightmap_ids: Vec::new(), + texture_count: 0, + lightmap_count: 0, + }); + prototypes.push(fparkan_prototype::EffectivePrototype { + key: fparkan_prototype::PrototypeKey(fparkan_path::ResourceName( + format!("prototype{index}").into_bytes(), + )), + geometry: fparkan_prototype::PrototypeGeometry::Mesh(mesh), + source: fparkan_prototype::PrototypeSource::ObjectsRegistry, + source_type: source_types[index], + dependencies: Vec::new(), + control_resource: controls[index] + .as_ref() + .map(|control| control.source.clone()), + node_data_resource: controls[index] + .as_ref() + .and_then(|control| control.node_data.as_ref()) + .map(|node_data| node_data.source.clone()), + point_resource: None, + bas_resource: None, + }); + } + assets.visuals = visuals; + assets.object_visuals = vec![visual_ids.clone()]; + assets.object_component_controls = vec![controls]; + let draft = MissionObjectDraft { + original_id: Some(OriginalObjectId(0)), + resource_name_raw: b"TEST/ROOT.DAT".to_vec(), + raw_after_resource: 0, + identity_or_clan_raw: 0, + raw_after_name: 0, + unit_dat_header_flags: Some(0), + position: [0.0; 3], + orientation_raw: [0.0; 3], + scale: [1.0; 3], + visual_ids, + properties: Vec::new(), + unit_components, + }; + (draft, assets, prototypes) + } + + fn synthetic_control_table( + source_types: &[Option<u32>], + kinds: &[u32], + child_counts: &[u32], + parent_or_links: &[i32], + model_nodes: &[usize], + controls: Vec<Option<PreparedComponentControl>>, + ) -> MissionControlDeviceTableStatus { + let (draft, assets, prototypes) = synthetic_control_fixture( + source_types, + kinds, + child_counts, + parent_or_links, + model_nodes, + controls, + ); + build_control_device_table( + 0, + &draft, + &assets, + Some(&(0..prototypes.len())), + &prototypes, + ) + .map_or_else( + MissionControlDeviceTableStatus::Unavailable, + MissionControlDeviceTableStatus::Available, + ) + } + + fn synthetic_control_projection( + source_types: &[Option<u32>], + kinds: &[u32], + child_counts: &[u32], + parent_or_links: &[i32], + model_nodes: &[usize], + controls: Vec<Option<PreparedComponentControl>>, + ) -> ( + MissionControlDeviceTableStatus, + MissionControlNodeProviderTableStatus, + ) { + let (draft, assets, prototypes) = synthetic_control_fixture( + source_types, + kinds, + child_counts, + parent_or_links, + model_nodes, + controls, + ); + let (status, node_provider_status) = match build_control_device_projection( + 0, + &draft, + &assets, + Some(&(0..prototypes.len())), + &prototypes, + ) { + Ok(projection) => ( + MissionControlDeviceTableStatus::Available(projection.devices), + projection.node_provider_status, + ), + Err(reason) => ( + MissionControlDeviceTableStatus::Unavailable(reason.clone()), + MissionControlNodeProviderTableStatus::Unavailable( + MissionControlNodeProviderTableUnavailableReason::DeviceTableUnavailable( + reason, + ), + ), + ), + }; + (status, node_provider_status) + } + + fn synthetic_effective_control_device( + factory_tag: u32, + descriptor_tag: u32, + coefficient_bits: u32, + multiplier_bits: Option<u32>, + class9_scale_bits: Option<u32>, + ) -> EffectiveControlDevice { + let descriptor = synthetic_control_record(descriptor_tag, 2, coefficient_bits, None); + let control = synthetic_component_control( + 0, + vec![descriptor.clone()], + PreparedControlEffectSection::Parsed(Vec::new()), + ); + let provenance = control_device_record_provenance(0, 0, &control); + let mut coefficients = [0; 16]; + coefficients[0] = coefficient_bits; + EffectiveControlDevice { + factory_tag, + component_id: 3, + key: 2, + coefficient_bits: Some(coefficients), + multiplier_bits, + class9_selector0_scale_bits: class9_scale_bits, + native_word_50_bits: None, + descriptor, + factory_provenance: provenance.clone(), + descriptor_provenance: provenance, + } + } + + fn synthetic_control_device_table( + status: MissionControlDeviceTableStatus, + ) -> MissionControlDeviceTableState { + synthetic_control_device_table_with_providers( + status, + MissionControlNodeProviderTableStatus::Available(Vec::new()), + ) + } + + fn synthetic_control_device_table_with_providers( + status: MissionControlDeviceTableStatus, + node_provider_status: MissionControlNodeProviderTableStatus, + ) -> MissionControlDeviceTableState { + MissionControlDeviceTableState { + original_id: Some(OriginalObjectId(7)), + handle: ObjectHandle { + generation: 5, + slot: 7, + }, + status, + node_provider_status, + } + } + + #[test] + fn control_resource_queries_filter_current_tag_and_use_factory_getters() { + let table = + synthetic_control_device_table(MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device( + 9, + 19, + 2.0_f32.to_bits(), + Some(3.0_f32.to_bits()), + Some(0.5_f32.to_bits()), + ), + synthetic_effective_control_device( + 19, + 9, + 100.0_f32.to_bits(), + Some(77.0_f32.to_bits()), + None, + ), + synthetic_effective_control_device( + 15, + 19, + 4.0_f32.to_bits(), + Some(0.5_f32.to_bits()), + None, + ), + synthetic_effective_control_device( + 19, + 19, + 1.0_f32.to_bits(), + Some(4.0_f32.to_bits()), + None, + ), + ])); + + assert_eq!( + query_control_device_table_resource(&table, 1) + .expect("selector 1") + .map(f32::to_bits), + Some(2.0_f32.to_bits()) + ); + assert_eq!( + query_control_device_table_resource(&table, 2) + .expect("selector 2") + .map(f32::to_bits), + Some(6.0_f32.to_bits()) + ); + assert_eq!( + query_control_device_table_resource(&table, 3), + Err(ControlResourceAccessError::UnsupportedSelector(3)) + ); + } + + #[test] + fn control_resource_setter_updates_matching_rows_atomically_and_round_trips() { + let mut table = + synthetic_control_device_table(MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device( + 9, + 19, + 2.0_f32.to_bits(), + Some(3.0_f32.to_bits()), + Some(0.5_f32.to_bits()), + ), + synthetic_effective_control_device( + 19, + 9, + 100.0_f32.to_bits(), + Some(77.0_f32.to_bits()), + None, + ), + synthetic_effective_control_device( + 15, + 19, + 4.0_f32.to_bits(), + Some(0.5_f32.to_bits()), + None, + ), + synthetic_effective_control_device( + 19, + 19, + 1.0_f32.to_bits(), + Some(4.0_f32.to_bits()), + None, + ), + ])); + + set_control_device_table_multiplier(&mut table, 7.5).expect("setter 1"); + let MissionControlDeviceTableStatus::Available(entries) = &table.status else { + panic!("synthetic table is available"); + }; + assert_eq!( + entries + .iter() + .map(|entry| entry.multiplier_bits) + .collect::<Vec<_>>(), + [ + Some(7.5_f32.to_bits()), + Some(77.0_f32.to_bits()), + Some(7.5_f32.to_bits()), + Some(7.5_f32.to_bits()) + ] + ); + assert_eq!( + entries[0].class9_selector0_scale_bits, + Some(0.5_f32.to_bits()) + ); + assert_eq!( + query_control_device_table_resource(&table, 1) + .expect("updated selector 1") + .map(f32::to_bits), + Some(8.75_f32.to_bits()) + ); + + let mut unsupported = + synthetic_control_device_table(MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device( + 19, + 19, + 2.0_f32.to_bits(), + Some(1.0_f32.to_bits()), + None, + ), + synthetic_effective_control_device(12, 19, 1.0_f32.to_bits(), None, None), + ])); + assert_eq!( + set_control_device_table_multiplier(&mut unsupported, 2.0), + Err(ControlResourceAccessError::UnsupportedFactoryTag { factory_tag: 12 }) + ); + let MissionControlDeviceTableStatus::Available(entries) = &unsupported.status else { + panic!("synthetic table is available"); + }; + assert_eq!(entries[0].multiplier_bits, Some(1.0_f32.to_bits())); + } + + #[test] + fn control_resource_queries_preserve_native_no_result_and_negative_rules() { + let empty = + synthetic_control_device_table(MissionControlDeviceTableStatus::Available(Vec::new())); + assert_eq!(query_control_device_table_resource(&empty, 1), Ok(None)); + assert_eq!(query_control_device_table_resource(&empty, 2), Ok(None)); + assert!(set_control_device_table_multiplier(&mut empty.clone(), f32::NAN).is_ok()); + + let zero_denominator = + synthetic_control_device_table(MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device( + 19, + 19, + 0.0_f32.to_bits(), + Some(2.0_f32.to_bits()), + None, + ), + ])); + assert_eq!( + query_control_device_table_resource(&zero_denominator, 1), + Ok(None) + ); + assert_eq!( + query_control_device_table_resource(&zero_denominator, 2), + Ok(None) + ); + + let nonmatching = + synthetic_control_device_table(MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device( + 19, + 9, + 4.0_f32.to_bits(), + Some(2.0_f32.to_bits()), + None, + ), + ])); + assert_eq!( + query_control_device_table_resource(&nonmatching, 1), + Ok(None) + ); + + let no_multiplier = + synthetic_control_device_table(MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device(19, 19, 2.0_f32.to_bits(), None, None), + ])); + assert_eq!( + query_control_device_table_resource(&no_multiplier, 2) + .expect("selector 2 does not read multiplier") + .map(f32::to_bits), + Some(2.0_f32.to_bits()) + ); + + let negative = + synthetic_control_device_table(MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device(19, 19, (-1.0_f32).to_bits(), None, None), + ])); + assert_eq!( + query_control_device_table_resource(&negative, 1) + .expect("negative selector 1") + .map(f32::to_bits), + Some(1.0_f32.to_bits()) + ); + assert_eq!( + query_control_device_table_resource(&negative, 2) + .expect("negative selector 2") + .map(f32::to_bits), + Some((-1.0_f32).to_bits()) + ); + + let rounded = + synthetic_control_device_table(MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device( + 19, + 19, + 1.0_f32.to_bits(), + Some(16_777_216.0_f32.to_bits()), + None, + ), + synthetic_effective_control_device( + 19, + 19, + 1.0_f32.to_bits(), + Some(1.0_f32.to_bits()), + None, + ), + synthetic_effective_control_device( + 19, + 19, + 1.0_f32.to_bits(), + Some((-16_777_216.0_f32).to_bits()), + None, + ), + ])); + assert_eq!( + query_control_device_table_resource(&rounded, 1) + .expect("rounded selector 1") + .map(f32::to_bits), + Some(0.0_f32.to_bits()) + ); + + let mut replaceable = + synthetic_control_device_table(MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device( + 19, + 19, + 1.0_f32.to_bits(), + Some(f32::INFINITY.to_bits()), + None, + ), + ])); + set_control_device_table_multiplier(&mut replaceable, 2.0) + .expect("setter does not read the old multiplier"); + let MissionControlDeviceTableStatus::Available(entries) = &replaceable.status else { + panic!("synthetic table is available"); + }; + assert_eq!(entries[0].multiplier_bits, Some(2.0_f32.to_bits())); + } + + #[test] + fn control_resource_access_reports_unavailable_and_nonfinite_inputs() { + let unavailable = + synthetic_control_device_table(MissionControlDeviceTableStatus::Unavailable( + MissionControlDeviceTableUnavailableReason::NoControlResource, + )); + assert_eq!( + query_control_device_table_resource(&unavailable, 1), + Err(ControlResourceAccessError::TableUnavailable( + MissionControlDeviceTableUnavailableReason::NoControlResource + )) + ); + + let nonfinite = + synthetic_control_device_table(MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device( + 19, + 19, + f32::INFINITY.to_bits(), + Some(1.0_f32.to_bits()), + None, + ), + ])); + assert!(matches!( + query_control_device_table_resource(&nonfinite, 1), + Err(ControlResourceAccessError::NonFiniteValue { + factory_tag: 19, + field: "coefficient" + }) + )); + + let subnormal = + synthetic_control_device_table(MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device(19, 19, 1, Some(1.0_f32.to_bits()), None), + ])); + assert!(matches!( + query_control_device_table_resource(&subnormal, 2), + Err(ControlResourceAccessError::SubnormalValue { + factory_tag: 19, + field: "coefficient" + }) + )); + + let mut finite = + synthetic_control_device_table(MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device( + 19, + 19, + 1.0_f32.to_bits(), + Some(1.0_f32.to_bits()), + None, + ), + ])); + assert!(matches!( + set_control_device_table_multiplier(&mut finite, f32::INFINITY), + Err(ControlResourceAccessError::NonFiniteValue { + factory_tag: 19, + field: "multiplier" + }) + )); + + let underflowing_product = + synthetic_control_device_table(MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device( + 19, + 19, + f32::MIN_POSITIVE.to_bits(), + Some(f32::MIN_POSITIVE.to_bits()), + None, + ), + ])); + assert!(matches!( + query_control_device_table_resource(&underflowing_product, 1), + Err(ControlResourceAccessError::UnsupportedFloatRange { + factory_tag: Some(19), + field: "weighted value" + }) + )); + + let underflowing_ratio = + synthetic_control_device_table(MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device( + 19, + 19, + f32::MIN_POSITIVE.to_bits(), + Some(1.0_f32.to_bits()), + None, + ), + synthetic_effective_control_device( + 19, + 19, + f32::MAX.to_bits(), + Some(0.0_f32.to_bits()), + None, + ), + ])); + assert!(matches!( + query_control_device_table_resource(&underflowing_ratio, 1), + Err(ControlResourceAccessError::UnsupportedFloatRange { + factory_tag: None, + field: "ratio" + }) + )); + + let overflowing_sum = + synthetic_control_device_table(MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device(19, 19, f32::MAX.to_bits(), None, None), + synthetic_effective_control_device(19, 19, f32::MAX.to_bits(), None, None), + ])); + assert!(matches!( + query_control_device_table_resource(&overflowing_sum, 2), + Err(ControlResourceAccessError::UnsupportedFloatRange { + factory_tag: Some(19), + field: "sum" + }) + )); + } + + #[test] + fn control_resource_api_checks_live_world_handle_before_loaded_state() { + let mut engine = create(EngineServices::default()).expect("engine"); + let handle = construct_object( + &mut engine.world, + ObjectDraft { + original_id: Some(OriginalObjectId(4)), + }, + ) + .expect("live world object"); + assert_eq!( + query_loaded_mission_control_resource(&engine, handle, 1), + Err(ControlResourceAccessError::MissionUnavailable) + ); + assert_eq!( + query_loaded_mission_control_device_selector(&engine, handle, 0, 0xe00), + Err(ControlResourceAccessError::MissionUnavailable) + ); + + let stale = ObjectHandle { + generation: handle.generation.wrapping_add(1), + slot: handle.slot, + }; + assert_eq!( + query_loaded_mission_control_resource(&engine, stale, 1), + Err(ControlResourceAccessError::World( + fparkan_world::WorldError::StaleHandle + )) + ); + assert_eq!( + query_loaded_mission_control_device_selector(&engine, stale, 0, 0xe00), + Err(ControlResourceAccessError::World( + fparkan_world::WorldError::StaleHandle + )) + ); + assert_eq!( + set_loaded_mission_control_multiplier(&mut engine, stale, 2.0), + Err(ControlResourceAccessError::World( + fparkan_world::WorldError::StaleHandle + )) + ); + + fparkan_world::request_delete(&mut engine.world, handle).expect("delete object"); + assert_eq!( + query_loaded_mission_control_resource(&engine, handle, 1), + Err(ControlResourceAccessError::World( + fparkan_world::WorldError::StaleHandle + )) + ); + assert_eq!( + query_loaded_mission_control_device_selector(&engine, handle, 0, 0xe00), + Err(ControlResourceAccessError::World( + fparkan_world::WorldError::StaleHandle + )) + ); + } + + #[test] + fn control_factory_multiplier_defaults_preserve_unknown_word_50() { + for factory_tag in [9, 15, 25] { + assert_eq!( + native_control_factory_defaults(factory_tag), + (Some(0x3f80_0000), None) + ); + } + } + #[test] fn native_basement_mode_uses_unit_header_gate_not_builds_path() { assert_eq!( @@ -2014,6 +4029,788 @@ mod tests { } #[test] + fn into_table_target_uses_native_wrapping_and_append_sentinel() { + let no_parent_devices = []; + let local_one = native_into_table_target_index(&no_parent_devices, 9, 1); + assert_eq!(local_one, 0); + assert_eq!( + native_control_target_action(local_one), + ControlTableTarget::Override(0) + ); + + let local_zero = native_into_table_target_index(&no_parent_devices, 9, 0); + assert_eq!(local_zero, u32::MAX); + assert_eq!( + native_control_target_action(local_zero), + ControlTableTarget::Append + ); + } + + #[test] + fn into_missing_parent_append_maps_only_zero_key_to_native_minus_one() { + assert_eq!(native_into_append_key(0), u32::MAX); + assert_eq!(native_into_append_key(0x1234), 0x1234); + } + + #[test] + fn exto_key_mapping_obeys_native_component_and_mount_sentinels() { + assert_eq!(native_ex_to_append_key(2, 0, None, Some(20)), Some(2)); + assert_eq!( + native_ex_to_append_key(2, 1, Some(u32::MAX), Some(20)), + Some(2) + ); + assert_eq!( + native_ex_to_append_key(0, 1, Some(u32::MAX), None), + Some(u32::MAX) + ); + assert_eq!(native_ex_to_append_key(2, 1, Some(4), Some(10)), Some(11)); + assert_eq!(native_ex_to_append_key(2, 1, Some(4), None), Some(0)); + assert_eq!(native_ex_to_append_key(1, 5, Some(9), Some(22)), Some(22)); + } + + #[test] + fn synthetic_ex_to_builder_appends_remapped_rows_and_skips_inactive_subtree() { + let controls = vec![ + Some(synthetic_component_control( + 0, + vec![synthetic_control_record(19, 7, 0x10, None)], + PreparedControlEffectSection::Parsed(Vec::new()), + )), + Some(synthetic_component_control( + 1, + vec![ + synthetic_control_record(19, 0, 0x20, None), + synthetic_control_record(19, 2, 0x21, None), + ], + PreparedControlEffectSection::Parsed(Vec::new()), + )), + Some(synthetic_component_control( + 2, + vec![ + synthetic_control_record(19, 0, 0x30, None), + synthetic_control_record(19, 2, 0x31, None), + ], + PreparedControlEffectSection::Parsed(Vec::new()), + )), + Some(synthetic_component_control( + 3, + vec![synthetic_control_record(19, 9, 0x40, None)], + PreparedControlEffectSection::Parsed(Vec::new()), + )), + Some(synthetic_component_control( + 4, + vec![synthetic_control_record(19, 10, 0x50, None)], + PreparedControlEffectSection::Parsed(Vec::new()), + )), + Some(synthetic_component_control( + 5, + vec![synthetic_control_record(19, 2, 0x60, None)], + PreparedControlEffectSection::Parsed(Vec::new()), + )), + ]; + let status = synthetic_control_table( + &[ + Some(PROTOTYPE_TYPE_EXTO), + Some(PROTOTYPE_TYPE_EXTO), + Some(PROTOTYPE_TYPE_EXTO), + None, + None, + Some(PROTOTYPE_TYPE_EXTO), + ], + &[1, 1, 1, 0, 1, 1], + &[3, 1, 0, 1, 0, 0], + &[0, 3, 2, 0, 0, 4], + &[5, 3, 2, 1, 1, 2], + controls, + ); + let MissionControlDeviceTableStatus::Available(entries) = status else { + panic!("synthetic EXTO table should be available: {status:?}"); + }; + assert_eq!(entries.len(), 6); + // Root EXTO keys remain raw. Child keys map to mount/global nodes. + assert_eq!( + entries.iter().map(|entry| entry.key).collect::<Vec<_>>(), + [7, 3, 6, 6, 8, 9] + ); + assert_eq!( + entries + .iter() + .map(|entry| entry.component_id) + .collect::<Vec<_>>(), + [0, 1, 1, 2, 2, 3] + ); + assert_eq!( + entries + .iter() + .map(|entry| entry.descriptor_provenance.unit_component_index) + .collect::<Vec<_>>(), + [0, 1, 1, 2, 2, 5] + ); + assert_ne!( + entries[5].component_id as usize, + entries[5].descriptor_provenance.unit_component_index + ); + } + + #[test] + fn synthetic_node_provider_projection_keeps_native_rows_separate_from_mesh_keys() { + let controls = vec![ + Some(control_with_synthetic_node_data( + 0, + vec![synthetic_control_record(26, 1, 2.0_f32.to_bits(), None)], + 2, + )), + Some(control_with_synthetic_node_data( + 1, + vec![synthetic_control_record(26, 0, 3.0_f32.to_bits(), None)], + 7, + )), + Some(control_with_synthetic_node_data( + 2, + vec![synthetic_control_record(26, 5, 4.0_f32.to_bits(), None)], + 3, + )), + Some(control_with_synthetic_node_data( + 3, + vec![synthetic_control_record(26, 0, 5.0_f32.to_bits(), None)], + 2, + )), + Some(control_with_synthetic_node_data( + 4, + vec![synthetic_control_record(26, 0, 6.0_f32.to_bits(), None)], + 6, + )), + Some(control_with_synthetic_node_data( + 5, + vec![synthetic_control_record(26, 1, 6.0_f32.to_bits(), None)], + 5, + )), + Some(control_with_synthetic_node_data( + 6, + vec![synthetic_control_record(26, 1, 7.0_f32.to_bits(), None)], + 4, + )), + ]; + let (status, node_provider_status) = synthetic_control_projection( + &[ + None, + Some(PROTOTYPE_TYPE_INTO), + Some(PROTOTYPE_TYPE_EXTO), + Some(PROTOTYPE_TYPE_EXTO), + Some(PROTOTYPE_TYPE_EXTO), + None, + None, + ], + &[1, 1, 1, 1, 1, 0, 1], + &[4, 0, 1, 0, 0, 1, 0], + &[0, -1, 2, 0, -1, 0, 0], + &[1, 1, 4, 2, 1, 1, 1], + controls, + ); + let table = synthetic_control_device_table_with_providers(status, node_provider_status); + let MissionControlNodeProviderTableStatus::Available(rows) = &table.node_provider_status + else { + panic!( + "synthetic provider rows should be available: {:?}", + table.node_provider_status + ); + }; + + // Root contributes all rows, INTO contributes none, and each mounted + // EXTO skips its local row zero. The EXTO with C4=FFFFFFFF contributes + // no provider rows. The kind-zero component and its child are absent + // from the native active-component walk. + 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), (2, 1), (2, 2), (3, 1)] + ); + assert!(rows + .iter() + .all(|row| row.initial_type1_value_bits == 1.0_f32.to_bits())); + + let MissionControlDeviceTableStatus::Available(devices) = &table.status else { + panic!("synthetic devices should be available: {:?}", table.status); + }; + assert_eq!( + devices.iter().map(|device| device.key).collect::<Vec<_>>(), + [1, u32::MAX, 5, 0, u32::MAX] + ); + assert_eq!( + query_control_device_table_selector(&table, 0, 0xe00) + .expect("root tag-26 selector") + .map(f32::to_bits), + Some(2.0_f32.to_bits()) + ); + // Device keys still use the confirmed MSH mapping. The provider list + // is the real concatenated NDP row count, so no model-node padding or + // second key remap hides an out-of-range key. + assert_eq!( + query_control_device_table_selector(&table, 2, 0xe00), + Err(ControlResourceAccessError::NodeProviderKeyOutOfRange { + key: 5, + row_count: 5 + }) + ); + assert_eq!( + query_control_device_table_selector(&table, 3, 0xe00), + Ok(Some(5.0)) + ); + assert_eq!( + query_control_device_table_selector(&table, 4, 0xe00), + Err(ControlResourceAccessError::NodeProviderKeyOutOfRange { + key: u32::MAX, + row_count: 5 + }) + ); + } + + #[test] + fn missing_node_provider_does_not_hide_aggregate_queries() { + let controls = vec![Some(synthetic_component_control( + 0, + vec![ + synthetic_control_record(26, 0, 2.0_f32.to_bits(), None), + synthetic_control_record(19, 1, 4.0_f32.to_bits(), None), + ], + PreparedControlEffectSection::Parsed(Vec::new()), + ))]; + let (status, node_provider_status) = + synthetic_control_projection(&[None], &[1], &[0], &[0], &[1], controls); + let table = synthetic_control_device_table_with_providers(status, node_provider_status); + assert!(matches!( + &table.node_provider_status, + MissionControlNodeProviderTableStatus::Unavailable( + MissionControlNodeProviderTableUnavailableReason::MissingNodeData { + unit_component_index: 0, + .. + } + ) + )); + assert_eq!( + query_control_device_table_resource(&table, 1) + .expect("aggregate selector 1 remains available") + .map(f32::to_bits), + Some(1.0_f32.to_bits()) + ); + assert_eq!( + query_control_device_table_resource(&table, 2) + .expect("aggregate selector 2 remains available") + .map(f32::to_bits), + Some(4.0_f32.to_bits()) + ); + assert!(matches!( + query_control_device_table_selector(&table, 0, 0xe00), + Err(ControlResourceAccessError::NodeProviderTableUnavailable(_)) + )); + } + + #[test] + fn mounted_exto_requires_a_row_before_native_skip_first() { + let controls = vec![ + Some(control_with_synthetic_node_data( + 0, + vec![synthetic_control_record(26, 0, 1.0_f32.to_bits(), None)], + 0, + )), + Some(control_with_synthetic_node_data(1, Vec::new(), 0)), + ]; + let (_, node_provider_status) = synthetic_control_projection( + &[None, Some(PROTOTYPE_TYPE_EXTO)], + &[1, 1], + &[1, 0], + &[0, 0], + &[2, 2], + controls, + ); + assert_eq!( + node_provider_status, + MissionControlNodeProviderTableStatus::Unavailable( + MissionControlNodeProviderTableUnavailableReason::MissingExToRootRow { + unit_component_index: 1, + } + ) + ); + + // An empty root table is legal, and a mounted EXTO with exactly its + // root row skips that row and contributes an empty range. + let controls = vec![ + Some(control_with_synthetic_node_data( + 0, + vec![synthetic_control_record(26, 0, 1.0_f32.to_bits(), None)], + 0, + )), + Some(control_with_synthetic_node_data(1, Vec::new(), 1)), + ]; + let (_, node_provider_status) = synthetic_control_projection( + &[None, Some(PROTOTYPE_TYPE_EXTO)], + &[1, 1], + &[1, 0], + &[0, 0], + &[2, 2], + controls, + ); + assert_eq!( + node_provider_status, + MissionControlNodeProviderTableStatus::Available(Vec::new()) + ); + } + + #[test] + fn indexed_node_provider_query_handles_current_tags_and_factory_scope() { + let available = MissionControlNodeProviderTableStatus::Available(vec![ + synthetic_node_provider_row(0, 0, 1.0_f32.to_bits()), + synthetic_node_provider_row(0, 1, 1.0_f32.to_bits()), + synthetic_node_provider_row(0, 2, 1.0_f32.to_bits()), + ]); + let table = synthetic_control_device_table_with_providers( + MissionControlDeviceTableStatus::Available(vec![ + synthetic_effective_control_device( + 26, + 26, + 2.0_f32.to_bits(), + Some(3.0_f32.to_bits()), + None, + ), + synthetic_effective_control_device( + 26, + 19, + 4.0_f32.to_bits(), + Some(5.0_f32.to_bits()), + None, + ), + synthetic_effective_control_device( + 26, + 5, + 1.0_f32.to_bits(), + Some(1.0_f32.to_bits()), + None, + ), + synthetic_effective_control_device( + 9, + 26, + 1.0_f32.to_bits(), + Some(1.0_f32.to_bits()), + Some(0.5_f32.to_bits()), + ), + ]), + available, + ); + assert_eq!( + query_control_device_table_selector(&table, 0, 0xe00) + .expect("tag-26 query") + .map(f32::to_bits), + Some(6.0_f32.to_bits()) + ); + assert_eq!( + query_control_device_table_selector(&table, 1, 0xe00), + Ok(None) + ); + for tag in [5, 10, 21] { + let mut unsupported = table.clone(); + let MissionControlDeviceTableStatus::Available(entries) = &mut unsupported.status + else { + unreachable!(); + }; + entries[1].descriptor.tag = tag; + assert_eq!( + query_control_device_table_selector(&unsupported, 1, 0xe00), + Err(ControlResourceAccessError::UnsupportedCurrentTag { tag }) + ); + } + assert_eq!( + query_control_device_table_selector(&table, 3, 0xe00), + Err(ControlResourceAccessError::UnsupportedFactoryTag { factory_tag: 9 }) + ); + assert_eq!( + query_control_device_table_selector(&table, 0, 1), + Err(ControlResourceAccessError::UnsupportedSelector(1)) + ); + assert_eq!( + query_control_device_table_selector(&table, 8, 0xe00), + Err(ControlResourceAccessError::DeviceIndexOutOfRange { + device_index: 8, + device_count: 4 + }) + ); + } + + #[test] + fn synthetic_into_builder_appends_all_rows_and_overrides_only_first_record() { + let append = synthetic_control_table( + &[None, Some(PROTOTYPE_TYPE_INTO)], + &[1, 1], + &[1, 0], + &[0, 0], + &[1, 0], + vec![ + None, + Some(synthetic_component_control( + 1, + vec![ + synthetic_control_record(19, 0, 0x10, None), + synthetic_control_record(19, 2, 0x20, None), + ], + PreparedControlEffectSection::Parsed(Vec::new()), + )), + ], + ); + let MissionControlDeviceTableStatus::Available(appended) = append else { + panic!("synthetic INTO sentinel should append: {append:?}"); + }; + assert_eq!(appended.len(), 2); + assert_eq!( + appended.iter().map(|entry| entry.key).collect::<Vec<_>>(), + [u32::MAX, 2] + ); + assert_eq!( + appended + .iter() + .map(|entry| entry.descriptor_provenance.typed_record_index) + .collect::<Vec<_>>(), + [0, 1] + ); + + let override_table = synthetic_control_table( + &[None, Some(PROTOTYPE_TYPE_INTO), Some(PROTOTYPE_TYPE_INTO)], + &[1, 1, 1], + &[2, 0, 0], + &[0, 0, 1], + &[1, 0, 0], + vec![ + Some(synthetic_component_control( + 0, + vec![ + synthetic_control_record(19, 11, 0x10, None), + synthetic_control_record(19, 12, 0x20, None), + ], + PreparedControlEffectSection::Parsed(Vec::new()), + )), + Some(synthetic_component_control( + 1, + vec![ + synthetic_control_record(21, 99, 0xA1, Some(0x77)), + synthetic_control_record(25, 88, 0xA2, Some(0x88)), + ], + PreparedControlEffectSection::Parsed(Vec::new()), + )), + Some(synthetic_component_control( + 2, + vec![synthetic_control_record(21, 77, 0xB1, None)], + PreparedControlEffectSection::Parsed(Vec::new()), + )), + ], + ); + let MissionControlDeviceTableStatus::Available(overridden) = override_table else { + panic!("synthetic INTO overrides should be available: {override_table:?}"); + }; + assert_eq!(overridden.len(), 2); + assert_eq!( + overridden + .iter() + .map(|entry| (entry.factory_tag, entry.key, entry.component_id)) + .collect::<Vec<_>>(), + [(19, 11, 0), (19, 12, 0)] + ); + assert_eq!( + overridden + .iter() + .map(|entry| entry.coefficient_bits.map(|words| words[0])) + .collect::<Vec<_>>(), + [Some(0xA1), Some(0xB1)] + ); + assert_eq!( + overridden + .iter() + .map(|entry| entry.native_word_50_bits) + .collect::<Vec<_>>(), + [Some(0x77), Some(0x20)] + ); + assert_eq!( + overridden + .iter() + .map(|entry| entry.multiplier_bits) + .collect::<Vec<_>>(), + [Some(0x3F80_0000); 2] + ); + assert_eq!( + overridden + .iter() + .map(|entry| entry.descriptor_provenance.unit_component_index) + .collect::<Vec<_>>(), + [1, 2] + ); + assert_eq!( + overridden + .iter() + .map(|entry| entry.descriptor_provenance.typed_record_index) + .collect::<Vec<_>>(), + [0, 0] + ); + assert_eq!(overridden[0].descriptor.tag, 21); + + let mut live_device = overridden[0].clone(); + live_device.multiplier_bits = Some(0x4020_0000); // Live native multiplier 2.5. + let replacement = synthetic_control_record(25, 100, 0xC1, None); + let replacement_control = synthetic_component_control( + 3, + vec![replacement.clone()], + PreparedControlEffectSection::Parsed(Vec::new()), + ); + apply_effective_control_override( + &mut live_device, + &replacement, + 3, + 0, + &replacement_control, + ); + assert_eq!(live_device.factory_tag, 19); + assert_eq!(live_device.key, 11); + assert_eq!(live_device.component_id, 0); + assert_eq!(live_device.multiplier_bits, Some(0x4020_0000)); + assert_eq!( + live_device.coefficient_bits, + Some([0xC1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) + ); + } + + #[test] + fn synthetic_incomplete_typed_list_does_not_expose_partial_table() { + let status = synthetic_control_table( + &[None], + &[1], + &[0], + &[0], + &[1], + vec![Some(synthetic_component_control( + 0, + vec![synthetic_control_record(19, 1, 0x10, None)], + PreparedControlEffectSection::Unsupported { + typed_record_index: Some(1), + typed_record_tag: Some(0xDEAD), + }, + ))], + ); + assert_eq!( + status, + MissionControlDeviceTableStatus::Unavailable( + MissionControlDeviceTableUnavailableReason::IncompleteTypedRecordList { + unit_component_index: 0, + first_unparsed_record: 1, + } + ) + ); + } + + #[test] + #[ignore = "requires licensed corpus"] + fn full_load_builds_effective_control_device_table_for_mine_unit_dat() { + fn push_u32(bytes: &mut Vec<u8>, value: u32) { + bytes.extend_from_slice(&value.to_le_bytes()); + } + fn push_lp(bytes: &mut Vec<u8>, value: &[u8]) { + push_u32(bytes, u32::try_from(value.len()).expect("length fits u32")); + bytes.extend_from_slice(value); + } + fn single_unit_tma(land_path: &[u8]) -> Vec<u8> { + let mut bytes = Vec::new(); + push_u32(&mut bytes, 1); // TMA format version. + push_u32(&mut bytes, 0); // Paths. + push_u32(&mut bytes, 6); // Clan section version. + push_u32(&mut bytes, 0); // Clans. + push_u32(&mut bytes, 10); // Object section version. + push_u32(&mut bytes, 1); // One Unit DAT object. + push_u32(&mut bytes, 1); // Raw object kind. + push_u32(&mut bytes, 0x8000_0002); // Strict object class/flags word. + push_lp(&mut bytes, b"UNITS/BUILDS/MINE/min_l_n1.dat"); + push_u32(&mut bytes, 0); // Raw word after resource. + push_u32(&mut bytes, 0); // Identity/clan. + for value in [0.0_f32, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0] { + bytes.extend_from_slice(&value.to_le_bytes()); + } + push_lp(&mut bytes, b"mine-control-table-test"); + push_u32(&mut bytes, 0); // Raw word after name. + push_u32(&mut bytes, 0); // Link 0. + push_u32(&mut bytes, 0); // Link 1. + push_u32(&mut bytes, 1); // Property schema version. + push_u32(&mut bytes, 0); // Properties. + push_lp(&mut bytes, land_path); + push_u32(&mut bytes, 0); // Mission flag. + push_lp(&mut bytes, b""); // Description. + push_u32(&mut bytes, 1); // Extra section version. + push_u32(&mut bytes, 0); // Extras. + bytes + } + + let root = licensed_root("IS"); + let source_tma = std::fs::read(root.join("MISSIONS/Autodemo.00/data.tma")) + .expect("licensed source mission"); + let land_path = decode_mission_land_path(&source_tma, TmaProfile::Strict) + .expect("source mission land path") + .raw; + let mut overlay = MemoryVfs::default(); + overlay.insert( + normalize_engine_path("test mission", "MISSIONS/TEST/MINE/data.tma") + .expect("mission path"), + Arc::from(single_unit_tma(&land_path)), + ); + let vfs = Arc::new(OverlayVfs::from_layers(vec![ + Arc::new(overlay), + Arc::new(DirectoryVfs::new(&root)), + ])); + let mut engine = create(EngineServices::new(vfs)).expect("engine"); + let loaded = load_mission( + &mut engine, + MissionRequest { + key: "MISSIONS/TEST/MINE/data.tma".to_string(), + mode: MissionMode::SingleMission, + }, + 0, + ) + .expect("full normal mission load"); + assert_eq!(loaded.object_count, 1); + + let draft = &loaded_mission_object_drafts(&engine).expect("object drafts")[0]; + assert_eq!(draft.unit_components.len(), 6); + assert_eq!(draft.unit_components[0].immediate_child_count, 5); + let tables = loaded_mission_control_device_tables(&engine).expect("Control tables"); + assert_eq!(tables.len(), 1); + assert_eq!(tables[0].original_id, Some(OriginalObjectId(0))); + let control_handle = tables[0].handle; + assert_eq!( + query_loaded_mission_control_resource(&engine, control_handle, 1) + .expect("licensed selector 1") + .map(f32::to_bits), + Some(1.0_f32.to_bits()) + ); + assert_eq!( + query_loaded_mission_control_resource(&engine, control_handle, 2) + .expect("licensed selector 2") + .map(f32::to_bits), + Some(16.0_f32.to_bits()) + ); + let MissionControlDeviceTableStatus::Available(entries) = &tables[0].status else { + panic!( + "licensed mine table should be available: {:?}", + tables[0].status + ); + }; + assert_eq!(entries.len(), 11); + assert_eq!( + entries + .iter() + .map(|entry| entry.factory_tag) + .collect::<Vec<_>>(), + [19, 19, 9, 15, 12, 12, 13, 13, 26, 25, 21] + ); + assert_eq!( + entries + .iter() + .map(|entry| entry.descriptor.tag) + .collect::<Vec<_>>(), + [19, 19, 9, 15, 12, 12, 13, 13, 26, 25, 21] + ); + assert_eq!( + entries.iter().map(|entry| entry.key).collect::<Vec<_>>(), + [2, 2, 1, 1, 18, 21, 15, 16, 2, 1, 22] + ); + assert_eq!( + ( + entries[0].coefficient_bits.map(|words| words[0]), + entries[1].coefficient_bits.map(|words| words[0]) + ), + (Some(0x4100_0000), Some(0x4100_0000)) + ); + assert_eq!( + (entries[0].multiplier_bits, entries[0].native_word_50_bits), + (Some(0x3f80_0000), Some(0x20)) + ); + for index in [2, 3, 9] { + assert_eq!(entries[index].multiplier_bits, Some(0x3f80_0000)); + } + assert_eq!(entries[2].class9_selector0_scale_bits, Some(0x3f80_0000)); + assert_eq!( + entries + .iter() + .map(|entry| entry.descriptor_provenance.unit_component_index) + .collect::<Vec<_>>(), + [1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 5] + ); + assert_eq!(entries[8].descriptor_provenance.typed_record_index, 8); + assert_eq!( + query_loaded_mission_control_device_selector(&engine, control_handle, 8, 0xe00) + .expect("licensed tag-26 selector") + .map(f32::to_bits), + Some(1.0_f32.to_bits()) + ); + let prepared_controls = &engine + .loaded + .as_ref() + .expect("loaded mission state") + .mission_assets + .object_component_controls[0]; + let root_node_data = prepared_controls[0] + .as_ref() + .and_then(|control| control.node_data.as_ref()) + .expect("root NDP sidecar"); + let ext_node_data = prepared_controls[5] + .as_ref() + .and_then(|control| control.node_data.as_ref()) + .expect("EXTO NDP sidecar"); + let provider_rows = match &tables[0].node_provider_status { + MissionControlNodeProviderTableStatus::Available(rows) => rows, + MissionControlNodeProviderTableStatus::Unavailable(reason) => { + panic!("licensed provider table should be available: {reason:?}"); + } + }; + assert_eq!(root_node_data.rows.len(), 22); + assert_eq!(ext_node_data.rows.len(), 4); + assert_eq!(provider_rows.len(), 25); + 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))) + .collect::<Vec<_>>(); + assert_eq!( + provider_rows + .iter() + .map(|row| (row.unit_component_index, row.source_row_index)) + .collect::<Vec<_>>(), + expected_provider_sources + ); + assert!(provider_rows + .iter() + .all(|row| row.initial_type1_value_bits == 1.0_f32.to_bits())); + assert_eq!( + ( + entries[9].factory_tag, + entries[9].component_id, + entries[9].key + ), + (25, 0, 1) + ); + assert_eq!(entries[9].descriptor.tag, 25); + assert_eq!( + ( + entries[10].factory_tag, + entries[10].component_id, + entries[10].key + ), + (21, 5, 22) + ); + assert_eq!(entries[10].descriptor.tag, 21); + set_loaded_mission_control_multiplier(&mut engine, control_handle, 2.5) + .expect("licensed setter 1"); + assert_eq!( + query_loaded_mission_control_resource(&engine, control_handle, 1) + .expect("updated licensed selector 1") + .map(f32::to_bits), + Some(2.5_f32.to_bits()) + ); + } + + #[test] fn script_varset_prefers_bundle_adjacent_file_then_uses_shared_fallback() { let mut personal_files = MemoryVfs::default(); personal_files.insert( @@ -2470,6 +5267,26 @@ mod tests { .collect::<Vec<_>>(), vec![(0, true), (1, true)] ); + let ore_states = loaded_mission_behavior_ore_states(&engine).expect("Behavior ore state"); + let unit_dat_drafts = drafts + .iter() + .filter(|draft| draft.unit_dat_header_flags.is_some()) + .collect::<Vec<_>>(); + assert_eq!(ore_states.len(), unit_dat_drafts.len()); + assert_eq!(ore_states.len(), 8); + for state in ore_states { + let draft = unit_dat_drafts + .iter() + .find(|draft| draft.original_id == Some(state.original_id)) + .expect("ore state has a Unit DAT source"); + assert_eq!( + state.handle, + handle_by_original_id(&engine.world, state.original_id).unwrap() + ); + assert_eq!(state.class_flags, draft.unit_dat_header_flags.unwrap()); + assert_eq!(state.current_ore_bits, 0); + assert_eq!(state.maximum_ore_bits, 0); + } let registered = distributors .iter() .flat_map(|distributor| { @@ -2538,6 +5355,15 @@ mod tests { ] ); assert_eq!(registered.len(), 4); + assert!(ore_states.iter().any(|state| { + state.class_flags == 0x0100_8000 + && !distributors.iter().any(|distributor| { + distributor + .registered_objects + .iter() + .any(|object| object.handle == state.handle) + }) + })); for (_, object) in registered { assert_eq!( handle_by_original_id(&engine.world, object.original_id), @@ -2620,6 +5446,55 @@ mod tests { } #[test] + fn behavior_ore_initialization_uses_first_exact_current_value_and_read_only_maximum() { + let handle = ObjectHandle { + generation: 7, + slot: 19, + }; + let state = initialize_behavior_ore_state( + OriginalObjectId(19), + handle, + 0x0100_2000, + &[ + MissionObjectProperty { + name_raw: b"currentore".to_vec(), + raw_value: [0x1111_1111, 0xdead_beef, 0, 0], + }, + MissionObjectProperty { + name_raw: b"CurrentOre".to_vec(), + raw_value: [0x3f80_0000, 0x7fc1_2345, 0, 0], + }, + MissionObjectProperty { + name_raw: b"CurrentOre".to_vec(), + raw_value: [0, 0x4400_0000, 0, 0], + }, + MissionObjectProperty { + name_raw: b"MaximumOre".to_vec(), + raw_value: [0, 0x4123_4567, 0, 0], + }, + ], + ); + + assert_eq!(state.original_id, OriginalObjectId(19)); + assert_eq!(state.handle, handle); + assert_eq!(state.class_flags, 0x0100_2000); + assert_eq!(state.current_ore_bits, 0x7fc1_2345); + assert_eq!(state.maximum_ore_bits, 0x44fa_0000); + } + + #[test] + fn behavior_ore_defaults_follow_native_class_dispatch() { + assert_eq!(native_behavior_ore_defaults(0x8000_0004), (0, 0x43fa_0000)); + assert_eq!(native_behavior_ore_defaults(0x8000_0008), (0, 0x457a_0000)); + assert_eq!(native_behavior_ore_defaults(0x0100_2000), (0, 0x44fa_0000)); + assert_eq!( + native_behavior_ore_defaults(0x0100_4000), + (0x44fa_0000, 0x44fa_0000) + ); + assert_eq!(native_behavior_ore_defaults(0x0100_8000), (0, 0)); + } + + #[test] fn behavior_distributor_add_uses_handle_and_preserves_duplicate_tail() { let mut distributor = BehaviorDistributorState { clan_index: 0, @@ -2767,6 +5642,9 @@ mod tests { assert!(loaded_mission_behavior_distributors(&engine) .expect("preview Behavior distributors") .is_empty()); + assert!(loaded_mission_behavior_ore_states(&engine) + .expect("preview Behavior ore state") + .is_empty()); assert!(bundles .iter() .all(|bundle| bundle.behavior_warm_start.is_none())); |