diff options
| -rw-r--r-- | Cargo.lock | 1 | ||||
| -rw-r--r-- | crates/fparkan-msh/src/lib.rs | 12 | ||||
| -rw-r--r-- | crates/fparkan-runtime/Cargo.toml | 1 | ||||
| -rw-r--r-- | crates/fparkan-runtime/src/lib.rs | 483 | ||||
| -rw-r--r-- | crates/fparkan-runtime/tests/behavior_distributor_tick_native_oracle.cs | 693 | ||||
| -rw-r--r-- | docs/appendices/knowledge-boundaries.md | 37 | ||||
| -rw-r--r-- | docs/appendices/script-vm.md | 167 | ||||
| -rw-r--r-- | docs/tomes/06-behavior.md | 49 |
8 files changed, 1427 insertions, 16 deletions
@@ -630,6 +630,7 @@ name = "fparkan-runtime" version = "0.1.0" dependencies = [ "fparkan-assets", + "fparkan-msh", "fparkan-path", "fparkan-platform", "fparkan-prototype", diff --git a/crates/fparkan-msh/src/lib.rs b/crates/fparkan-msh/src/lib.rs index b6459ab..4b561e7 100644 --- a/crates/fparkan-msh/src/lib.rs +++ b/crates/fparkan-msh/src/lib.rs @@ -140,7 +140,10 @@ pub struct Node { /// Raw fields of the standard 38-byte node layout that precede slot selection. #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub struct Node38Metadata { - /// Unassigned source link value at byte offset two. + /// Raw Node38 header/flag word at byte offset zero. + pub header_flags: u16, + /// Source-local parent word at byte offset two; `0xFFFF` is the native + /// sentinel before component rebasing. pub parent_or_link_raw: u16, /// Offset into the type-19 frame map, or `0xFFFF` for no map. pub anim_map_start: u16, @@ -431,6 +434,7 @@ pub fn node38_metadata(model: &ModelAsset, node: NodeId) -> Option<Node38Metadat } let offset = node_index.checked_mul(model.node_stride)?; Some(Node38Metadata { + header_flags: read_u16(&model.nodes_raw, offset)?, parent_or_link_raw: read_u16(&model.nodes_raw, offset + 2)?, anim_map_start: read_u16(&model.nodes_raw, offset + 4)?, fallback_key: read_u16(&model.nodes_raw, offset + 6)?, @@ -441,8 +445,8 @@ pub fn node38_metadata(model: &ModelAsset, node: NodeId) -> Option<Node38Metadat /// /// The legacy sampler uses this key when a node has no frame map or its current /// frame falls outside that map. It is a static-pose input only; callers must -/// still recover animation state and the meaning of `parent_or_link_raw` before -/// assembling a runtime hierarchy. Its quaternion is converted to match native +/// assemble the runtime hierarchy separately and apply the component-specific +/// mapping of `parent_or_link_raw`. Its quaternion is converted to match native /// AniMesh's quaternion-to-matrix convention. #[must_use] pub fn node38_fallback_pose(model: &ModelAsset, node: NodeId) -> Option<Pose> { @@ -1412,6 +1416,7 @@ mod tests { #[test] fn standard_node_exposes_fallback_pose_and_unassigned_link() { let mut node = node38([u16::MAX; 15]); + node[0..2].copy_from_slice(&0x8201_u16.to_le_bytes()); node[2..4].copy_from_slice(&7_u16.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()); @@ -1440,6 +1445,7 @@ mod tests { assert_eq!( node38_metadata(&model, NodeId(0)), Some(Node38Metadata { + header_flags: 0x8201, parent_or_link_raw: 7, anim_map_start: u16::MAX, fallback_key: 0, diff --git a/crates/fparkan-runtime/Cargo.toml b/crates/fparkan-runtime/Cargo.toml index ddf09a1..f66551b 100644 --- a/crates/fparkan-runtime/Cargo.toml +++ b/crates/fparkan-runtime/Cargo.toml @@ -7,6 +7,7 @@ repository.workspace = true [dependencies] fparkan-assets = { path = "../fparkan-assets" } +fparkan-msh = { path = "../fparkan-msh" } fparkan-path = { path = "../fparkan-path" } fparkan-platform = { path = "../fparkan-platform" } fparkan-prototype = { path = "../fparkan-prototype" } diff --git a/crates/fparkan-runtime/src/lib.rs b/crates/fparkan-runtime/src/lib.rs index 51b5180..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, @@ -210,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. @@ -224,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. @@ -3256,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; @@ -3412,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, @@ -3452,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, @@ -3948,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], @@ -5215,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, @@ -5767,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))) @@ -5781,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, diff --git a/crates/fparkan-runtime/tests/behavior_distributor_tick_native_oracle.cs b/crates/fparkan-runtime/tests/behavior_distributor_tick_native_oracle.cs index 247d08d..efd9b08 100644 --- a/crates/fparkan-runtime/tests/behavior_distributor_tick_native_oracle.cs +++ b/crates/fparkan-runtime/tests/behavior_distributor_tick_native_oracle.cs @@ -5,7 +5,7 @@ using System.Runtime.InteropServices; using System.Security.Cryptography; using System.Text; -// Calls selected original x86 Behavior.dll, ArealMap.dll, and Control.dll paths +// Calls selected original x86 Behavior.dll, ArealMap.dll, AniMesh.dll, and Control.dll paths // against synthetic storage. Only host callbacks, GetSystemArealMap/GetQueue IAT // slots, and bounded vector backing are substituted; tested module code remains installed. internal static class BehaviorDistributorTickOracle { @@ -17,6 +17,7 @@ internal static class BehaviorDistributorTickOracle { private const string ExpectedBehaviorSha256 = "ddfbdbde07832358fe6e35e01c8dba9b58e7313789498b6049ed51d4ed9baf99"; private const string ExpectedControlSha256 = "bcb86318089028548a178b03a21accdce15df0cc85ddd91674cf3c2f55012c6e"; private const string ExpectedArealMapSha256 = "a25f9254ebb339d70e2e07c8121950191e9584ca0858d8e9c2e2b6c671edf6ea"; + private const string ExpectedAniMeshSha256 = "65659bf67f20e5be77d67a5b2f59968f61b94293143807fa59ca451c560c4f7e"; private const int TickRva = 0x19e80; private const int DistributorScheduleRva = 0x1adb0; private const int AddObjectRva = 0x1aac0; @@ -35,11 +36,18 @@ internal static class BehaviorDistributorTickOracle { private const int ControlProviderInterfaceVtableRva = 0x3d254; private const int ControlProviderType1GetterRva = 0x0dc40; private const int ControlProviderRowConstructorRva = 0x0b240; + private const int ControlOwnerConstructorRva = 0x06bf0; + private const int ControlProviderInitialStateRva = 0x0f940; private const int ControlProviderAmountUpdateRva = 0x10f30; private const int ControlProviderAmountDistributeRva = 0x10ba0; + private const int ControlProviderStagePropagationRva = 0x11130; + private const int ControlProviderStageUpdateRva = 0x11220; private const int ControlContactRateUpdateRva = 0x12a40; private const int ControlTimedUpdateRva = 0x0bcf0; private const int ArealMapUnitDatComponentBuilderRva = 0x14b90; + private const int AniMeshNodeMetadataQueryRva = 0x051f0; + private const int AniMeshNodeStageCountRva = 0x05840; + private const int AniMeshNodeStageSetRva = 0x05810; private const int ControlResourceDeviceConstructorRva = 0x22980; private const int ControlResourceComponentOverrideRva = 0x2d890; private const int ControlResourceCommonSetterRva = 0x21d50; @@ -99,6 +107,8 @@ internal static class BehaviorDistributorTickOracle { [UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate float NativeControlResourceDeviceGet(IntPtr self, uint selector); [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate void NativeFastcallComponentBuilder(IntPtr owner, IntPtr node, uint parentId); [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate int NativeArealMapEvent(IntPtr owner, uint message, uint subcode, IntPtr descriptor); + [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate int NativeAniMeshNodeMetadataQuery(IntPtr owner, uint nodeIndex, uint selector, IntPtr result); + [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate uint NativeAniMeshNodeStageCount(IntPtr owner, uint nodeIndex); [UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeControlResourceDeviceConstructor(IntPtr self); [UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeControlResourceComponentOverride(IntPtr self, int deviceIndex, IntPtr typedRecord); [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate int NativeControlAggregateQuery(IntPtr self, uint selector, IntPtr result); @@ -108,7 +118,12 @@ internal static class BehaviorDistributorTickOracle { [UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeControlContactRateUpdate(IntPtr self, float deltaSeconds); [UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeControlTimedUpdate(IntPtr self, float inputTime); [UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeControlProviderRowConstructor(IntPtr self, IntPtr sourceNdpRow); + [UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeControlOwnerConstructor(IntPtr self, IntPtr host, uint classCode); + [UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeControlProviderInitialState(IntPtr self); [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate void NativeControlNodeUpdateCallback(IntPtr self, uint nodeIndex, uint selector, uint valueBits); + [UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeControlProviderStageUpdate(IntPtr self, int nodeIndex, uint updateEffects); + [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate void NativeAniMeshStageTransitionCallback(IntPtr self, uint nodeIndex, uint visibleStage); + [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate uint NativeAniMeshNodeLifecycleCallback(IntPtr self, uint nodeIndex, uint selector, uint mask); private static readonly AreaMapGetter AreaMapGetterCallback = GetAreaMap; private static readonly QueueGetter QueueGetterCallback = GetQueue; @@ -125,12 +140,28 @@ internal static class BehaviorDistributorTickOracle { private static readonly InterfaceSetProperty InterfaceSetCallback = SetInterfaceProperty; private static readonly NativeArealMapEvent ArealMapEventCallback = OnArealMapEvent; private static readonly NativeControlNodeUpdateCallback ControlNodeUpdateCallback = OnControlNodeUpdate; + private static readonly NativeAniMeshStageTransitionCallback AniMeshStageTransitionCallback = OnAniMeshStageTransition; + private static readonly NativeAniMeshNodeLifecycleCallback AniMeshNodeLifecycleCallback = OnAniMeshNodeLifecycle; + private static readonly NativeAniMeshNodeMetadataQuery AniMeshNodeMetadataQueryCallback = OnAniMeshNodeMetadataQuery; private static ArealMapFixture activeArealMap; private static int controlNodeUpdateCount; private static uint controlNodeUpdateIndex; private static uint controlNodeUpdateSelector; private static uint controlNodeUpdateValueBits; private static readonly List<uint> controlNodeUpdateIndices = new List<uint>(); + private static readonly List<uint> controlNodeUpdateFlags = new List<uint>(); + private static readonly List<string> aniMeshStageTransitions = new List<string>(); + private static readonly List<string> aniMeshNodeLifecycleCallbacks = new List<string>(); + private static readonly List<string> aniMeshNodeMetadataQueries = new List<string>(); + private static readonly List<string> controlProviderCallbackTrace = new List<string>(); + private static NativeAniMeshStageTransitionCallback activeNativeAniMeshStageTransition; + private static NativeAniMeshNodeLifecycleCallback activeNativeAniMeshNodeLifecycle; + private static NativeAniMeshNodeMetadataQuery activeNativeAniMeshNodeMetadataQuery; + private static IntPtr activeControlProviderRows; + private static IntPtr activeAniMeshInterface; + private static bool aniMeshCallbackOwnerMismatch; + private static bool controlNodeUpdateOwnerMismatch; + private static bool nativeAniMeshStageCallbackMissing; private static IntPtr fastcallThunks; private static IntPtr queryObjectThunk; private static IntPtr getInterfacePropertyThunk; @@ -475,11 +506,45 @@ internal static class BehaviorDistributorTickOracle { return 1; } private static void OnControlNodeUpdate(IntPtr self, uint nodeIndex, uint selector, uint valueBits) { + if (activeAniMeshInterface != IntPtr.Zero && self != activeAniMeshInterface) + controlNodeUpdateOwnerMismatch = true; controlNodeUpdateCount++; controlNodeUpdateIndex = nodeIndex; controlNodeUpdateSelector = selector; controlNodeUpdateValueBits = valueBits; controlNodeUpdateIndices.Add(nodeIndex); + controlProviderCallbackTrace.Add("amount:" + nodeIndex.ToString()); + if (activeControlProviderRows != IntPtr.Zero) + controlNodeUpdateFlags.Add(unchecked((uint)Marshal.ReadInt32(activeControlProviderRows, checked((int)nodeIndex * 0x2c + 0x28)))); + } + private static void OnAniMeshStageTransition(IntPtr self, uint nodeIndex, uint visibleStage) { + controlProviderCallbackTrace.Add("stage:" + nodeIndex.ToString() + ":" + visibleStage.ToString()); + aniMeshStageTransitions.Add(nodeIndex.ToString() + ":" + visibleStage.ToString()); + if (activeAniMeshInterface != IntPtr.Zero && self != activeAniMeshInterface) + aniMeshCallbackOwnerMismatch = true; + if (activeNativeAniMeshStageTransition == null) nativeAniMeshStageCallbackMissing = true; + else activeNativeAniMeshStageTransition(self, nodeIndex, visibleStage); + } + private static uint OnAniMeshNodeLifecycle(IntPtr self, uint nodeIndex, uint selector, uint mask) { + aniMeshNodeLifecycleCallbacks.Add(nodeIndex.ToString() + ":" + selector.ToString("x") + ":" + mask.ToString("x")); + controlProviderCallbackTrace.Add("lifecycle:" + nodeIndex.ToString() + ":" + selector.ToString("x") + ":" + mask.ToString("x")); + if (activeAniMeshInterface != IntPtr.Zero && self != activeAniMeshInterface) + aniMeshCallbackOwnerMismatch = true; + if (activeNativeAniMeshNodeLifecycle == null) { + nativeAniMeshStageCallbackMissing = true; + return 0; + } + return activeNativeAniMeshNodeLifecycle(self, nodeIndex, selector, mask); + } + private static int OnAniMeshNodeMetadataQuery(IntPtr self, uint nodeIndex, uint selector, IntPtr result) { + int nativeResult = activeNativeAniMeshNodeMetadataQuery(self, nodeIndex, selector, result); + int success = (nativeResult & 0xff) != 0 ? 1 : 0; + if (activeAniMeshInterface != IntPtr.Zero && self != activeAniMeshInterface) + aniMeshCallbackOwnerMismatch = true; + IntPtr value = success != 0 && result != IntPtr.Zero ? Marshal.ReadIntPtr(result) : IntPtr.Zero; + aniMeshNodeMetadataQueries.Add(nodeIndex.ToString() + ":" + selector.ToString("x") + ":" + + (value == IntPtr.Zero ? "none" : Hex(unchecked((uint)Marshal.ReadInt32(value))))); + return success; } private static float SequenceValue(float[] sequence, int index, float fallback) { if (sequence == null || sequence.Length == 0) return fallback; @@ -522,6 +587,11 @@ internal static class BehaviorDistributorTickOracle { if (!File.Exists(arealMapPath)) { Console.Error.WriteLine("Set FPARKAN_ORIGINAL_AREALMAP_DLL to the installed ArealMap.dll."); return 10; } string arealMapHash = Hash(arealMapPath); if (arealMapHash != ExpectedArealMapSha256) { Console.Error.WriteLine("Unexpected ArealMap.dll SHA-256: " + arealMapHash); return 11; } + string aniMeshPath = Environment.GetEnvironmentVariable("FPARKAN_ORIGINAL_ANIMESH_DLL"); + if (String.IsNullOrEmpty(aniMeshPath)) aniMeshPath = @"C:\GOG Games\Parkan - Iron Strategy\AniMesh.dll"; + if (!File.Exists(aniMeshPath)) { Console.Error.WriteLine("Set FPARKAN_ORIGINAL_ANIMESH_DLL to the installed AniMesh.dll."); return 13; } + string aniMeshHash = Hash(aniMeshPath); + if (aniMeshHash != ExpectedAniMeshSha256) { Console.Error.WriteLine("Unexpected AniMesh.dll SHA-256: " + aniMeshHash); return 14; } IntPtr controlModule = LoadLibraryEx(controlPath, IntPtr.Zero, LoadWithAlteredSearchPath); if (controlModule == IntPtr.Zero) { Console.Error.WriteLine("LoadLibraryEx(Control.dll) failed: " + Marshal.GetLastWin32Error()); return 9; } string path = Environment.GetEnvironmentVariable("FPARKAN_ORIGINAL_BEHAVIOR_DLL"); @@ -536,6 +606,11 @@ internal static class BehaviorDistributorTickOracle { Console.Error.WriteLine("LoadLibraryEx(ArealMap.dll) failed: " + Marshal.GetLastWin32Error()); FreeLibrary(module); FreeLibrary(controlModule); return 12; } + IntPtr aniMeshModule = LoadLibraryEx(aniMeshPath, IntPtr.Zero, LoadWithAlteredSearchPath); + if (aniMeshModule == IntPtr.Zero) { + Console.Error.WriteLine("LoadLibraryEx(AniMesh.dll) failed: " + Marshal.GetLastWin32Error()); + FreeLibrary(arealMapModule); FreeLibrary(module); FreeLibrary(controlModule); return 15; + } IntPtr import = IntPtr.Add(module, GetSystemArealMapIatRva); IntPtr queueImport = IntPtr.Add(module, GetQueueIatRva); IntPtr originalImport = Marshal.ReadIntPtr(import); @@ -560,7 +635,7 @@ internal static class BehaviorDistributorTickOracle { protectionChanged = true; Marshal.WriteIntPtr(import, Marshal.GetFunctionPointerForDelegate(AreaMapGetterCallback)); Marshal.WriteIntPtr(queueImport, Marshal.GetFunctionPointerForDelegate(QueueGetterCallback)); - RunSmokeCases(module, controlModule, arealMapModule); + RunSmokeCases(module, controlModule, arealMapModule, aniMeshModule); Console.WriteLine("original native Behavior/ArealMap/Control oracle passed (Behavior Add 0x1aac0, normalize 0x1ac90, scheduler 0x1adb0, tick 0x19e80; ArealMap UnitDAT projection 0x14b90; Control INTO override 0x2d890, provider distribution 0x10ba0, class-4 update 0x12a40 and inactive timing baseline 0xbcf0; synthetic host callbacks, GetSystemArealMap/GetQueue IAT slots, and bounded vector insertion are substituted; Control provider selector vtable is original; no full Control update or Rust parity is claimed)."); return 0; } @@ -587,12 +662,13 @@ internal static class BehaviorDistributorTickOracle { throw new InvalidOperationException("VirtualFree(fastcall callback thunks) failed: " + Marshal.GetLastWin32Error()); if (x87ControlWordCell != IntPtr.Zero) { Marshal.FreeHGlobal(x87ControlWordCell); x87ControlWordCell = IntPtr.Zero; } FreeLibrary(arealMapModule); + FreeLibrary(aniMeshModule); FreeLibrary(module); FreeLibrary(controlModule); } } - private static void RunSmokeCases(IntPtr module, IntPtr controlModule, IntPtr arealMapModule) { + private static void RunSmokeCases(IntPtr module, IntPtr controlModule, IntPtr arealMapModule, IntPtr aniMeshModule) { ushort savedControlWord = CurrentX87ControlWord(); Console.WriteLine("x87-control-word-before=0x" + savedControlWord.ToString("x4") + " (x86 oracle process)"); try { @@ -601,9 +677,15 @@ internal static class BehaviorDistributorTickOracle { RunNativeAddCases(module); RunNativeNormalizeCases(module); RunNativeArealMapComponentBuilderCase(arealMapModule); + RunNativeAniMeshScaleLoadSnapshot(aniMeshModule); + RunNativeAniMeshNodeMetadataCases(aniMeshModule); + RunNativeControlProviderInitialStateCase(controlModule, aniMeshModule); RunNativeControlIntoOverrideCase(controlModule); RunNativeControlResourceDeviceCase(controlModule); RunNativeControlProviderLiveStateCase(controlModule); + RunNativeControlProviderStageArithmeticCase(controlModule, aniMeshModule); + RunNativeControlProviderHierarchyPropagationCase(controlModule, aniMeshModule); + RunNativeControlProviderVisibilityCase(controlModule, aniMeshModule); RunNativeControlProviderDistributionCases(controlModule); RunNativeControlContactRateUpdateCase(controlModule); RunNativeControlTimedUpdateBaselineCases(controlModule); @@ -857,6 +939,388 @@ internal static class BehaviorDistributorTickOracle { } } + private static void RunNativeControlProviderStageArithmeticCase(IntPtr module, IntPtr aniMeshModule) { + NativeControlProviderStageUpdate updateStage = (NativeControlProviderStageUpdate) + Marshal.GetDelegateForFunctionPointer(IntPtr.Add(module, ControlProviderStageUpdateRva), typeof(NativeControlProviderStageUpdate)); + activeNativeAniMeshStageTransition = (NativeAniMeshStageTransitionCallback) + Marshal.GetDelegateForFunctionPointer(IntPtr.Add(aniMeshModule, AniMeshNodeStageSetRva), + typeof(NativeAniMeshStageTransitionCallback)); + activeNativeAniMeshNodeLifecycle = (NativeAniMeshNodeLifecycleCallback) + Marshal.GetDelegateForFunctionPointer(IntPtr.Add(aniMeshModule, 0x05500), + typeof(NativeAniMeshNodeLifecycleCallback)); + using (Fixture fixture = new Fixture()) { + const int rowCount = 9; + IntPtr owner = fixture.Allocate(0x664); + IntPtr rows = fixture.Allocate(rowCount * 0x2c); + IntPtr aniInterface = fixture.Allocate(0x1b0); + IntPtr aniVtable = fixture.Allocate(0x50); + IntPtr meshRows = fixture.Allocate(rowCount * 0x130); + Marshal.WriteIntPtr(aniInterface, 0, aniVtable); + Marshal.WriteIntPtr(aniInterface, 0x1a8, meshRows); + Marshal.WriteInt32(aniInterface, 0x1ac, rowCount); + for (int index = 0; index < rowCount; index++) + Marshal.WriteInt32(meshRows, index * 0x130 + 0x1c, -99); + Marshal.WriteIntPtr(aniVtable, 0x44, Marshal.GetFunctionPointerForDelegate(AniMeshStageTransitionCallback)); + Marshal.WriteIntPtr(aniVtable, 0x20, Marshal.GetFunctionPointerForDelegate(AniMeshNodeLifecycleCallback)); + Marshal.WriteIntPtr(owner, 0x20, aniInterface); + Marshal.WriteIntPtr(owner, 0x55c, rows); + Marshal.WriteInt32(owner, 0x560, rowCount); + + // Parent ratio .25 yields stage 3 of 4. Bit 4 inherits that ratio; + // bit 8 inherits the parent's stage and clamps it to the child's count. + WriteProviderStageRow(rows, 0, -1, 40.0f, 91.0f, 0.25f, 0, 4, 0x02); + WriteProviderStageRow(rows, 1, 0, 12.0f, 81.0f, 0.875f, 0, 5, 0x06); + WriteProviderStageRow(rows, 2, 0, 7.0f, 71.0f, 0.9f, 0, 2, 0x0a); + WriteProviderStageRow(rows, 3, 1, 3.0f, 31.0f, 0.1f, 0, 6, 0x0e); + // These independent rows distinguish the native ceiling operation + // from floor/round for fractional stage products. + WriteProviderStageRow(rows, 4, -1, 2.0f, 92.0f, 0.1f, 0, 3, 0x02); + WriteProviderStageRow(rows, 5, -1, 3.0f, 93.0f, 0.4f, 0, 3, 0x02); + WriteProviderStageRow(rows, 6, -1, 4.0f, 94.0f, 0.5f, 0, 3, 0x02); + WriteProviderStageRow(rows, 7, -1, 5.0f, 95.0f, 1.0f, 1, 3, 0x102); + WriteProviderStageRow(rows, 8, -1, 6.0f, 96.0f, 0.0f, 0, 3, 0x02); + + aniMeshStageTransitions.Clear(); + aniMeshNodeLifecycleCallbacks.Clear(); + controlProviderCallbackTrace.Clear(); + aniMeshCallbackOwnerMismatch = false; + controlNodeUpdateOwnerMismatch = false; + nativeAniMeshStageCallbackMissing = false; + activeAniMeshInterface = aniInterface; + updateStage(owner, 0, 0); // param2=false suppresses effect creation. + updateStage(owner, 1, 0); + updateStage(owner, 2, 0); + updateStage(owner, 3, 0); + for (int index = 4; index < rowCount; index++) updateStage(owner, index, 0); + + uint[] expectedStages = { 3, 3, 2, 3, 2, 1, 1, 0, 3 }; + uint[] expectedVisibleStages = { 3, 3, 1, 3, 2, 1, 1, 0, 2 }; + uint[] expectedAmounts = { 0x42200000, 0x41400000, 0x40e00000, 0x40400000, + 0x40000000, 0x40400000, 0x40800000, 0x40a00000, 0x40c00000 }; + for (int index = 0; index < rowCount; index++) { + IntPtr row = IntPtr.Add(rows, index * 0x2c); + IntPtr meshRow = IntPtr.Add(meshRows, index * 0x130); + Expect(unchecked((uint)Marshal.ReadInt32(row, 0x18)) == expectedStages[index], + "Control 0x11220 computes inherited stage for row " + index); + Expect(unchecked((uint)Marshal.ReadInt32(meshRow, 0x1c)) == expectedVisibleStages[index], + "AniMesh RVA 0x5810 receives the bounded visual stage for row " + index); + Expect(unchecked((uint)Marshal.ReadInt32(row, 0x08)) == expectedAmounts[index] && + unchecked((uint)Marshal.ReadInt32(row, 0x0c)) == expectedAmounts[index], + "Control 0x11220 retains amount and updates its processed snapshot for row " + index); + Expect((unchecked((uint)Marshal.ReadInt32(row, 0x28)) & 0x200) != 0, + "Control 0x11220 records a stage transition for row " + index); + } + Expect(unchecked((uint)Marshal.ReadInt32(rows, 0x14)) == 0x3e800000 && + unchecked((uint)Marshal.ReadInt32(rows, 0x2c + 0x14)) == 0x3e800000 && + unchecked((uint)Marshal.ReadInt32(rows, 3 * 0x2c + 0x14)) == 0x3e800000, + "Control flag 4 copies the parent type-1 ratio before stage calculation"); + Expect(String.Join(",", aniMeshStageTransitions.ToArray()) == "0:3,1:3,2:1,3:3,4:2,5:1,6:1,7:0,8:2" && + String.Join(",", aniMeshNodeLifecycleCallbacks.ToArray()) == "7:101:4" && !aniMeshCallbackOwnerMismatch && + !controlNodeUpdateOwnerMismatch && !nativeAniMeshStageCallbackMissing, + "Control stage and slot-0x20 callbacks reach the original AniMesh RVA 0x5810 in direct update order"); + Expect(String.Join(",", controlProviderCallbackTrace.ToArray()) == + "stage:0:3,stage:1:3,stage:2:1,stage:3:3,stage:4:2,stage:5:1,stage:6:1,lifecycle:7:101:4,stage:7:0,stage:8:2", + "AniMesh slot 0x20 receives its native node, selector, and mask arguments before stage publication"); + + Console.WriteLine("native-control-parent-stage-arithmetic: controlHash=" + ExpectedControlSha256 + + " rva=0x11220 bit4=ratio bit8=parent-stage ceil=[0.1,0.4,0.5,1,0]=>[2,1,1,0,3]" + + " callbacks=[0:3,1:3,2:1,3:3,4:2,5:1,6:1,lifecycle7:101:4,7:0,8:2]"); + activeAniMeshInterface = IntPtr.Zero; + activeNativeAniMeshStageTransition = null; + activeNativeAniMeshNodeLifecycle = null; + GC.KeepAlive(updateStage); + } + } + + private static void RunNativeControlProviderHierarchyPropagationCase(IntPtr module, IntPtr aniMeshModule) { + NativeControlProviderStageUpdate propagate = (NativeControlProviderStageUpdate) + Marshal.GetDelegateForFunctionPointer(IntPtr.Add(module, ControlProviderStagePropagationRva), typeof(NativeControlProviderStageUpdate)); + activeNativeAniMeshStageTransition = (NativeAniMeshStageTransitionCallback) + Marshal.GetDelegateForFunctionPointer(IntPtr.Add(aniMeshModule, AniMeshNodeStageSetRva), + typeof(NativeAniMeshStageTransitionCallback)); + activeNativeAniMeshNodeLifecycle = (NativeAniMeshNodeLifecycleCallback) + Marshal.GetDelegateForFunctionPointer(IntPtr.Add(aniMeshModule, 0x05500), + typeof(NativeAniMeshNodeLifecycleCallback)); + using (Fixture fixture = new Fixture()) { + NativeProviderTable table = CreateNativeProviderTable(fixture, module, + new float[] { 100.0f, 20.0f, 10.0f, 30.0f, 14.0f }, + new float[] { 25.0f, 10.0f, 5.0f, 12.0f, 7.0f }, + new byte[] { 0x02, 0x02, 0x02, 0x02, 0x02 }); + const int rowCount = 5; + int[] parents = { -1, 0, 1, 0, 0 }; + uint[] stages = { 4, 2, 3, 2, 2 }; + uint[] flags = { 0x02, 0x42, 0x02, 0x102, 0x02 }; + for (int index = 0; index < rowCount; index++) { + IntPtr row = IntPtr.Add(table.Rows, index * 0x2c); + WriteProviderStageRow(table.Rows, index, parents[index], ReadFloat(row, 0x08), + 123.0f + index, ReadFloat(row, 0x14), 0, stages[index], flags[index]); + } + + IntPtr aniInterface = fixture.Allocate(0x1b0); + IntPtr aniVtable = fixture.Allocate(0x50); + IntPtr meshRows = fixture.Allocate(rowCount * 0x130); + Marshal.WriteIntPtr(aniInterface, 0, aniVtable); + Marshal.WriteIntPtr(aniInterface, 0x1a8, meshRows); + Marshal.WriteInt32(aniInterface, 0x1ac, rowCount); + for (int index = 0; index < rowCount; index++) + Marshal.WriteInt32(meshRows, index * 0x130 + 0x1c, -99); + Marshal.WriteIntPtr(aniVtable, 0x20, Marshal.GetFunctionPointerForDelegate(AniMeshNodeLifecycleCallback)); + Marshal.WriteIntPtr(aniVtable, 0x34, Marshal.GetFunctionPointerForDelegate(ControlNodeUpdateCallback)); + Marshal.WriteIntPtr(aniVtable, 0x44, Marshal.GetFunctionPointerForDelegate(AniMeshStageTransitionCallback)); + Marshal.WriteIntPtr(table.Owner, 0x20, aniInterface); + + controlNodeUpdateCount = 0; + controlNodeUpdateIndices.Clear(); + controlNodeUpdateFlags.Clear(); + aniMeshStageTransitions.Clear(); + aniMeshNodeLifecycleCallbacks.Clear(); + controlProviderCallbackTrace.Clear(); + aniMeshCallbackOwnerMismatch = false; + controlNodeUpdateOwnerMismatch = false; + nativeAniMeshStageCallbackMissing = false; + activeControlProviderRows = table.Rows; + activeAniMeshInterface = aniInterface; + + propagate(table.Owner, 0, 0); + + IntPtr parent = table.Rows; + IntPtr protected40 = IntPtr.Add(table.Rows, 0x2c); + IntPtr grandchild = IntPtr.Add(table.Rows, 2 * 0x2c); + IntPtr protected100 = IntPtr.Add(table.Rows, 3 * 0x2c); + IntPtr sibling = IntPtr.Add(table.Rows, 4 * 0x2c); + IntPtr parentMeshRow = meshRows; + IntPtr bit40MeshRow = IntPtr.Add(meshRows, 0x130); + IntPtr grandchildMeshRow = IntPtr.Add(meshRows, 2 * 0x130); + IntPtr bit100MeshRow = IntPtr.Add(meshRows, 3 * 0x130); + IntPtr siblingMeshRow = IntPtr.Add(meshRows, 4 * 0x130); + Expect(ReadFloat(parent, 0x08) == 25.0f && ReadFloat(parent, 0x0c) == 25.0f && + unchecked((uint)Marshal.ReadInt32(parent, 0x18)) == 3, + "Control 0x11130 updates the parent stage and processed amount first"); + Expect(ReadFloat(protected40, 0x08) == 0.0f && ReadFloat(protected40, 0x14) == 0.0f && + unchecked((uint)Marshal.ReadInt32(protected40, 0x18)) == 0 && + (unchecked((uint)Marshal.ReadInt32(protected40, 0x28)) & 0x50) == 0x50, + "Protected bit 0x40 does not stop child depletion, while its depleted-stage early return remains visible"); + Expect(ReadFloat(grandchild, 0x08) == 0.0f && ReadFloat(grandchild, 0x0c) == 125.0f && + unchecked((uint)Marshal.ReadInt32(grandchild, 0x18)) == 0 && + (unchecked((uint)Marshal.ReadInt32(grandchild, 0x28)) & 0x90) == 0x90, + "Control 0x11130 drains a protected child's descendant but its inherited 0x80 flag preserves the depleted stage snapshot"); + Expect(ReadFloat(protected100, 0x08) == 0.0f && ReadFloat(protected100, 0x0c) == 0.0f && + unchecked((uint)Marshal.ReadInt32(protected100, 0x18)) == 2, + "Protected bit 0x100 does not stop child depletion or its later stage update"); + Expect(ReadFloat(sibling, 0x08) == 0.0f && ReadFloat(sibling, 0x0c) == 0.0f && + unchecked((uint)Marshal.ReadInt32(sibling, 0x18)) == 2 && + (unchecked((uint)Marshal.ReadInt32(sibling, 0x28)) & 0x100) != 0, + "An unprotected sibling retains the native damaged flag while updating its stage"); + Expect(unchecked((uint)Marshal.ReadInt32(parentMeshRow, 0x1c)) == 3 && + unchecked((uint)Marshal.ReadInt32(bit40MeshRow, 0x1c)) == unchecked((uint)-99) && + unchecked((uint)Marshal.ReadInt32(grandchildMeshRow, 0x1c)) == unchecked((uint)-99) && + unchecked((uint)Marshal.ReadInt32(bit100MeshRow, 0x1c)) == 1 && + unchecked((uint)Marshal.ReadInt32(siblingMeshRow, 0x1c)) == 1, + "ANI slot 0x44 reaches native AniMesh RVA 0x5810 for changed visible stages only"); + Expect(controlNodeUpdateCount == 4 && + String.Join(",", controlNodeUpdateIndices.ConvertAll(index => index.ToString()).ToArray()) == "1,2,3,4" && + String.Join(",", controlNodeUpdateFlags.ConvertAll(value => value.ToString("x")).ToArray()) == "42,82,102,102" && + !controlNodeUpdateOwnerMismatch, + "Control 0x11130 traverses descendants depth-first, checking callback owners and protected flags"); + Expect(String.Join(",", aniMeshStageTransitions.ToArray()) == "0:3,3:1,4:1" && + aniMeshNodeLifecycleCallbacks.Count == 0 && + !aniMeshCallbackOwnerMismatch && !nativeAniMeshStageCallbackMissing, + "Control descendant update preserves the native callback order and stage bounds"); + Expect(String.Join(",", controlProviderCallbackTrace.ToArray()) == + "stage:0:3,amount:1,amount:2,amount:3,stage:3:1,amount:4,stage:4:1", + "Control 0x11130 keeps amount, lifecycle, and visual-stage callbacks in native depth-first order"); + Expect(ReadFloat(table.Owner, 0x590) == 25.0f, + "Control 0x10f30 keeps the aggregate amount in sync after recursive child depletion"); + + Console.WriteLine("native-control-parent-propagation: controlHash=" + ExpectedControlSha256 + + " rva=0x11130 childOrder=[1,2,3,4] protected40/100=depleted bit40-stage-return=preserved" + + " callbacks=" + String.Join(",", controlProviderCallbackTrace.ToArray())); + activeControlProviderRows = IntPtr.Zero; + activeAniMeshInterface = IntPtr.Zero; + activeNativeAniMeshStageTransition = null; + activeNativeAniMeshNodeLifecycle = null; + GC.KeepAlive(propagate); + } + } + + private static void RunNativeControlProviderVisibilityCase(IntPtr controlModule, IntPtr aniMeshModule) { + NativeControlProviderStageUpdate updateStage = (NativeControlProviderStageUpdate) + Marshal.GetDelegateForFunctionPointer(IntPtr.Add(controlModule, ControlProviderStageUpdateRva), + typeof(NativeControlProviderStageUpdate)); + NativeAniMeshNodeMetadataQuery queryNode = (NativeAniMeshNodeMetadataQuery) + Marshal.GetDelegateForFunctionPointer(IntPtr.Add(aniMeshModule, AniMeshNodeMetadataQueryRva), + typeof(NativeAniMeshNodeMetadataQuery)); + NativeAniMeshNodeLifecycleCallback updateNodeLifecycle = (NativeAniMeshNodeLifecycleCallback) + Marshal.GetDelegateForFunctionPointer(IntPtr.Add(aniMeshModule, 0x05500), + typeof(NativeAniMeshNodeLifecycleCallback)); + NativeAniMeshStageTransitionCallback setNodeStage = (NativeAniMeshStageTransitionCallback) + Marshal.GetDelegateForFunctionPointer(IntPtr.Add(aniMeshModule, AniMeshNodeStageSetRva), + typeof(NativeAniMeshStageTransitionCallback)); + + using (Fixture fixture = NewFixture()) { + NativeProviderTable table = CreateNativeProviderTable(fixture, controlModule, + new float[] { 13.0f }, new float[] { 13.0f }, new byte[] { 0x00 }); + IntPtr descriptor = Marshal.ReadIntPtr(table.Rows); + Marshal.WriteInt32(descriptor, 0x08, FloatBits(0.03125f)); // source mobility per unit volume + Marshal.WriteInt32(table.Owner, 0x50, 9); // class 9 makes FUN_1000fca0 return after the visibility change + Marshal.WriteInt32(table.Owner, 0x530, FloatBits(100.0f)); + Marshal.WriteInt32(table.Owner, 0x534, FloatBits(200.0f)); + Marshal.WriteInt32(table.Owner, 0x538, FloatBits(300.0f)); + Marshal.WriteInt32(table.Owner, 0x4d8, FloatBits(40.0f)); + WriteProviderStageRow(table.Rows, 0, -1, 13.0f, 13.0f, 0.0f, 0, 3, 0x00); + Marshal.WriteInt32(table.Rows, 0x20, FloatBits(13.0f)); + + IntPtr aniInterface = fixture.Allocate(0x1b0); + IntPtr aniVtable = fixture.Allocate(0x50); + IntPtr meshRows = fixture.Allocate(0x130); + IntPtr nodeData = fixture.Allocate(0x26); + IntPtr slotData = fixture.Allocate(2 * 0x44); + IntPtr meshData = fixture.Allocate(3 * IntPtr.Size); + for (int word = 0; word < 19; word++) Marshal.WriteInt16(nodeData, word * 2, -1); + for (int stage = 0; stage < 3; stage++) + Marshal.WriteInt16(nodeData, 0x08 + stage * 5 * sizeof(ushort), 0); + // State 0,1,2 each expose slot 0; 0x11220 publishes visible stage 2 before 0x11920 queries it. + Marshal.WriteIntPtr(meshData, 0, nodeData); + Marshal.WriteIntPtr(meshData, 2 * IntPtr.Size, slotData); + Marshal.WriteIntPtr(aniInterface, 0, aniVtable); + Marshal.WriteIntPtr(aniInterface, 0x1a8, meshRows); + Marshal.WriteInt32(aniInterface, 0x1ac, 1); + Marshal.WriteInt32(aniInterface, 0x158, FloatBits(2.0f)); + Marshal.WriteInt32(aniInterface, 0x15c, FloatBits(3.0f)); + Marshal.WriteInt32(aniInterface, 0x160, FloatBits(5.0f)); + Marshal.WriteInt32(meshRows, 0x00, 0); // ANI model-instance ID used by FUN_10005780/57c0 + Marshal.WriteInt32(meshRows, 0x1c, 0); // current visible stage selects Node38 slot state 0 + Marshal.WriteIntPtr(meshRows, 0x12c, meshData); + Marshal.WriteInt32(slotData, 0x30, FloatBits(7.0f)); + Marshal.WriteInt32(slotData, 0x34, FloatBits(11.0f)); + Marshal.WriteInt32(slotData, 0x44 + 0x30, FloatBits(17.0f)); + Marshal.WriteInt32(slotData, 0x44 + 0x34, FloatBits(19.0f)); + + // Use the original ANI vtable entries exercised by FUN_10011920: + // node selector F/10, instance lookup/count, lifecycle flags, and visible stage. + activeNativeAniMeshNodeMetadataQuery = queryNode; + Marshal.WriteIntPtr(aniVtable, 0x0c, Marshal.GetFunctionPointerForDelegate(AniMeshNodeMetadataQueryCallback)); + activeNativeAniMeshNodeLifecycle = updateNodeLifecycle; + Marshal.WriteIntPtr(aniVtable, 0x20, Marshal.GetFunctionPointerForDelegate(AniMeshNodeLifecycleCallback)); + Marshal.WriteIntPtr(aniVtable, 0x38, IntPtr.Add(aniMeshModule, 0x05780)); + Marshal.WriteIntPtr(aniVtable, 0x3c, IntPtr.Add(aniMeshModule, 0x057c0)); + activeNativeAniMeshStageTransition = setNodeStage; + Marshal.WriteIntPtr(aniVtable, 0x44, Marshal.GetFunctionPointerForDelegate(AniMeshStageTransitionCallback)); + Marshal.WriteIntPtr(table.Owner, 0x20, aniInterface); + activeAniMeshInterface = aniInterface; + + IntPtr firstValueOut = fixture.Allocate(IntPtr.Size); + IntPtr secondValueOut = fixture.Allocate(IntPtr.Size); + Expect(NativeBoolean(queryNode(aniInterface, 0, 0x0f, firstValueOut)) == 1, + "AniMesh selector F reads the raw slot state through the original getter"); + IntPtr firstValue = Marshal.ReadIntPtr(firstValueOut); + Expect(ReadFloat(firstValue, 0) == 42.0f, + "AniMesh selector F scales slot+0x30 by both XY instance factors"); + Expect(NativeBoolean(queryNode(aniInterface, 0, 0x10, secondValueOut)) == 1, + "AniMesh selector 10 reads the second raw slot field through the original getter"); + IntPtr secondValue = Marshal.ReadIntPtr(secondValueOut); + Expect(firstValue == secondValue && ReadFloat(firstValue, 0) == 330.0f, + "AniMesh selectors F and 10 return the same scratch cell; the second query overwrites the first result"); + + activeControlProviderRows = table.Rows; + aniMeshNodeMetadataQueries.Clear(); + aniMeshNodeLifecycleCallbacks.Clear(); + aniMeshStageTransitions.Clear(); + controlProviderCallbackTrace.Clear(); + aniMeshCallbackOwnerMismatch = false; + nativeAniMeshStageCallbackMissing = false; + // At ratio zero, the native ceiling stage rule selects the depleted sentinel + // and reaches 0x11920's hide branch. Ratio one reopens that node. + updateStage(table.Owner, 0, 0); + IntPtr row = table.Rows; + IntPtr meshRow = meshRows; + Expect(unchecked((uint)Marshal.ReadInt32(row, 0x28)) == 0x220 && + unchecked((uint)Marshal.ReadInt32(row, 0x18)) == 3 && + unchecked((uint)Marshal.ReadInt32(meshRow, 0x14)) == 1 && + unchecked((uint)Marshal.ReadInt32(meshRow, 0x1c)) == 2, + "Control RVA 0x11920 hides an exhausted provider in both Control and the original AniMesh node state"); + Expect(String.Join(",", aniMeshNodeMetadataQueries.ToArray()) == "0:f:0x42280000,0:10:0x43a50000" && + !aniMeshCallbackOwnerMismatch && !nativeAniMeshStageCallbackMissing, + "Control RVA 0x11920 queries the shared AniMesh scratch cell before applying its aggregate changes"); + Console.WriteLine("native-control-provider-hide-values: row20=" + Float(ReadFloat(row, 0x20)) + + " totals=[" + Float(ReadFloat(table.Owner, 0x530)) + "," + Float(ReadFloat(table.Owner, 0x534)) + + "," + Float(ReadFloat(table.Owner, 0x538)) + "," + Float(ReadFloat(table.Owner, 0x4d8)) + + "] queries=[" + String.Join(",", aniMeshNodeMetadataQueries.ToArray()) + "]"); + Expect(ReadFloat(table.Owner, 0x530) == -230.0f && ReadFloat(table.Owner, 0x534) == -130.0f && + ReadFloat(table.Owner, 0x538) == 287.0f && FloatBits(ReadFloat(table.Owner, 0x4d8)) == FloatBits(42.6875f), + "Control RVA 0x11920 removes the aliased AniMesh value from aggregates and applies the volume adjustment"); + + Marshal.WriteInt32(row, 0x14, FloatBits(1.0f)); + updateStage(table.Owner, 0, 0); + Expect(unchecked((uint)Marshal.ReadInt32(row, 0x28)) == 0x200 && + unchecked((uint)Marshal.ReadInt32(row, 0x18)) == 0 && + unchecked((uint)Marshal.ReadInt32(meshRow, 0x14)) == 0 && + unchecked((uint)Marshal.ReadInt32(meshRow, 0x1c)) == 0, + "Control RVA 0x11920 shows the reopened provider and clears both Control and AniMesh visibility flags"); + Expect(ReadFloat(table.Owner, 0x530) == 100.0f && ReadFloat(table.Owner, 0x534) == 200.0f && + ReadFloat(table.Owner, 0x538) == 300.0f && FloatBits(ReadFloat(table.Owner, 0x4d8)) == FloatBits(40.0f), + "Control RVA 0x11920 restores provider aggregates on the paired show transition"); + Expect(String.Join(",", aniMeshNodeMetadataQueries.ToArray()) == + "0:f:0x42280000,0:10:0x43a50000,0:f:0x42280000,0:10:0x43a50000" && + String.Join(",", aniMeshNodeLifecycleCallbacks.ToArray()) == "0:100:1,0:101:5" && + String.Join(",", aniMeshStageTransitions.ToArray()) == "0:2,0:0", + "Native hide/show repeats the same F/10 queries and original AniMesh callbacks in order"); + + // The same native getter follows a new visible state: state 2 now selects + // the second MSH slot while state 0 still selects the first. + Marshal.WriteInt16(nodeData, 0x08 + 2 * 5 * sizeof(ushort), 1); + Marshal.WriteInt32(row, 0x14, FloatBits(0.0f)); + updateStage(table.Owner, 0, 0); + Expect(String.Join(",", aniMeshNodeMetadataQueries.ToArray()) == + "0:f:0x42280000,0:10:0x43a50000,0:f:0x42280000,0:10:0x43a50000," + + "0:f:0x42cc0000,0:10:0x440e8000" && + ReadFloat(table.Owner, 0x530) == -470.0f && ReadFloat(table.Owner, 0x534) == -370.0f && + ReadFloat(table.Owner, 0x538) == 287.0f && FloatBits(ReadFloat(table.Owner, 0x4d8)) == FloatBits(35.1875f), + "Control hide query follows visible state 2 and applies its different native mesh-slot value"); + Marshal.WriteInt32(row, 0x14, FloatBits(1.0f)); + updateStage(table.Owner, 0, 0); + Expect(String.Join(",", aniMeshNodeMetadataQueries.ToArray()) == + "0:f:0x42280000,0:10:0x43a50000,0:f:0x42280000,0:10:0x43a50000," + + "0:f:0x42cc0000,0:10:0x440e8000,0:f:0x42280000,0:10:0x43a50000" && + ReadFloat(table.Owner, 0x530) == -140.0f && ReadFloat(table.Owner, 0x534) == -40.0f && + ReadFloat(table.Owner, 0x538) == 300.0f && FloatBits(ReadFloat(table.Owner, 0x4d8)) == FloatBits(32.5f), + "Control show query returns to visible state 0 rather than reversing the prior state-2 contribution"); + Expect(String.Join(",", controlProviderCallbackTrace.ToArray()) == + "stage:0:2,lifecycle:0:100:1,stage:0:0,lifecycle:0:101:5," + + "stage:0:2,lifecycle:0:100:1,stage:0:0,lifecycle:0:101:5", + "Control and AniMesh visibility transitions preserve native callback order and arguments"); + Expect(!aniMeshCallbackOwnerMismatch && !nativeAniMeshStageCallbackMissing, + "Both visibility cycles preserve AniMesh callback owners and original function results"); + + Console.WriteLine("native-control-provider-visibility: controlHash=" + ExpectedControlSha256 + + " aniMeshHash=" + ExpectedAniMeshSha256 + " rva=0x11920 selectorF/10=same-scratch-cell " + + "visible-state-values=[42,330]=>[102,570] hide/show=stage-dependent"); + activeControlProviderRows = IntPtr.Zero; + activeAniMeshInterface = IntPtr.Zero; + activeNativeAniMeshNodeMetadataQuery = null; + activeNativeAniMeshStageTransition = null; + activeNativeAniMeshNodeLifecycle = null; + GC.KeepAlive(updateStage); + GC.KeepAlive(queryNode); + GC.KeepAlive(updateNodeLifecycle); + GC.KeepAlive(setNodeStage); + GC.KeepAlive(AniMeshNodeLifecycleCallback); + GC.KeepAlive(AniMeshStageTransitionCallback); + } + } + + private static void WriteProviderStageRow(IntPtr rows, int index, int parentIndex, + float amount, float processed, float normalized, uint currentStage, uint stageCount, uint flags) { + IntPtr row = IntPtr.Add(rows, index * 0x2c); + Marshal.WriteInt32(row, 0x04, parentIndex); + Marshal.WriteInt32(row, 0x08, FloatBits(amount)); + Marshal.WriteInt32(row, 0x0c, FloatBits(processed)); + Marshal.WriteInt32(row, 0x14, FloatBits(normalized)); + Marshal.WriteInt32(row, 0x18, unchecked((int)currentStage)); + Marshal.WriteInt32(row, 0x1c, unchecked((int)stageCount)); + Marshal.WriteInt32(row, 0x28, unchecked((int)flags)); + } + private static NativeProviderTable CreateNativeProviderTable(Fixture fixture, IntPtr module, float[] maxima, float[] amounts, byte[] rowFlags) { Expect(maxima.Length == amounts.Length && maxima.Length == rowFlags.Length, @@ -1219,6 +1683,229 @@ internal static class BehaviorDistributorTickOracle { } } + private static void RunNativeAniMeshScaleLoadSnapshot(IntPtr module) { + uint[] actual = new uint[] { + unchecked((uint)Marshal.ReadInt32(IntPtr.Add(module, 0x26068))), + unchecked((uint)Marshal.ReadInt32(IntPtr.Add(module, 0x2606c))), + unchecked((uint)Marshal.ReadInt32(IntPtr.Add(module, 0x26070))) + }; + Expect(actual[0] == 0x3f800000 && actual[1] == 0x3f800000 && actual[2] == 0x3f800000, + "AniMesh module load initializes all three runtime scale globals to 1.0"); + Console.WriteLine("native-anim-mesh-scale-load-snapshot: aniMeshHash=" + ExpectedAniMeshSha256 + + " globals=[" + String.Join(",", Array.ConvertAll(actual, Hex)) + "]"); + } + + private static void RunNativeAniMeshNodeMetadataCases(IntPtr module) { + NativeAniMeshNodeMetadataQuery query = (NativeAniMeshNodeMetadataQuery)Marshal.GetDelegateForFunctionPointer( + IntPtr.Add(module, AniMeshNodeMetadataQueryRva), typeof(NativeAniMeshNodeMetadataQuery)); + NativeAniMeshNodeStageCount stageCount = (NativeAniMeshNodeStageCount)Marshal.GetDelegateForFunctionPointer( + IntPtr.Add(module, AniMeshNodeStageCountRva), typeof(NativeAniMeshNodeStageCount)); + + using (Fixture fixture = new Fixture()) { + IntPtr owner = fixture.Allocate(0x1b0); + IntPtr meshRows = fixture.Allocate(3 * 0x130); + IntPtr nodeData = fixture.Allocate(3 * 0x26); + IntPtr slotData = fixture.Allocate(3 * 0x44); + IntPtr meshData = fixture.Allocate(3 * IntPtr.Size); + IntPtr result = fixture.Allocate(IntPtr.Size); + Marshal.WriteIntPtr(meshData, 0, nodeData); + Marshal.WriteIntPtr(meshData, 2 * IntPtr.Size, slotData); + Marshal.WriteIntPtr(owner, 0x1a8, meshRows); + Marshal.WriteInt32(owner, 0x1ac, 3); + + ushort[] headerFlags = new ushort[] { 0x8201, 0x0180, 0x0400 }; + int[] rawParentIndices = new int[] { 3, 0, 1 }; + int[] runtimeParentIndices = new int[] { -1, 22, 7 }; + for (int nodeIndex = 0; nodeIndex < 3; nodeIndex++) { + IntPtr rawNode = IntPtr.Add(nodeData, nodeIndex * 0x26); + for (int word = 0; word < 19; word++) Marshal.WriteInt16(rawNode, word * 2, -1); + Marshal.WriteInt16(rawNode, 0, unchecked((short)headerFlags[nodeIndex])); + Marshal.WriteInt16(rawNode, 2, unchecked((short)rawParentIndices[nodeIndex])); + + IntPtr meshRow = IntPtr.Add(meshRows, nodeIndex * 0x130); + Marshal.WriteInt32(meshRow, 8, nodeIndex); + Marshal.WriteInt32(meshRow, 0x18, runtimeParentIndices[nodeIndex]); + Marshal.WriteIntPtr(meshRow, 0x12c, meshData); + } + + // Node 0: state0 present, state1 absent, state2 present. Native + // GetStateCount stops at the first missing state, so it returns 1. + WriteNode38Slot(nodeData, 0, 0, 0); + WriteNode38Slot(nodeData, 0, 2, 2); + // Node 1: the prefix is empty even though later states are present. + WriteNode38Slot(nodeData, 1, 1, 1); + WriteNode38Slot(nodeData, 1, 2, 2); + // Node 2: all three consecutive state slots are present. + WriteNode38Slot(nodeData, 2, 0, 0); + WriteNode38Slot(nodeData, 2, 1, 1); + WriteNode38Slot(nodeData, 2, 2, 2); + + for (uint nodeIndex = 0; nodeIndex < 3; nodeIndex++) { + Marshal.WriteIntPtr(result, IntPtr.Zero); + Expect(NativeBoolean(query(owner, nodeIndex, 0x0d, result)) == 1, + "AniMesh selector D returns runtime parent metadata"); + IntPtr parent = Marshal.ReadIntPtr(result); + Expect(runtimeParentIndices[nodeIndex] != rawParentIndices[nodeIndex], + "AniMesh runtime parent fixture differs from the raw Node38 parent"); + Expect(Marshal.ReadInt32(parent) == runtimeParentIndices[nodeIndex], + "AniMesh selector D copies the indexed global runtime parent, not the raw Node38 link"); + + Marshal.WriteIntPtr(result, IntPtr.Zero); + Expect(NativeBoolean(query(owner, nodeIndex, 0x0e, result)) == 1, + "AniMesh selector E returns the Node38 header word"); + IntPtr flags = Marshal.ReadIntPtr(result); + Expect(unchecked((uint)Marshal.ReadInt32(flags)) == headerFlags[nodeIndex], + "AniMesh selector E points to the indexed Node38 hdr0"); + } + + uint[] expectedStageCounts = new uint[] { 1, 0, 3 }; + for (uint nodeIndex = 0; nodeIndex < expectedStageCounts.Length; nodeIndex++) { + Expect(stageCount(owner, nodeIndex) == expectedStageCounts[nodeIndex], + "AniMesh stage count is the consecutive state0-2 prefix"); + } + Console.WriteLine("native-anim-mesh-control-node-metadata: aniMeshHash=" + ExpectedAniMeshSha256 + + " D=runtime-parent E=Node38-hdr0 stage-prefix=[1,0,3]"); + } + GC.KeepAlive(query); + GC.KeepAlive(stageCount); + } + + private static void RunNativeControlProviderInitialStateCase(IntPtr controlModule, IntPtr aniMeshModule) { + const int rowCount = 4; + NativeControlOwnerConstructor constructOwner = (NativeControlOwnerConstructor)Marshal.GetDelegateForFunctionPointer( + IntPtr.Add(controlModule, ControlOwnerConstructorRva), typeof(NativeControlOwnerConstructor)); + NativeControlProviderRowConstructor constructProviderRow = (NativeControlProviderRowConstructor) + Marshal.GetDelegateForFunctionPointer(IntPtr.Add(controlModule, ControlProviderRowConstructorRva), + typeof(NativeControlProviderRowConstructor)); + NativeControlProviderInitialState initialize = (NativeControlProviderInitialState) + Marshal.GetDelegateForFunctionPointer(IntPtr.Add(controlModule, ControlProviderInitialStateRva), + typeof(NativeControlProviderInitialState)); + using (Fixture fixture = NewFixture()) { + IntPtr owner = fixture.Allocate(0x664); + Expect(constructOwner(owner, IntPtr.Zero, 4) == owner, + "Control constructor initializes a synthetic class-4 owner without a host object"); + Expect(unchecked((uint)Marshal.ReadInt32(owner, 0x548)) == 0x3f800000 && + unchecked((uint)Marshal.ReadInt32(owner, 0x660)) == 0x3f800000, + "Control constructor starts both provider getter scale factors at 1.0"); + + IntPtr aniOwner = fixture.Allocate(0x1b0); + IntPtr aniVtable = fixture.Allocate(0x4c); + IntPtr meshRows = fixture.Allocate(rowCount * 0x130); + IntPtr nodeData = fixture.Allocate(rowCount * 0x26); + IntPtr slotData = fixture.Allocate(rowCount * 0x44); + IntPtr meshData = fixture.Allocate(3 * IntPtr.Size); + IntPtr providerRows = fixture.Allocate(rowCount * 0x2c); + Marshal.WriteIntPtr(meshData, 0, nodeData); + Marshal.WriteIntPtr(meshData, 2 * IntPtr.Size, slotData); + Marshal.WriteIntPtr(aniOwner, 0, aniVtable); + Marshal.WriteIntPtr(aniOwner, 0x1a8, meshRows); + Marshal.WriteInt32(aniOwner, 0x1ac, rowCount); + Marshal.WriteIntPtr(aniVtable, 0x0c, IntPtr.Add(aniMeshModule, AniMeshNodeMetadataQueryRva)); + Marshal.WriteIntPtr(aniVtable, 0x34, Marshal.GetFunctionPointerForDelegate(ControlNodeUpdateCallback)); + Marshal.WriteIntPtr(aniVtable, 0x48, IntPtr.Add(aniMeshModule, AniMeshNodeStageCountRva)); + + ushort[] headers = { 0x8201, 0x0180, 0x0400, 0x0001 }; + int[] rawParents = { 3, 0, 1, 0 }; + int[] runtimeParents = { -1, 22, 7, 11 }; + float[] sourceMaxima = { 30.0f, 60.0f, 50.0f, 0.0f }; + for (int nodeIndex = 0; nodeIndex < rowCount; nodeIndex++) { + IntPtr rawNode = IntPtr.Add(nodeData, nodeIndex * 0x26); + for (int word = 0; word < 19; word++) Marshal.WriteInt16(rawNode, word * 2, -1); + Marshal.WriteInt16(rawNode, 0, unchecked((short)headers[nodeIndex])); + Marshal.WriteInt16(rawNode, 2, unchecked((short)rawParents[nodeIndex])); + + IntPtr meshRow = IntPtr.Add(meshRows, nodeIndex * 0x130); + Marshal.WriteInt32(meshRow, 8, nodeIndex); + Marshal.WriteInt32(meshRow, 0x18, runtimeParents[nodeIndex]); + Marshal.WriteIntPtr(meshRow, 0x12c, meshData); + + IntPtr descriptor = fixture.Allocate(0x4c); + Marshal.WriteInt32(descriptor, 0x04, FloatBits(sourceMaxima[nodeIndex])); + constructProviderRow(IntPtr.Add(providerRows, nodeIndex * 0x2c), descriptor); + } + // Stage counts are the consecutive state-0/1/2 prefix; Control + // changes an empty prefix to one for its initial provider row. + WriteNode38Slot(nodeData, 0, 0, 0); + WriteNode38Slot(nodeData, 0, 2, 2); + WriteNode38Slot(nodeData, 1, 1, 1); + WriteNode38Slot(nodeData, 1, 2, 2); + WriteNode38Slot(nodeData, 2, 0, 0); + WriteNode38Slot(nodeData, 2, 1, 1); + WriteNode38Slot(nodeData, 2, 2, 2); + + Marshal.WriteIntPtr(owner, 0x20, aniOwner); + Marshal.WriteIntPtr(owner, 0x55c, providerRows); + Marshal.WriteInt32(owner, 0x560, rowCount); + IntPtr providerVtable = Marshal.ReadIntPtr(IntPtr.Add(owner, 4)); + Expect(providerVtable != IntPtr.Zero && + Marshal.ReadIntPtr(providerVtable, 0x0c) == IntPtr.Add(controlModule, ControlProviderType1GetterRva), + "Control constructor installs the original selector-3 provider vtable"); + + controlNodeUpdateCount = 0; + controlNodeUpdateIndices.Clear(); + initialize(owner); + uint[] expectedFlags = { 0x09, 0x02, 0x04, 0x08 }; + uint[] expectedStages = { 1, 1, 3, 1 }; + for (int nodeIndex = 0; nodeIndex < rowCount; nodeIndex++) { + IntPtr row = IntPtr.Add(providerRows, nodeIndex * 0x2c); + Console.WriteLine("native-control-f940-row=" + nodeIndex + " parent=" + Marshal.ReadInt32(row, 0x04) + + " amount=" + Hex(unchecked((uint)Marshal.ReadInt32(row, 0x08))) + + " processed=" + Hex(unchecked((uint)Marshal.ReadInt32(row, 0x0c))) + + " normalized=" + Hex(unchecked((uint)Marshal.ReadInt32(row, 0x14))) + + " stages=" + Hex(unchecked((uint)Marshal.ReadInt32(row, 0x1c))) + + " flags=" + Hex(unchecked((uint)Marshal.ReadInt32(row, 0x28)))); + uint expectedAmount = unchecked((uint)FloatBits(sourceMaxima[nodeIndex])); + Expect(Marshal.ReadInt32(row, 0x04) == runtimeParents[nodeIndex] && + unchecked((uint)Marshal.ReadInt32(row, 0x08)) == expectedAmount && + unchecked((uint)Marshal.ReadInt32(row, 0x0c)) == expectedAmount && + unchecked((uint)Marshal.ReadInt32(row, 0x14)) == 0x3f800000 && + unchecked((uint)Marshal.ReadInt32(row, 0x1c)) == expectedStages[nodeIndex] && + unchecked((uint)Marshal.ReadInt32(row, 0x28)) == expectedFlags[nodeIndex], + "Control f940 initializes row " + nodeIndex + " from AniMesh metadata and selector-3 amount"); + } + Expect(unchecked((uint)Marshal.ReadInt32(owner, 0x590)) == 0x430c0000 && + unchecked((uint)Marshal.ReadInt32(owner, 0x58c)) == 0x430c0000, + "Control f940 stores the sum of initial row amounts in both provider aggregates"); + Expect(controlNodeUpdateCount == rowCount && + String.Join(",", controlNodeUpdateIndices.ConvertAll(index => index.ToString()).ToArray()) == "0,1,2,3" && + controlNodeUpdateSelector == 0x200 && controlNodeUpdateValueBits == 0x3f800000, + "Control f940 notifies the host once per row in native append order"); + + // Selector 3 is the shared maximum getter. A non-unity owner scale + // exercises its native multiplication before the same initializer. + Marshal.WriteInt32(owner, 0x660, FloatBits(1.5f)); + Marshal.WriteInt32(owner, 0x548, FloatBits(0.5f)); + controlNodeUpdateCount = 0; + controlNodeUpdateIndices.Clear(); + initialize(owner); + uint[] scaledAmounts = { 0x41b40000, 0x42340000, 0x42160000, 0x00000000 }; + for (int nodeIndex = 0; nodeIndex < rowCount; nodeIndex++) { + IntPtr row = IntPtr.Add(providerRows, nodeIndex * 0x2c); + Expect(unchecked((uint)Marshal.ReadInt32(row, 0x08)) == scaledAmounts[nodeIndex] && + unchecked((uint)Marshal.ReadInt32(row, 0x0c)) == scaledAmounts[nodeIndex], + "Control f940 selector-3 scaled amount row " + nodeIndex); + } + Expect(unchecked((uint)Marshal.ReadInt32(owner, 0x590)) == 0x42d20000 && + unchecked((uint)Marshal.ReadInt32(owner, 0x58c)) == 0x42d20000, + "Control f940 aggregates its non-unity selector-3 results"); + Expect(controlNodeUpdateCount == rowCount && + String.Join(",", controlNodeUpdateIndices.ConvertAll(index => index.ToString()).ToArray()) == "0,1,2,3", + "Control f940 retains callback order for non-unity amounts"); + + Console.WriteLine("native-control-provider-initial-state: controlHash=" + ExpectedControlSha256 + + " rva=0xf940 selector3=0xdc40 rows=4 unity=[30,60,50,0] nonunity=[22.5,45,37.5,0]" + + " current=processed=sourceMax*owner660*owner548 ratio=1 parents=[-1,22,7,11]"); + GC.KeepAlive(constructOwner); + GC.KeepAlive(constructProviderRow); + GC.KeepAlive(initialize); + } + } + + private static void WriteNode38Slot(IntPtr nodeData, int nodeIndex, int state, ushort slotIndex) { + int wordIndex = nodeIndex * 19 + 4 + state * 5; + Marshal.WriteInt16(nodeData, wordIndex * 2, unchecked((short)slotIndex)); + } + private static void RunNativeControlIntoOverrideCase(IntPtr module) { NativeControlResourceComponentOverride applyOverride = (NativeControlResourceComponentOverride)Marshal.GetDelegateForFunctionPointer( IntPtr.Add(module, ControlResourceComponentOverrideRva), typeof(NativeControlResourceComponentOverride)); diff --git a/docs/appendices/knowledge-boundaries.md b/docs/appendices/knowledge-boundaries.md index 9e293ba..d4a620f 100644 --- a/docs/appendices/knowledge-boundaries.md +++ b/docs/appendices/knowledge-boundaries.md @@ -323,16 +323,39 @@ sequence определяется NDP: она не дополняется по sidecar недоступен, запрос `0xe00` сообщает это отдельно, оставляя независимые агрегатные selectors `1/2` доступными. +Поля `parent_index`, Control flags и начальный stage count для NDP-строк +проецируются из AniMesh по глобальному ordinal; точные правила, native ABI +векторы и лицензированная root/`EXTO` fixture описаны в +[техническом подразделе](script-vm.md#начальная-msh-часть-строки-provider). +Проверки подтверждают только начальный снимок: сборка runtime parent-ов +остаётся статическим выводом по RVA `AniMesh.dll+0xa460`, а последующие +изменения в полном Control/animation tick-е не проверялись. + +Для provider-строки Rust также хранит одно `initial_amount_bits`. Нативный +`Control.dll` `FUN_1000f940` (RVA `0xf940`) кладёт результат selector `3` в +текущее и обработанное значения строки; при подтверждённых единичных множителях +это raw `max_volume` NDP. Последующее обновление меняет оба native поля, поэтому +снимок не моделирует вместимость или изменяемый Control amount. + Rust query обращается к загруженному объекту и поддерживает `0xe00` только для текущего descriptor tag `26` с factory tag `26`; другие активные typed tags и factory paths остаются явными границами. Этот запрос возвращает начальный -снимок provider amount; дальнейшее изменение строк в Rust не реализовано. -Native oracle проверил изолированные пути распределения, обновления класса `4` -и начальную ветвь таймера. Активную clock-ветвь не запускали; внешний источник -времени и порядок вызовов остаются незакрытыми. Источник контактного коэффициента -прослежен статически, но не исполнен; синтетические provider-строки не имеют -родителей, а родительская логика и lifecycle истощения не проверены. Подробные -векторы и статические границы приведены в +type-1 provider value (`1.0`); дальнейшее изменение provider amount в Rust не +реализовано. +Native oracle проверил изолированные пути распределения, обновления класса `4`, +стадийную арифметику `0x11220`, обход дочерних provider-строк `0x11130` и +visibility transition `0x11920` с исходными AniMesh callbacks. Эти сценарии +используют синтетические NDP/Node38-строки; они подтверждают локальные переходы +и порядок вызовов, но не полную загрузку или выполнение Control на миссии. Вызовы +`0x11220` используют `updateEffects = false`, что исключает ветвь Control FX и +`0x11af0`; в отдельном сценарии класса `9` `0xfca0` возвращается сразу после +смены видимости, поэтому связанное с ним движение не проверено. Хотя у строки +Control выставлен flag `0x102`, слово флагов ANI `+0x14` и производные байты +`+0x111..+0x113` изначально равны нулю. Вызовы AniMesh `0x93c0` и `0xa2a0` обновляют производную геометрию и +видимость, это отдельная непроверенная граница, а не FX callbacks. Активную +clock-ветвь не запускали; внешний источник времени и порядок вызовов в игре +остаются незакрытыми. Источник контактного коэффициента прослежен статически, +но не исполнен. Подробные векторы и статические границы приведены в [техническом подразделе о provider-состоянии Control](script-vm.md#изменение-provider-состояния-control). Отдельный API `advance_loaded_mission_resources` принимает явное время очереди diff --git a/docs/appendices/script-vm.md b/docs/appendices/script-vm.md index a95c031..0f5994b 100644 --- a/docs/appendices/script-vm.md +++ b/docs/appendices/script-vm.md @@ -640,9 +640,170 @@ oracle вызывает оригинальные `FUN_10010ba0` (RVA `0x10ba0`), затем `FMUL` с binary32-константой `0.001` (`0x3a83126f`), после чего результат сохраняется в `f32`. Код вызывает `FUN_10012a40`, затем `FUN_1002d340` и присваивает `+0xec = +0xe4`. В соседней ветви update packet queue обрабатывается -через `FUN_10012ce0`. Источник абсолютного времени извне и полный порядок -вызовов в игре не установлены; эти связи остаются статическим выводом. Rust -продолжает читать начальные provider snapshots и не моделирует эти изменения. +через `FUN_10012ce0`. Активную clock-ветвь oracle не запускал: внешний источник +времени и полный порядок вызовов в игре не установлены. Rust продолжает читать +начальные provider snapshots и не моделирует эти изменения. + +#### Родители, стадии и видимость provider-узлов + +`Control.dll` с SHA-256 +`bcb86318089028548a178b03a21accdce15df0cc85ddd91674cf3c2f55012c6e` проверен +прямыми вызовами исходных `FUN_10011220` (RVA `0x11220`) и +`FUN_10011130` (RVA `0x11130`). При расчёте стадии `FUN_10011220` может взять +долю родителя по флагу `0x04` или стадию родителя по `0x08`. Для стадии с +числом вариантов `count` при проверенных долях `0..1` расчёт имеет вид +`stage = min(count, count - ceil(f32(count * ratio)))`. Нативное ограничение +применяется к результату вычитания как к беззнаковому 32-битному значению; +здесь проверены конечные доли `0..1`. Для отдельного ряда из трёх стадий коэффициенты +`[0.1, 0.4, 0.5, 1, 0]` дали внутренние значения `[2, 1, 1, 0, 3]`; последнее +значение равно служебному sentinel `count` и означает истощение. В callback +`AniMesh.dll!FUN_10005810` передаётся только видимое значение +`min(stage, count - 1)`. + +После перехода родительского ряда `FUN_10011130` находит более поздние строки +с его индексом в поле parent. Обход идёт в глубину: сначала ребёнок и всё его +поддерево, затем следующий ребёнок. Рост стадии или истощение родителя снимает +количество с дочерних строк; защитные флаги `0x40` и `0x100` меняют часть +обработки флагов, но не останавливают снятие количества и обход потомков в +проверенных входах. Нативный тест задал родителя с дочерними рядами, снял их +количество и проверил порядок вызовов и значение stage snapshot. + +Переход между обычной стадией и sentinel `stage == count` вызывает +`Control.dll!FUN_10011920`, только если у строки не установлен флаг `0x02`. +Функция читает геометрию уже выбранной видимой стадии через +`AniMesh.dll!FUN_100051f0`. +Selectors `F` и `10` возвращают одну общую ячейку; второй запрос перезаписывает +значение первого. Это влияет на агрегаты: один синтетический узел при состоянии `0` +давал пару `[42, 330]`, а другой слот для состояния `2` — `[102, 570]`. В одном +тестовом цикле hide/show использовали один и тот же слот, поэтому агрегаты +вернулись к исходным; во втором цикл скрывал состояние `2`, а показывал состояние +`0`, и полученные значения уже не были взаимными противоположностями. Отрицательные +агрегаты во втором векторе — специально выбранные синтетические числа, а не +утверждение о допустимом состоянии игры. + +Эти вызовы исполнены в x86 oracle с Control SHA выше и AniMesh SHA-256 +`65659bf67f20e5be77d67a5b2f59968f61b94293143807fa59ca451c560c4f7e`. Таблицы +NDP, Node38 и объект хоста синтетические; слот lifecycle проходит через исходный +`FUN_10005500`, а переход видимой стадии — через исходный `FUN_10005810`. Вызовы +`FUN_10011220` сделаны с `updateEffects = false`, поэтому ветвь Control FX, +включая `FUN_10011af0`, ими исключена. В отдельном visibility-сценарии класс `9` +заставляет `FUN_1000fca0` вернуться сразу после смены видимости, так что связанное +с ним движение также не проверено. Одна строка Control имеет flags `0x102`, но +слово флагов ANI `+0x14` и производные байты `+0x111..+0x113` изначально равны +нулю; поэтому вызовы +`AniMesh.dll!FUN_100093c0` и `FUN_1000a2a0` (пересчёт производной геометрии и +видимости) не покрыты. Эти результаты подтверждают локальные переходы и порядок +callbacks, но не полный Control update реальной миссии. Активная clock-ветвь, +внешний источник времени и полный игровой порядок вызовов пока не установлены. + +### Начальная MSH-часть строки provider + +`AniMesh.dll` (SHA-256 +`65659bf67f20e5be77d67a5b2f59968f61b94293143807fa59ca451c560c4f7e`) +строит глобальную MSH-таблицу в `FUN_1000a460` (RVA `0xa460`). Для каждого +узла корневой модели добавляется его исходная запись; mounted `EXTO` начинает +с узла `1`; `INTO` в эту таблицу не добавляет. При чтении Node38 поле +`parent_or_link` — это беззнаковое `u16` из байтов `+2`, а не готовый индекс +глобальной таблицы. + +Статические инструкции `0xa474..0xa49f` дают основу родительского индекса. +Для корня база равна нулю; для `EXTO` она равна старому размеру глобальной +таблицы минус один. Само значение трактуется так: + +```text +raw == 0 -> mount_node +raw == 0xffff -> parent_base - 1 +иначе -> parent_base + u32(raw) +``` + +Только `0xffff` служит sentinel-ом: остальные слова, включая `0xfffe`, +прибавляются как беззнаковые `u16`. Для примонтированного `EXTO` с базой `21` +слово `1` даёт parent `22`, а `0xffff` даёт `20`. `mount_node` выбирается из +уже построенной иерархии компонентов. Эта формула восстановлена по машинным +инструкциям загрузчика: `ADD EDI,EAX` в RVA `0xa7e3` прибавляет нормализованное +значение к базе перед записью parent по `0xa7e7`. Это не исполнение полного +загрузочного пути оригинальной игры. + +`Control.dll` (SHA-256 +`bcb86318089028548a178b03a21accdce15df0cc85ddd91674cf3c2f55012c6e`) +`FUN_1000f940` (RVA `0xf940`) получает три поля из AniMesh для того же +глобального ordinal. В x86 ABI oracle оригинального `AniMesh.dll` +`FUN_100051f0` (RVA `0x51f0`) с selector `0x0d` копирует runtime parent из +строки `+0x18` в общий scratch `DAT_10025e88` и возвращает адрес этой копии; +selector `0x0e` так же возвращает копию hdr0 Node38, а не адрес исходной записи. +Тест устанавливает raw parent words `[3, 0, 1]`, но runtime parents `[-1, 22, 7]`, +и проверяет, что selector D читает именно последние. hdr0 `[0x8201, 0x0180, +0x0400]` читается через полный 32-битный результат, поэтому старшие биты не +теряются. + +Control переводит проверенные маски hdr0 в поле строки `+0x28`: + +| Node38 hdr0 | Control bit | +| --- | --- | +| `hdr0 & 0x0200` | `0x01` | +| `hdr0 & 0x0100` | `0x02` | +| `hdr0 & 0x0400` | `0x04` | +| `(hdr0 & 1) != 0 && (hdr0 & 0x0080) == 0` | `0x08` | + +`FUN_10005840` (RVA `0x5840`) возвращает число подряд присутствующих slots +состояний `0..2`: `[present, absent, present] -> 1`, +`[absent, present, present] -> 0`, `[present, present, present] -> 3`. +Пустой префикс в начальной строке Control становится одной доступной стадией, +поэтому Rust хранит `max(1, prefix_length)`. Slot проверяется через штатный +`selected_slot` с `Group(0)` (native LOD0), а не подсчётом всех ненулевых words. + +Runtime временно собирает mesh-состояния в порядке AniMesh, затем сопоставляет +их с уже упорядоченными NDP provider-строками по общему ordinal. Избыточная NDP +строка или отсутствующий MSH asset получают `initial_mesh_state = None`; +совпадение по `(component_index, source_row_index)` не выполняется. Состояние +также не меняет существующий `0xe00` query: он читает начальное type-1 поле +`+0x14` provider-строки, равное `1.0` после нативного конструктора. + +### Начальное количество строки provider + +В `Control.dll` SHA-256 +`bcb86318089028548a178b03a21accdce15df0cc85ddd91674cf3c2f55012c6e` +`FUN_1000f940` (RVA `0xf940`) получает для каждой строки selector `3` через +provider getter `FUN_1000dc40` (RVA `0xdc40`). Getter берёт `max_volume` из +NDP descriptor и последовательно умножает его на поля владельца `+0x660` и +`+0x548`. Конструктор `FUN_10006bf0` (RVA `0x6bf0`) задаёт оба множителя как +`1.0`. Инициализатор записывает результат в поля строки `+0x08` и `+0x0c`, а +type-1 поле `+0x14` остаётся `1.0`. Второе поле не является постоянной +вместимостью: `FUN_10011220` (RVA `0x11220`) копирует туда текущее `+0x08` при +завершении обновления. + +Native oracle вызывает оригинальные `f940`, `dc40`, `b240` и AniMesh getters +`FUN_100051f0`/`FUN_10005840` на тестовой памяти; подменён только callback +владельца. При unity множителях строки с `max_volume` `[30, 60, 50, 0]` +получили начальные количества с теми же битами, включая нулевую строку, а +callback-и пришли в порядке `[0, 1, 2, 3]`. Отдельный прогон с синтетическими +множителями `1.5` и `0.5` подтвердил формулу для этих входов, но не порядок +операций или загрузку игрового объекта; порядок `max_volume * +0x660 * +0x548` +виден в машинных инструкциях getter-а. На начальном пути Unit DAT множители +единичные: `ArealMap.dll` (SHA-256 +`a25f9254ebb339d70e2e07c8121950191e9584ca0858d8e9c2e2b6c671edf6ea`) в RVA +`0x15290` передаёт в `CreateObject` три значения `1.0`. Вызов World3D +`AddObjectToGame` (`World3D.dll`, SHA-256 +`17e4a3089b2583a8cf2356c9db0390b1aba138356a09130d79b4e7e4791da61e`, RVA +`0x7ea0`) не применяет transform scale; отдельный `AddNewObjectToGame` в RVA +`0x8310` имеет ветку установки scale. AniMesh constructor (`AniMesh.dll`, +SHA-256 `65659bf67f20e5be77d67a5b2f59968f61b94293143807fa59ca451c560c4f7e`, +RVA `0x68a0`) читает три DLL scale globals, которые после LoadLibrary в oracle +равны `1.0`. В Rust одна `initial_amount_bits` запись +сохраняет это общее начальное количество; полный update, который меняет +amount и обработанное предыдущее значение, пока не моделируется. + +Licensed full-load regression `full_load_builds_effective_control_device_table_for_mine_unit_dat` +проверяет значения настоящего `min_l_n1.dat`: корневой provider row `0` даёт +`1.0`, а row `1` примонтированного `EXTO` (общий ordinal `22`) даёт `6000.0`. +Проверка использует исходные CTL/NDP/MSH и не делает выводов о динамическом +изменении этих строк. + +Native-часть этих ABI проверок воспроизводит +`behavior_distributor_tick_native_oracle.cs` на синтетически выделенной памяти +и оригинальном DLL с указанным SHA. Она подтверждает getters и layout, но не +создание реальных AniMesh rows при полной загрузке; licensed runtime test +отдельно проверяет реальные Node38 literals root/`EXTO` на `min_l_n1.dat`. ### Аргументы и обратный вызов Handler(30) diff --git a/docs/tomes/06-behavior.md b/docs/tomes/06-behavior.md index 1d32930..0ebbbf7 100644 --- a/docs/tomes/06-behavior.md +++ b/docs/tomes/06-behavior.md @@ -859,12 +859,61 @@ tag-26 ряда получается `1.0` provider × `1.0` coefficient × `1.0 `1.0`. Эти запросы используют начальные provider-значения после конструкторов, а не результаты живого игрового тика. +У Control есть и начальные сведения о модели узла, но их таблица не совпадает +с NDP. Sidecar задаёт состав и порядок provider-строк, а поле type-1 `+0x14` +получает начальное значение `1.0` от нативного конструктора. AniMesh отдельно +собирает глобальный список MSH-узлов. При создании строки Control берёт +mesh-состояние по её порядковому номеру в общей таблице provider, а не пытается +угадать пару по локальному номеру строки sidecar-а. Например, после 22 +корневых строк номер 22 указывает на первый глобальный узел присоединённой +`EXTO`-модели, который +происходит из её локального узла `1`. + +В снимке это необязательное поле: `None` означает, что для данного номера не +удалось получить MSH-узел; исходные запросы к NDP от этого не исчезают. Поэтому +начальное значение и поза модели остаются отдельными частями состояния: + +```rust +initial_mesh_state: Option<MissionControlNodeInitialMeshState> +``` + +Внутри снимка хранятся родительский индекс, переведённые флаги Control и число +начальных стадий. Узлы корневой модели добавляются все, а присоединённая `EXTO` +начинает с локального узла `1`. Это описывает исходную настройку: код пока не +переключает стадии в ходе игры и не исполняет полный Control tick. + +На той же начальной стадии Control вычисляет количество строки по NDP +`max_volume`. Для загрузки Unit DAT проверенные множители равны `1.0`, поэтому +количество совпадает с исходным значением NDP. Оригинал начинает с одинакового +текущего и последнего обработанного количества; Rust сохраняет его один раз как +`initial_amount_bits`. Это исходный снимок, а не неизменяемая вместимость: +позднее Control меняет оба количества. В лицензированном `min_l_n1.dat` +проверены, например, root row `0` со значением `1.0` и строка `EXTO` с local +row `1` в общей позиции `22` со значением `6000.0`. + После загрузки количество в строках может меняться. Контроллер распределяет добавку либо пропорционально свободному месту, либо по очереди: при максимумах `[30, 60, 50]`, текущих значениях `[10, 20, 0]` и добавке `22` первый способ даёт `[14, 28, 10]`. При вычитании последовательный способ начинает с последней строки. Так одна таблица описывает и текущее значение, и то, как оно меняется. +У строк есть и связи с родительскими узлами. Когда стадия родителя меняется, +Control пересчитывает дочерние строки в глубину: ребёнка вместе со всем его +поддеревом, затем следующего ребёнка. Для числа вариантов `count` внутренняя +стадия вычисляется как `count - ceil(f32(count * ratio))`, а видимое значение +ограничивается диапазоном модели. Например, при трёх стадиях доли +`[0.1, 0.4, 0.5, 1, 0]` дали `[2, 1, 1, 0, 3]`; последнее значение — sentinel +истощения, а в модель передаётся индекс не выше `count - 1`. Нативные проверки +подтвердили порядок обхода и передачу состояния в AniMesh. + +Выбранная стадия также задаёт, какие данные MSH попадают в пересчёт видимости. +У одного синтетического узла первый слот давал `[42, 330]`, а слот другой стадии — +`[102, 570]`. В проверенных векторах одинаковые данные при скрытии и повторном +включении восстановили суммы; переходы с разными слотами — нет. Эти проверки +исполняют исходные DLL на тестовых строках, но не являются запуском Control на +полной миссии; Rust пока сохраняет только начальное состояние provider-строк. +Подробные границы приведены в [техническом приложении](../appendices/script-vm.md#родители-стадии-и-видимость-provider-узлов). + Для точного повтора важен порядок округления. При исходных значениях `[2^24, 2]` и запросе `-1` оригинал сначала складывает общий итог с изменением, затем вычитает прежний итог. Из-за округления фактическое изменение получается `-2`. |