aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--crates/fparkan-runtime/src/lib.rs1223
-rw-r--r--crates/fparkan-runtime/tests/behavior_distributor_tick_native_oracle.cs295
-rw-r--r--docs/appendices/knowledge-boundaries.md38
-rw-r--r--docs/tomes/03-resources.md11
-rw-r--r--docs/tomes/06-behavior.md45
5 files changed, 1588 insertions, 24 deletions
diff --git a/crates/fparkan-runtime/src/lib.rs b/crates/fparkan-runtime/src/lib.rs
index baba3b3..a4985a6 100644
--- a/crates/fparkan-runtime/src/lib.rs
+++ b/crates/fparkan-runtime/src/lib.rs
@@ -6,15 +6,17 @@ use fparkan_assets::{
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,
+ MissionTerrainPaths, NresError, PreparedComponentControl, PreparedControlEffectSection,
+ 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,
@@ -149,6 +151,101 @@ pub struct BehaviorOreState {
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>,
+ /// 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,
+}
+
+/// 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,
+}
+
/// Resource distributor state associated with one TMA clan's constructed AI.
#[derive(Clone, Debug, PartialEq)]
pub struct BehaviorDistributorState {
@@ -163,6 +260,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)]
@@ -480,6 +579,7 @@ struct LoadedMissionState {
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>,
@@ -1079,6 +1179,35 @@ fn load_mission_with_options(
Vec::new()
};
+ let control_device_tables = if options.asset_scope == MissionAssetScope::Full {
+ object_drafts
+ .iter()
+ .zip(&handles)
+ .enumerate()
+ .map(
+ |(object_index, (draft, handle))| MissionControlDeviceTableState {
+ original_id: draft.original_id,
+ handle: *handle,
+ status: build_control_device_table(
+ object_index,
+ draft,
+ &mission_assets,
+ prototype_graph
+ .root_prototype_request_spans
+ .get(object_index),
+ &resolved_prototypes,
+ )
+ .map_or_else(
+ MissionControlDeviceTableStatus::Unavailable,
+ MissionControlDeviceTableStatus::Available,
+ ),
+ },
+ )
+ .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");
@@ -1155,6 +1284,7 @@ fn load_mission_with_options(
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,
@@ -1446,6 +1576,17 @@ pub fn loaded_mission_behavior_ore_states(engine: &Engine) -> Option<&[BehaviorO
.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())
+}
+
fn behavior_clan_for_selector(
selector: u32,
clan_count: usize,
@@ -1494,6 +1635,491 @@ fn initialize_behavior_ore_state(
}
}
+#[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_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,
+ 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>) {
+ let flags = match factory_tag {
+ 1 | 4 => 0x200,
+ 5 | 8 | 26 => 0x5,
+ 10 => 0x2000,
+ 17 | 19 => 0x20,
+ _ => return (None, None),
+ };
+ (Some(0x3f80_0000), Some(flags))
+}
+
+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> {
+ 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 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);
+ 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 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 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 mount_node = if is_ex_to {
+ 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)),
+ )
+ })
+ } else {
+ None
+ };
+ 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(devices)
+}
+
fn add_behavior_registered_object(
distributor: &mut BehaviorDistributorState,
mut object: BehaviorRegisteredObject,
@@ -1867,7 +2493,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 {
@@ -1887,6 +2513,171 @@ 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_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()),
+ point_resource: None,
+ node_data_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,
+ )
+ }
+
#[test]
fn native_basement_mode_uses_unit_header_gate_not_builds_path() {
assert_eq!(
@@ -2090,6 +2881,428 @@ 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_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 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.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))
+ );
+ 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!(
+ (
+ 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);
+ }
+
+ #[test]
fn script_varset_prefers_bundle_adjacent_file_then_uses_shared_fallback() {
let mut personal_files = MemoryVfs::default();
personal_files.insert(
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 d2e5bb9..5f5f139 100644
--- a/crates/fparkan-runtime/tests/behavior_distributor_tick_native_oracle.cs
+++ b/crates/fparkan-runtime/tests/behavior_distributor_tick_native_oracle.cs
@@ -5,10 +5,9 @@ using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Text;
-// Calls the original x86 Behavior.dll distributor Add, normalize, indexed resource
-// property, and tick paths against synthetic storage. Only GetSystemArealMap and the
-// bounded vector backing are substituted; Behavior's corresponding instructions
-// remain the installed DLL.
+// Calls selected original x86 Behavior.dll, ArealMap.dll, and Control.dll paths
+// against synthetic storage. Only host callbacks, GetSystemArealMap, and bounded
+// vector backing are substituted; the tested module instructions remain installed code.
internal static class BehaviorDistributorTickOracle {
private const uint LoadWithAlteredSearchPath = 0x00000008;
private const uint MemCommitReserve = 0x00003000;
@@ -17,6 +16,7 @@ internal static class BehaviorDistributorTickOracle {
private const uint PageReadWrite = 0x04;
private const string ExpectedBehaviorSha256 = "ddfbdbde07832358fe6e35e01c8dba9b58e7313789498b6049ed51d4ed9baf99";
private const string ExpectedControlSha256 = "bcb86318089028548a178b03a21accdce15df0cc85ddd91674cf3c2f55012c6e";
+ private const string ExpectedArealMapSha256 = "a25f9254ebb339d70e2e07c8121950191e9584ca0858d8e9c2e2b6c671edf6ea";
private const int TickRva = 0x19e80;
private const int AddObjectRva = 0x1aac0;
private const int NormalizeRva = 0x1ac90;
@@ -27,6 +27,20 @@ internal static class BehaviorDistributorTickOracle {
private const int ControlResourceDeviceGetterRva = 0x21d00;
private const int ControlProviderInterfaceVtableRva = 0x3d254;
private const int ControlProviderType1GetterRva = 0x0dc40;
+ private const int ArealMapUnitDatComponentBuilderRva = 0x14b90;
+ private const int ControlResourceDeviceConstructorRva = 0x22980;
+ private const int ControlResourceComponentOverrideRva = 0x2d890;
+ private const int ControlResourceCommonSetterRva = 0x21d50;
+ private const int ControlResourceTag9ConstructorRva = 0x25460;
+ private const int ControlResourceTag15ConstructorRva = 0x22ae0;
+ private const int ControlResourceTag25ConstructorRva = 0x20800;
+ private const int ControlResourceTag9VtableRva = 0x3c938;
+ private const int ControlResourceTag15VtableRva = 0x3c648;
+ private const int ControlResourceTag25VtableRva = 0x3c448;
+ private const int ControlResourceTag9StringPairRva = 0x25600;
+ private const int ControlResourceNoOpStringPairRva = 0x0bcd0;
+ private const int ControlResourceTag19VtableRva = 0x3c608;
+ private const int ControlResourceTag19StringPairNoOpRva = 0x0bcd0;
private const uint ResourceProperty = 0x02000100;
private static Fixture active;
@@ -57,6 +71,10 @@ internal static class BehaviorDistributorTickOracle {
[UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate int IndexedPropertyGet(IntPtr self, uint index, IntPtr resultBits);
[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeOreInitialization(IntPtr self);
[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.ThisCall)] private delegate IntPtr NativeControlResourceDeviceConstructor(IntPtr self);
+ [UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeControlResourceComponentOverride(IntPtr self, int deviceIndex, IntPtr typedRecord);
private static readonly AreaMapGetter AreaMapGetterCallback = GetAreaMap;
private static readonly VectorInsert VectorInsertCallback = InsertVector;
@@ -69,6 +87,8 @@ internal static class BehaviorDistributorTickOracle {
private static readonly ObjectSetProperty ObjectSetPropertyCallback = SetProperty;
private static readonly InterfaceGetProperty InterfaceGetCallback = GetInterfaceProperty;
private static readonly InterfaceSetProperty InterfaceSetCallback = SetInterfaceProperty;
+ private static readonly NativeArealMapEvent ArealMapEventCallback = OnArealMapEvent;
+ private static ArealMapFixture activeArealMap;
private static IntPtr fastcallThunks;
private static IntPtr queryObjectThunk;
private static IntPtr getInterfacePropertyThunk;
@@ -183,7 +203,77 @@ internal static class BehaviorDistributorTickOracle {
}
}
+ private sealed class ComponentNode {
+ public readonly string ArchiveName;
+ public readonly string ResourceName;
+ public readonly uint Kind;
+ public readonly uint LocalIndex;
+ public readonly ComponentNode[] Children;
+ public ComponentNode(string archiveName, string resourceName, uint kind, uint localIndex, params ComponentNode[] children) {
+ ArchiveName = archiveName;
+ ResourceName = resourceName;
+ Kind = kind;
+ LocalIndex = localIndex;
+ Children = children ?? new ComponentNode[0];
+ }
+ }
+
+ private sealed class CapturedComponentDescriptor {
+ public string ArchiveName;
+ public string ResourceName;
+ public uint ParentId;
+ public uint LocalIndex;
+ public uint AssignedIdBeforeCallback;
+ public uint AssignedId;
+ public uint Message;
+ public uint Subcode;
+ }
+
+ private sealed class ArealMapFixture : IDisposable {
+ public IntPtr Owner;
+ public IntPtr OwnerVtable;
+ public readonly List<IntPtr> Allocations = new List<IntPtr>();
+ public readonly List<CapturedComponentDescriptor> Descriptors = new List<CapturedComponentDescriptor>();
+ public readonly uint[] AssignedIds = new uint[] { 41, 113, 127, 179 };
+ public string CallbackError;
+ public IntPtr Allocate(int size) {
+ IntPtr value = Marshal.AllocHGlobal(size);
+ Zero(value, size);
+ Allocations.Add(value);
+ return value;
+ }
+ public void Dispose() {
+ activeArealMap = null;
+ for (int i = Allocations.Count - 1; i >= 0; i--) Marshal.FreeHGlobal(Allocations[i]);
+ Allocations.Clear();
+ }
+ }
+
private static IntPtr GetAreaMap() { return active.Manager; }
+ private static int OnArealMapEvent(IntPtr owner, uint message, uint subcode, IntPtr descriptor) {
+ ArealMapFixture fixture = activeArealMap;
+ if (fixture == null) return 0;
+ if (owner != fixture.Owner) fixture.CallbackError = "ArealMap callback received an unexpected owner";
+ if (descriptor == IntPtr.Zero) {
+ fixture.CallbackError = "ArealMap callback received a null descriptor";
+ return 0;
+ }
+ int ordinal = fixture.Descriptors.Count;
+ uint assignedId = ordinal < fixture.AssignedIds.Length ? fixture.AssignedIds[ordinal] : 0xfffffff0u;
+ CapturedComponentDescriptor captured = new CapturedComponentDescriptor();
+ captured.ArchiveName = Marshal.PtrToStringAnsi(descriptor);
+ captured.ResourceName = Marshal.PtrToStringAnsi(IntPtr.Add(descriptor, 0x20));
+ captured.ParentId = unchecked((uint)Marshal.ReadInt32(descriptor, 0x40));
+ captured.LocalIndex = unchecked((uint)Marshal.ReadInt32(descriptor, 0x44));
+ captured.AssignedIdBeforeCallback = unchecked((uint)Marshal.ReadInt32(descriptor, 0x48));
+ captured.AssignedId = assignedId;
+ captured.Message = message;
+ captured.Subcode = subcode;
+ fixture.Descriptors.Add(captured);
+ Marshal.WriteInt32(descriptor, 0x48, unchecked((int)assignedId));
+ return 1;
+ }
+
private static void InsertVector(IntPtr self, IntPtr source, uint count, uint position) {
int length = Marshal.ReadInt32(self, 4);
int capacity = Marshal.ReadInt32(self, 8);
@@ -311,11 +401,40 @@ internal static class BehaviorDistributorTickOracle {
private static int Main() {
if (IntPtr.Size != 4) { Console.Error.WriteLine("Build with /platform:x86."); return 2; }
+ return RunWithIsolatedWorkingDirectory();
+ }
+
+ private static int RunWithIsolatedWorkingDirectory() {
+ string originalDirectory = Environment.CurrentDirectory;
+ string tempRoot = Path.GetFullPath(Path.GetTempPath()).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+ string workDirectory = Path.Combine(tempRoot, "fparkan-native-oracle-" + Guid.NewGuid().ToString("N"));
+ Directory.CreateDirectory(workDirectory);
+ try {
+ // ArealMap.dll runs its attach initializer on load; keep any relative log output out of the workspace and game directory.
+ Environment.CurrentDirectory = workDirectory;
+ return RunOracle();
+ } finally {
+ Environment.CurrentDirectory = originalDirectory;
+ string fullWorkDirectory = Path.GetFullPath(workDirectory);
+ if (!String.Equals(fullWorkDirectory, workDirectory, StringComparison.OrdinalIgnoreCase) ||
+ !String.Equals(Path.GetDirectoryName(fullWorkDirectory), tempRoot, StringComparison.OrdinalIgnoreCase) ||
+ !Path.GetFileName(fullWorkDirectory).StartsWith("fparkan-native-oracle-", StringComparison.Ordinal))
+ throw new InvalidOperationException("refusing to remove an unexpected native oracle working directory");
+ if (Directory.Exists(fullWorkDirectory)) Directory.Delete(fullWorkDirectory, true);
+ }
+ }
+
+ private static int RunOracle() {
string controlPath = Environment.GetEnvironmentVariable("FPARKAN_ORIGINAL_CONTROL_DLL");
if (String.IsNullOrEmpty(controlPath)) controlPath = @"C:\GOG Games\Parkan - Iron Strategy\Control.dll";
if (!File.Exists(controlPath)) { Console.Error.WriteLine("Set FPARKAN_ORIGINAL_CONTROL_DLL to the installed Control.dll."); return 7; }
string controlHash = Hash(controlPath);
if (controlHash != ExpectedControlSha256) { Console.Error.WriteLine("Unexpected Control.dll SHA-256: " + controlHash); return 8; }
+ string arealMapPath = Environment.GetEnvironmentVariable("FPARKAN_ORIGINAL_AREALMAP_DLL");
+ if (String.IsNullOrEmpty(arealMapPath)) arealMapPath = @"C:\GOG Games\Parkan - Iron Strategy\ArealMap.dll";
+ 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; }
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");
@@ -325,6 +444,11 @@ internal static class BehaviorDistributorTickOracle {
if (hash != ExpectedBehaviorSha256) { Console.Error.WriteLine("Unexpected Behavior.dll SHA-256: " + hash); FreeLibrary(controlModule); return 4; }
IntPtr module = LoadLibraryEx(path, IntPtr.Zero, LoadWithAlteredSearchPath);
if (module == IntPtr.Zero) { Console.Error.WriteLine("LoadLibraryEx(Behavior.dll) failed: " + Marshal.GetLastWin32Error()); FreeLibrary(controlModule); return 5; }
+ IntPtr arealMapModule = LoadLibraryEx(arealMapPath, IntPtr.Zero, LoadWithAlteredSearchPath);
+ if (arealMapModule == IntPtr.Zero) {
+ Console.Error.WriteLine("LoadLibraryEx(ArealMap.dll) failed: " + Marshal.GetLastWin32Error());
+ FreeLibrary(module); FreeLibrary(controlModule); return 12;
+ }
IntPtr import = IntPtr.Add(module, GetSystemArealMapIatRva);
IntPtr originalImport = Marshal.ReadIntPtr(import);
uint oldProtection = 0;
@@ -346,8 +470,8 @@ internal static class BehaviorDistributorTickOracle {
throw new InvalidOperationException("VirtualProtect(GetSystemArealMap IAT) failed: " + Marshal.GetLastWin32Error());
protectionChanged = true;
Marshal.WriteIntPtr(import, Marshal.GetFunctionPointerForDelegate(AreaMapGetterCallback));
- RunSmokeCases(module, controlModule);
- Console.WriteLine("original Behavior.dll distributor oracle passed (native Add 0x1aac0, normalize 0x1ac90, tick 0x19e80; only GetSystemArealMap IAT and bounded vector insertion are substituted; this does not compare Rust parity).");
+ RunSmokeCases(module, controlModule, arealMapModule);
+ Console.WriteLine("original native Behavior/ArealMap/Control oracle passed (Behavior Add 0x1aac0, normalize 0x1ac90, tick 0x19e80; ArealMap UnitDAT projection 0x14b90; Control INTO override 0x2d890; only synthetic host callbacks, GetSystemArealMap IAT, and bounded vector insertion are substituted; this does not compare Rust parity).");
return 0;
}
catch (Exception error) {
@@ -365,15 +489,17 @@ internal static class BehaviorDistributorTickOracle {
GC.KeepAlive(ObjectQueryCallback); GC.KeepAlive(ObjectRateCallback);
GC.KeepAlive(ObjectGetPropertyCallback); GC.KeepAlive(ObjectSetPropertyCallback);
GC.KeepAlive(InterfaceGetCallback); GC.KeepAlive(InterfaceSetCallback);
+ GC.KeepAlive(ArealMapEventCallback);
if (thunksAllocated && !VirtualFree(fastcallThunks, UIntPtr.Zero, MemRelease))
throw new InvalidOperationException("VirtualFree(fastcall callback thunks) failed: " + Marshal.GetLastWin32Error());
if (x87ControlWordCell != IntPtr.Zero) { Marshal.FreeHGlobal(x87ControlWordCell); x87ControlWordCell = IntPtr.Zero; }
+ FreeLibrary(arealMapModule);
FreeLibrary(module);
FreeLibrary(controlModule);
}
}
- private static void RunSmokeCases(IntPtr module, IntPtr controlModule) {
+ private static void RunSmokeCases(IntPtr module, IntPtr controlModule, IntPtr arealMapModule) {
ushort savedControlWord = CurrentX87ControlWord();
Console.WriteLine("x87-control-word-before=0x" + savedControlWord.ToString("x4") + " (x86 oracle process)");
try {
@@ -381,6 +507,8 @@ internal static class BehaviorDistributorTickOracle {
Console.WriteLine("native-add-normalize-x87-control-word=0x" + CurrentX87ControlWord().ToString("x4"));
RunNativeAddCases(module);
RunNativeNormalizeCases(module);
+ RunNativeArealMapComponentBuilderCase(arealMapModule);
+ RunNativeControlIntoOverrideCase(controlModule);
RunNativeControlResourceDeviceCase(controlModule);
} finally {
SetX87ControlWord(savedControlWord);
@@ -461,6 +589,150 @@ internal static class BehaviorDistributorTickOracle {
}
}
+ private static void RunNativeArealMapComponentBuilderCase(IntPtr module) {
+ using (ArealMapFixture fixture = new ArealMapFixture()) {
+ fixture.OwnerVtable = fixture.Allocate(0x40);
+ fixture.Owner = fixture.Allocate(4);
+ Marshal.WriteIntPtr(fixture.Owner, 0, fixture.OwnerVtable);
+ Marshal.WriteIntPtr(fixture.OwnerVtable, 0x34, Marshal.GetFunctionPointerForDelegate(ArealMapEventCallback));
+
+ ComponentNode tree = new ComponentNode("objects.rlb", "i_pws_f_df", 1, 9,
+ new ComponentNode("objects.rlb", "nested-slot", 1, 5,
+ new ComponentNode("objects.rlb", "nested-child", 1, 12)),
+ new ComponentNode("objects.rlb", "zero-kind-parent", 0, 77,
+ new ComponentNode("objects.rlb", "skipped-descendant", 1, 88)),
+ new ComponentNode("objects.rlb", "later-sibling", 1, 3));
+ IntPtr rootNode = fixture.Allocate(0x78);
+ PopulateUnitDatNode(fixture, rootNode, tree);
+
+ NativeFastcallComponentBuilder build = (NativeFastcallComponentBuilder)Marshal.GetDelegateForFunctionPointer(
+ WriteStdCallToFastcallThunk(0x180, IntPtr.Add(module, ArealMapUnitDatComponentBuilderRva)),
+ typeof(NativeFastcallComponentBuilder));
+ activeArealMap = fixture;
+ build(fixture.Owner, rootNode, 0);
+
+ Expect(fixture.CallbackError == null, "ArealMap descriptor callback owner and pointer");
+ Expect(fixture.Descriptors.Count == 4, "raw kind zero skips its node and descendants while later siblings continue");
+ string[] expectedResources = new string[] { "i_pws_f_df", "nested-slot", "nested-child", "later-sibling" };
+ uint[] expectedParents = new uint[] { 0, 41, 113, 41 };
+ uint[] expectedIndices = new uint[] { 9, 5, 12, 3 };
+ uint[] expectedAssignedIds = new uint[] { 41, 113, 127, 179 };
+ for (int i = 0; i < fixture.Descriptors.Count; i++) {
+ CapturedComponentDescriptor descriptor = fixture.Descriptors[i];
+ Expect(descriptor.ArchiveName == "objects.rlb" && descriptor.ResourceName == expectedResources[i] &&
+ descriptor.ParentId == expectedParents[i] && descriptor.LocalIndex == expectedIndices[i] &&
+ descriptor.AssignedIdBeforeCallback == 0xffffffff && descriptor.AssignedId == expectedAssignedIds[i] &&
+ descriptor.Message == 6 && descriptor.Subcode == 0x80000020,
+ "ArealMap descriptor " + i + " fields and callback-assigned parent ID");
+ }
+ Console.WriteLine("native-arealmap-unitdat-components: events=" + fixture.Descriptors.Count + " archive=objects.rlb" +
+ " parentIds=[" + String.Join(",", Array.ConvertAll(fixture.Descriptors.ToArray(), d => d.ParentId.ToString())) +
+ "] localIndices=[" + String.Join(",", Array.ConvertAll(fixture.Descriptors.ToArray(), d => d.LocalIndex.ToString())) +
+ "]; kind0-subtree=skipped sparse-assigned-ids=propagated");
+ GC.KeepAlive(build);
+ }
+ }
+
+ private static void RunNativeControlIntoOverrideCase(IntPtr module) {
+ NativeControlResourceComponentOverride applyOverride = (NativeControlResourceComponentOverride)Marshal.GetDelegateForFunctionPointer(
+ IntPtr.Add(module, ControlResourceComponentOverrideRva), typeof(NativeControlResourceComponentOverride));
+ RunNativeControlOverrideReceiverCase(module, 19, 0x94, ControlResourceDeviceConstructorRva,
+ ControlResourceTag19VtableRva, ControlResourceTag19StringPairNoOpRva, applyOverride);
+ RunNativeControlOverrideReceiverCase(module, 9, 0x120, ControlResourceTag9ConstructorRva,
+ ControlResourceTag9VtableRva, ControlResourceTag9StringPairRva, applyOverride);
+ RunNativeControlOverrideReceiverCase(module, 15, 0x98, ControlResourceTag15ConstructorRva,
+ ControlResourceTag15VtableRva, ControlResourceNoOpStringPairRva, applyOverride);
+ RunNativeControlOverrideReceiverCase(module, 25, 0xa4, ControlResourceTag25ConstructorRva,
+ ControlResourceTag25VtableRva, ControlResourceNoOpStringPairRva, applyOverride);
+ GC.KeepAlive(applyOverride);
+ }
+
+ private static void RunNativeControlOverrideReceiverCase(IntPtr module, int tag, int objectSize,
+ int constructorRva, int vtableRva, int stringPairRva,
+ NativeControlResourceComponentOverride applyOverride) {
+ NativeControlResourceDeviceConstructor construct = (NativeControlResourceDeviceConstructor)Marshal.GetDelegateForFunctionPointer(
+ IntPtr.Add(module, constructorRva), typeof(NativeControlResourceDeviceConstructor));
+ IntPtr expectedVtable = IntPtr.Add(module, vtableRva);
+ Expect(Marshal.ReadIntPtr(expectedVtable, 0x1c) == IntPtr.Add(module, ControlResourceCommonSetterRva),
+ "tag-" + tag + " vtable common setter slot resolves to native RVA 0x21d50");
+ Expect(Marshal.ReadIntPtr(expectedVtable, 0x24) == IntPtr.Add(module, stringPairRva),
+ "tag-" + tag + " vtable string-pair slot matches its native callback");
+ using (Fixture fixture = NewFixture()) {
+ IntPtr owner = fixture.Allocate(0x5c4);
+ IntPtr deviceArray = fixture.Allocate(IntPtr.Size);
+ IntPtr targetDevice = fixture.Allocate(objectSize);
+ IntPtr typedRecord = fixture.Allocate(0xb4);
+ Expect(construct(targetDevice) == targetDevice,
+ "native tag-" + tag + " constructor returns its exact-size device object");
+ Marshal.WriteIntPtr(deviceArray, 0, targetDevice);
+ Marshal.WriteIntPtr(owner, 0x5bc, deviceArray);
+ Marshal.WriteInt32(owner, 0x5c0, 1);
+
+ Marshal.WriteInt32(targetDevice, 0x04, unchecked((int)0x22222222));
+ Marshal.WriteInt32(targetDevice, 0x08, unchecked((int)0x12345678)); // component ID
+ Marshal.WriteInt32(targetDevice, 0x4c, unchecked((int)0x40200000)); // multiplier 2.5
+ for (int i = 0; i < 16; i++) {
+ Marshal.WriteInt32(targetDevice, 0x54 + i * 4, unchecked((int)(0xb2000000u + (uint)i)));
+ Marshal.WriteInt32(typedRecord, 0x2c + i * 4, unchecked((int)(0xc3000000u + (uint)i)));
+ }
+ Marshal.WriteInt32(typedRecord, 0x00, 19);
+ Marshal.WriteInt32(typedRecord, 0x04, unchecked((int)0x77777777)); // differs from the existing device key
+ Marshal.WriteInt32(typedRecord, 0x18, -1); // preserve the current class field
+ Marshal.WriteInt32(typedRecord, 0xac, 0); // no map rows or auxiliary string tail
+ if (tag == 9) {
+ // This synthetic receiver has no FX host and the descriptor has no map rows.
+ Marshal.WriteIntPtr(targetDevice, 0x3c, IntPtr.Zero);
+ }
+ int priorWord50 = Marshal.ReadInt32(targetDevice, 0x50);
+
+ IntPtr result = applyOverride(owner, 0, typedRecord);
+ Expect(result == IntPtr.Add(typedRecord, 0xb4),
+ "Control indexed override completes one tag-" + tag + " typed record");
+ Expect(Marshal.ReadInt32(owner, 0x5c0) == 1 && Marshal.ReadIntPtr(owner, 0x5bc) == deviceArray &&
+ Marshal.ReadIntPtr(deviceArray, 0) == targetDevice,
+ "Control INTO override keeps the existing tag-" + tag + " device slot and count");
+ Expect(Marshal.ReadIntPtr(targetDevice, 0) == expectedVtable &&
+ unchecked((uint)Marshal.ReadInt32(targetDevice, 0x04)) == 0x22222222 &&
+ unchecked((uint)Marshal.ReadInt32(targetDevice, 0x08)) == 0x12345678 &&
+ unchecked((uint)Marshal.ReadInt32(targetDevice, 0x4c)) == 0x40200000 &&
+ Marshal.ReadInt32(targetDevice, 0x50) == priorWord50 &&
+ Marshal.ReadIntPtr(targetDevice, 0x48) == typedRecord,
+ "selected tag-" + tag + " device retains class, existing key, component ID, multiplier, word +0x50, and records the replacement descriptor");
+ if (tag == 9)
+ Expect(Marshal.ReadIntPtr(targetDevice, 0x3c) == IntPtr.Zero,
+ "tag-9 string callback runs with no FX host on the synthetic receiver");
+ for (int i = 0; i < 16; i++) {
+ Expect(unchecked((uint)Marshal.ReadInt32(targetDevice, 0x54 + i * 4)) == 0xc3000000u + (uint)i,
+ "Control replaces selected tag-" + tag + " device coefficient " + i);
+ }
+ Console.WriteLine("native-control-tag" + tag + "-into-override: size=0x" + objectSize.ToString("x") +
+ " index=0 count=1 key=22222222 component=12345678 multiplier=" +
+ Float(unchecked((uint)Marshal.ReadInt32(targetDevice, 0x4c))) +
+ " original-class=preserved descriptor=attached coefficients=replaced");
+ GC.KeepAlive(construct);
+ }
+ }
+
+ private static void PopulateUnitDatNode(ArealMapFixture fixture, IntPtr destination, ComponentNode node) {
+ Zero(destination, 0x78);
+ Marshal.WriteInt32(destination, 0x04, node.Children.Length);
+ Marshal.WriteInt32(destination, 0x4c, unchecked((int)node.Kind));
+ Marshal.WriteInt32(destination, 0x50, unchecked((int)node.LocalIndex));
+ WriteFixedAnsi(destination, 0x0c, node.ArchiveName, 0x20);
+ WriteFixedAnsi(destination, 0x2c, node.ResourceName, 0x20);
+ if (node.Children.Length == 0) return;
+ IntPtr children = fixture.Allocate(node.Children.Length * 0x78);
+ Marshal.WriteIntPtr(destination, 0x08, children);
+ for (int i = 0; i < node.Children.Length; i++)
+ PopulateUnitDatNode(fixture, IntPtr.Add(children, i * 0x78), node.Children[i]);
+ }
+
+ private static void WriteFixedAnsi(IntPtr destination, int offset, string value, int capacity) {
+ byte[] bytes = Encoding.ASCII.GetBytes(value + "\0");
+ if (bytes.Length > capacity) throw new InvalidOperationException("synthetic UnitDAT string exceeds native field");
+ Marshal.Copy(bytes, 0, IntPtr.Add(destination, offset), bytes.Length);
+ }
+
private static void ExpectControlResourceDeviceResult(
NativeControlResourceDeviceGet getter,
IntPtr device,
@@ -966,6 +1238,15 @@ internal static class BehaviorDistributorTickOracle {
Marshal.Copy(code, 0, thunk, code.Length);
return thunk;
}
+ private static IntPtr WriteStdCallToFastcallThunk(int offset, IntPtr fastcallTarget) {
+ // Adapt stdcall(owner, node, parent ID) to the native __fastcall entry.
+ byte[] code = { 0x8b, 0x4c, 0x24, 0x04, 0x8b, 0x54, 0x24, 0x08, 0xff, 0x74, 0x24, 0x0c,
+ 0xb8, 0, 0, 0, 0, 0xff, 0xd0, 0xc2, 0x0c, 0x00 };
+ WriteImm32(code, 13, fastcallTarget.ToInt32());
+ IntPtr thunk = IntPtr.Add(fastcallThunks, offset);
+ Marshal.Copy(code, 0, thunk, code.Length);
+ return thunk;
+ }
private static IntPtr WriteX87ControlWordReader(int offset) {
byte[] code = { 0xd9, 0x3d, 0, 0, 0, 0, 0xc3 }; // fnstcw [absolute address]; ret
WriteImm32(code, 2, x87ControlWordCell.ToInt32());
diff --git a/docs/appendices/knowledge-boundaries.md b/docs/appendices/knowledge-boundaries.md
index 5791836..27cf74a 100644
--- a/docs/appendices/knowledge-boundaries.md
+++ b/docs/appendices/knowledge-boundaries.md
@@ -253,12 +253,26 @@ solver. То же относится к редким MSH auxiliary streams и ч
разрешается в индекс устройства и сдвигает локальный индекс только когда parent
ID не равен `-1` и IID `0x202` доступен; иначе используется raw локальный индекс.
В этом потоке нулевой raw kind пропускает узел вместе с потомками, поэтому общий
-assigned ID нельзя получать из preorder-позиции записи. Это закрывает только
-передачу полей в native loader-е; Rust ещё должен строить такую же проекцию.
-
-Control loader также различает добавление устройств и применение одной записи
-к уже выбранному устройству. Для tag `19` найденные поля и ветви описаны в
-главе, но эффективное слияние пока не реализовано. В Rust parser-е
+assigned ID нельзя получать из preorder-позиции записи. Полная загрузка миссии
+в FParkan строит упорядоченную базовую проекцию таблицы
+Control для объектов с Unit DAT: корневые записи добавляются, `EXTO` добавляет
+строки с ключами глобальной MSH-иерархии, а `INTO` обновляет первую строку
+выбранного индекса либо добавляет список при sentinel `-1`. Проверка полной
+загрузки на оригинальном `min_l_n1.dat` получает 11 строк: 10 корневых записей,
+четыре замены `INTO` и одну добавленную строку дочернего `EXTO`. Ветви C4/C8 и
+добавление `EXTO` подтверждены машинными инструкциями оригинальных модулей, но
+полный результат FParkan не сравнивался с таблицей из запущенной игры. Тест на
+искусственном дереве также проверяет ID после пропущенного поддерева с raw kind
+`0`. Проекция хранит общие поля и происхождение записей; она не исполняет все
+обработчики Control.
+
+Control различает добавление устройства и применение одной записи к уже
+выбранному устройству. Исполнение оригинальной 32-битной DLL на искусственных
+данных подтверждает общую ветвь переопределения для получателей tags `9`, `15`,
+`19` и `25`: остаются прежними слот, ключ, ID компонента, множитель и класс,
+а коэффициенты копируются из новой записи. Искусственный tag `9`-объект создан
+без FX-хоста (`+0x3c == 0`), а запись не содержит строк таблицы map; поэтому
+работа FX-хоста здесь не проверялась. В Rust parser-е
`Unsupported { typed_record_index: Some(_) }` означает, что разбор остановился
внутри списка typed records; без индекса остановки unsupported может относиться
к effect-tail после уже разобранного списка. Эти случаи нужно различать.
@@ -269,10 +283,14 @@ Control loader также различает добавление устройс
трактоваться как пустой список.
Глобальные Control selectors `1/2` и setter selector `1` по tag `19` описаны
-там же только по статическому разбору `Control.dll`; execution oracle для этих
-глобальных вызовов нет. Остаются открытыми проверка effective merge на живых
-объектах, полный охват registry types и host factory paths, а также runtime
-жизненный цикл множителя `+0x4c`.
+там же только по статическому разбору `Control.dll`; их вызовы отдельно не
+исполнялись. Проекция полного mission load недоступна для неполного списка
+typed records, Control resource у non-geometric prototype и некоторых
+неразрешённых EXTO node mappings; preview и объекты без Unit DAT root её не
+строят. Её соответствие полной загрузке игры для всех типов компонентов и
+factory paths ещё не установлено. Не восстановлен и жизненный цикл множителя
+`+0x4c` после конструктора и переопределения; также неизвестно, когда эти
+объекты создаются при отложенной загрузке.
Для `Control.dll` (SHA-256
`bcb86318089028548a178b03a21accdce15df0cc85ddd91674cf3c2f55012c6e`) tag-26
diff --git a/docs/tomes/03-resources.md b/docs/tomes/03-resources.md
index a11ad55..a349a79 100644
--- a/docs/tomes/03-resources.md
+++ b/docs/tomes/03-resources.md
@@ -477,8 +477,15 @@ struct UnitDatRecord112 {
При построении mission prototype graph FParkan сохраняет для каждого root
упорядоченный список этих raw records. Список передаётся в
-`MissionObjectDraft` с исходными `kind`, `parent_or_link`, description и tails;
-эти данные пока не объединяются в таблицу эффективных устройств Control.
+`MissionObjectDraft` с исходными `kind`, `parent_or_link`, description и tails.
+Во время полного mission load runtime использует дерево и подготовленные CTL
+resources, чтобы построить для такого объекта упорядоченную базовую таблицу
+Control: корневые строки добавляются, дочерний `INTO` может обновить выбранную
+строку или добавить записи при sentinel `-1`, а `EXTO` добавляет строки с
+переведёнными ключами глобальной MSH-иерархии. Результат хранит исходный factory
+tag и provenance; неизвестные tag-specific callbacks он не выполняет. Preview
+режим эту таблицу не строит, а неполная typed-record list оставляет состояние
+явно unavailable.
Каждый graph edge от `UnitDatRoot` к effective component и далее к его MSH
dependency также несёт `unit_component_index`. Это индекс исходной записи в
diff --git a/docs/tomes/06-behavior.md b/docs/tomes/06-behavior.md
index 9d7b01e..0bd00df 100644
--- a/docs/tomes/06-behavior.md
+++ b/docs/tomes/06-behavior.md
@@ -593,6 +593,28 @@ parent ID через Control IID `0x202`, virtual slot `+0x44`, только е
нужно проверить это поведение явно. `EXTO` проходит отдельную ветвь, поэтому
это правило нельзя распространять на все registry types.
+Ветка `EXTO` заполняет другие поля. В `FUN_10003760` RVA `0x3760` и mount
+`C4`, и target `C8` сначала равны `-1`. Ветка `EXTO` вычисляет mount и
+записывает его только в `C4`; `C8` остаётся `-1`. Поэтому Control добавляет
+все typed records такого компонента в конец общей таблицы. Raw
+`parent_or_link` здесь выбирает mount-узел, а не строку Control.
+
+`AniMesh.dll` (SHA-256
+`65659bf67f20e5be77d67a5b2f59968f61b94293143807fa59ca451c560c4f7e`)
+собирает глобальную нумерацию MSH-узлов: обычная корневая модель добавляет все
+`N` узлов, `EXTO`-дочерняя модель добавляет `N - 1`, начиная со своего узла `1`,
+а `INTO`-компонент не добавляет узлов. `FUN_1000a460` (RVA `0xa460`) выполняет
+эту загрузку MSH; `FUN_10005780` (RVA `0x5780`) находит первый глобальный узел
+с заданным component ID. Если у `EXTO`-модели только один узел, она не добавляет
+глобальных узлов, и поиск первого узла возвращает `-1`.
+
+При добавлении `EXTO` Control отдельно переводит ключи CTLD в пространство
+глобальной MSH-иерархии: нулевой ключ заменяется mount-узлом `C4`; ненулевой
+ключ сдвигается относительно первого глобального узла компонента только при
+`C4 != -1`. Например, если компонент начинается с глобального узла `22`, его
+исходный ключ `1` становится `22`. Этот ключ выбирает модельный узел, а не
+строку Control. Записи корня остаются в исходном виде.
+
### Как Control добавляет и переопределяет устройства
В `Control.dll` (SHA-256
@@ -609,6 +631,19 @@ override path применяет первую typed record и не добавл
путь `0x20800`, поэтому такой результат парсера сам по себе не доказывает отказ
оригинального loader-а и не позволяет объявить Rust merge полным.
+FParkan строит базовую проекцию этой таблицы во время полного mission load для
+объектов с Unit DAT. Корневые typed records добавляются в исходном порядке;
+`EXTO` тоже добавляет все свои записи с remapped MSH-ключами; `INTO` обновляет
+одну строку по `C8`, а при sentinel `-1` добавляет весь список. Preview таблицу
+не создаёт. Проекция хранит исходный factory tag, текущий typed record и их
+provenance, но не исполняет все tag-specific callbacks и не заменяет полный
+Control runtime. Лицензированный `UNITS/BUILDS/MINE/min_l_n1.dat` подтверждает
+10 исходных устройств, четыре `INTO`-override по индексам `0..3` и добавление
+одной дочерней записи `EXTO` с ключом `22`, всего 11 устройств. Это результат
+Rust full-loader теста на оригинальных ресурсах. Ветви C4/C8 и добавление
+`EXTO` подтверждены статически по native ASM; отдельный native full-load oracle
+для всей таблицы не запускался.
+
Для tag `19` фабрика создаёт объект с его исходными классом и vtable. Базовый
конструктор `FUN_100218b0` задаёт multiplier `+0x4c = 1.0`. Override через
`FUN_1002d890` вызывает у выбранного объекта vtable slot `+0x1c`, то есть
@@ -621,6 +656,16 @@ override path применяет первую typed record и не добавл
сбрасывают их. Поэтому «переопределение» здесь означает обновить часть данных
того же устройства, с ограничениями конкретного метода.
+Native x86 oracle для тех же GOG DLL выполняет конструкторы и этот общий setter
+на уже созданных получателях factory tags `9`, `15`, `19` и `25` (размеры
+объектов `0x120`, `0x98`, `0x94` и `0xa4`). У всех проверенных vtable slot
+`+0x1c` указывает на RVA `0x21d50`; тест подтверждает, что override сохраняет
+существующий слот, класс/vtable, ключ, component ID и multiplier `2.5`, копируя
+новые коэффициенты. Slot `+0x24` у tag `9` указывает на отдельный обработчик
+`0x25600`, а у остальных трёх — на no-op `0xbcd0`. Tag `9` проверяется с
+нулевым pointer `+0x3c` и записью без map rows: FX host намеренно не подключён,
+поэтому его поведение этим опытом не подтверждено.
+
Статический разбор глобального Control interface показывает aggregate getters
`1/2` (`FUN_1002b410`, RVA `0x2b410`) и setter `1` (`FUN_1002ba30`, RVA
`0x2ba30`) для устройств tag `19`. Для конечных значений getter `1` вычисляет
Copyright © 2026 Valentin A. Popov. All Rights Reverse Engineered.