Mass AI Example

State Trees are used for high-level AI logic management, acting similarly to Behavior Trees (BT) where Fragments act as the Blackboard.

Key components include:

• Evaluators: Gather data to be used within the State Tree.
• Enter Conditions: Used on leaf nodes to determine if a leaf should be executed.
• Tasks: Execute the actual logic (similar to BT tasks).
• Transitions: Allow the State Tree to move between different branches based on conditions.

Important Implementation Notes:

• Data Mapping: Use the UPROPERTY category InstanceData to define Input, Output, or Parameter values.
• Debugging: If a task fails due to missing fragments, check the task's header file for TStateTreeExternalDataHandle to identify required dependencies.
• Execution: In UMassStateTreeProcessor, Tick on StateTree Tasks is only run once and utilizes subscribed signals.

The project follows the standard Mass ECS architecture. Understanding these primitives is essential for building with the framework:

• Fragments (FMassFragment): Hold the raw data for entities.
• Tags (FMassTag): Used to filter entities based on specific properties or states.
• Traits (UMassEntityTraitBase): Used during entity configuration to define which fragments and tags an entity possesses.
• Processors (UMassProcessor): Perform logic by operating on groups of entities that share specific fragments or tags.
• Subsystems: Used to bridge logic between the Mass framework and the standard Unreal game world.
• ObserverProcessors: Can observe multiple fragments or tags by overriding the Register() function.

Efficiently visualizing large numbers of entities (e.g., ~50k) requires specialized techniques:

• Niagara Visualization: Use Niagara systems to render entities efficiently.
• LOD Strategy: Implement multiple Levels of Detail (LODs) using bone vertex animation and billboards.
• Key Components:
  • Visualization Trait
  • Mass Viewer Info Fragment
  • Mass Actor Fragment (for actor-based visualization)
  • Mass Visualization LOD Processor (Index 41)
  • Mass LOD Collector Trait and Mass LOD Collector Processor (Index 17). Note: LODCollectorProcessor may need to be enabled for high entity counts.
• Instanced Static Meshes (ISM): To apply unique textures/animations to ISMs, use an atlas and instance custom data. Use FMassRepresentationFragment, FMassRepresentationLODFragment, and RepresentationSubsystem to manage this.

The project demonstrates a save/load approach for Mass entities using:

• A Signal Processor to write entity data.
• A Subsystem for centralized data processing.
• Integration with the standard Unreal Save System.

The project utilizes a Spatial Hash Grid to perform fast spatial queries (e.g., finding entities within a specific range). This is the same underlying system used for Mass avoidance.

Implementation Details:

• Use a custom processor to update entity locations within the hash grid.
• Performance Note: THierarchicalHashGrid2D is generally more efficient for Mass avoidance than TPointHashGrid3.

Smart Objects allow Mass entities to interact with specific objects in the world.

Key Requirements and Patterns:

• Definition: A SmartObjectDefinition requires a USmartObjectMassBehaviorDefinition and all default tag filters to appear on the Mass SmartObject Eval evaluator.
• Execution: The UseSmartObjectTask executes the C++ logic defined in USmartObjectMassBehaviorDefinition.
• Accessing Objects: Use FMassSmartObjectHandler to interact with smart objects within Mass rather than accessing the smart object subsystem directly.
• Safe Destruction: When destroying a smart object within USmartObjectMassBehaviorDefinition, use PushCommand() to allow the SmartObjectUseTask to release the object safely before destruction.