Configuration Reference

// Role Registration
bool AutoRegisterForCombatRoles;     // Auto-register with role subsystem
TArray<FGameplayTag> AllowedRoles;   // Roles this AI can take
int32 Priority;                       // Lower = higher priority for slots
FGameplayTag PreferredRole;           // Default role when available
 
// Fitness Evaluation
TArray<URoleEvaluator*> FitnessEvaluators;  // Scoring objects for role assignment
 
// Target Selection
UTargetSelector* TargetSelector;      // Per-AI target selector (instanced)
bool bIgnoreTargetRedistribution;     // Opt out of periodic target reshuffling
 
// Behavior
FSoftObjectPath DefaultStateTree;     // Optional StateTree; empty = native C++ combat loop
FSECDecisionContextParams DecisionContextParams; // Tunables for the decision context
 
// Action Set Management
bool ManageActionSetsAutomatically;   // Swap ActionSets based on role
UActionSet* DefaultActionSet;         // Fallback ActionSet
TMap<FGameplayTag, FRoleActionSetMapping> RoleActionSets;  // Per-role ActionSets
 
// Reaction Set Management
bool bManageReactionSetsAutomatically; // Swap ReactionSets based on role
UReactionSet* DefaultReactionSet;     // Fallback ReactionSet
TMap<FGameplayTag, FRoleReactionSetMapping> RoleReactionSets; // Per-role ReactionSets
 
// Movement Profile Management
bool ManageMovementProfilesAutomatically; // Swap Movement Profiles based on role
UMovementBehaviorProfile* DefaultMovementProfile; // Fallback Profile
TMap<FGameplayTag, FRoleMovementProfileConfig> RoleMovementProfiles; // Per-role Profiles

Name: DA_SEC_CombatConfig_Default
 
CombatRole
  AutoRegisterForCombatRoles: true
 
RoleRegistration
  AllowedRoles:
    - SEC.Role.Attacker
    - SEC.Role.Flanker
    - SEC.Role.Supporter
    - SEC.Role.Waiter
  Priority: 0
  PreferredRole: SEC.Role.Attacker
 
FitnessEvaluators
  - DistanceEvaluator
  - BP_HealthEvaluator
  - BP_RandomEvaluator
 
Behavior
  DefaultStateTree: StateTree_SEC_Core   // optional; leave empty to run the native C++ combat loop
 
ActionSets
  ManageActionSetsAutomatically: true
  DefaultActionSet: DA_SEC_ActionSet_Attacker
 
RoleActionSets
  SEC.Role.Waiter   → DA_SEC_ActionSet_Waiter
  SEC.Role.Flanker  → DA_SEC_ActionSet_Flanker
  SEC.Role.Supporter → DA_SEC_ActionSet_Ranged
 
ReactionSets
  bManageReactionSetsAutomatically: true
  DefaultReactionSet: DA_SEC_ReactionSet_Default
 
RoleReactionSets
  SEC.Role.Attacker → DA_SEC_ReactionSet_Aggressive
  SEC.Role.Waiter   → DA_SEC_ReactionSet_Defensive
 
MovementProfiles
  ManageMovementProfilesAutomatically: true
  DefaultMovementProfile: DA_SEC_Movement_Aggressive
 
RoleMovementProfiles
  SEC.Role.Waiter   → DA_SEC_Movement_Passive
  SEC.Role.Flanker  → DA_SEC_Movement_Flanking

// Recovery
float ActionRecoveryTime;               // Seconds suspended after an action completes or times out (0 = off)
float InterruptRecoveryTime;            // Seconds suspended after an interrupt or cancel; keep below ActionRecoveryTime
float ActionRecoveryTimeRandomization;  // ± jitter on completion recovery, so a pack does not act in lockstep
TObjectPtr<USECActionHook> GlobalHook;  // Optional instanced lifecycle hook run for every action this enemy commits

struct FActionSpec
{
    // Identity
    FName ActionId;                    // Unique identifier within the set
 
    // Execution: instanced method that owns how the action runs
    TObjectPtr<USECExecutionMethod> ExecutionMethod; // Gameplay Ability, Behavior Tree Sequence, or your own subclass
 
    // Scoring
    float SelectionWeight;             // Base priority multiplier
    float RiskPenalty;                 // Divides the final score (1.0 = no penalty)
    TMap<FGameplayTag, float> TagScoreMultipliers; // Situational tag multipliers
    FSECCustomScoring CustomScoring;   // Scoring list: Scorers (multiply) + Gates (veto)
 
    // Cooldowns
    FActionCooldown Cooldown;
        float Duration;                // Time before reuse
        float InitialCooldown;         // Cooldown applied on spawn
        float RandomizationPercent;    // Cooldown randomness (±%)
 
    // Chaining
    FName PreferredNextActionId;       // Bonus for this action next
    float ChainBonusMultiplier;        // Score multiplier if chaining
 
    // Preconditions (Hard Gates)
    FGameplayTagContainer RequiresTags;// Must have these to use
    FGameplayTagContainer BlockTags;   // Cannot use if these exist
    bool bRequireLineOfSight;          // Only fire with a clear LOS to target
    FGameplayTagContainer AddTags;     // Added while action active
};

struct FRangeEval
{
    float MinValue;      // Score = 0 below this (invalid)
    float OptimalMin;    // Score = 1.0 starts here
    float OptimalMax;    // Score = 1.0 ends here
    float MaxValue;      // Score = 0 above this (invalid)
};

Range.MinValue = 0;
Range.OptimalMin = 100;
Range.OptimalMax = 250;
Range.MaxValue = 400;

// Distance
float DesiredDistance;            // Ideal distance to hold (cm), default 400
float DistanceTolerance;          // Comfort band as a fraction of desired (0.05-0.5), default 0.2
 
// Strafe Rest (fatigue)
bool  bEnableStrafeRest;          // Rest after continuous strafing, default true
float StrafeRestTimeLimit;        // Seconds of strafing before a rest (3-60), default 10
float StrafeRestDuration;         // Rest length in seconds (0.5-10), default 1.5
 
// Threat Response
bool  bSwapStrafeOnHighThreat;    // Swap strafe side under high threat, default false
bool  bAdjustDistanceByThreat;    // Back off as threat rises, default false
float ThreatDistanceScale;        // How strongly threat pushes distance out (0-5), default 1.0
 
// Custom Rules
TArray<UPositioningRule*> PositioningRules;  // Instanced direction modifiers, empty by default

Name: DA_AggressiveMelee
 
DesiredDistance: 300
DistanceTolerance: 0.15
 
bEnableStrafeRest: true
StrafeRestTimeLimit: 15.0
StrafeRestDuration: 0.5
 
bSwapStrafeOnHighThreat: false
bAdjustDistanceByThreat: false
ThreatDistanceScale: 1.0
 
PositioningRules: []

FMovementBehaviorConfig::MakeDefault();     // Balanced (400 cm)
FMovementBehaviorConfig::MakeAttacker();    // Close, aggressive, minimal rest (300 cm)
FMovementBehaviorConfig::MakeWaiter();      // Far, patient, frequent rest (600 cm)
FMovementBehaviorConfig::MakeFlanker();     // Medium, quick repositioning (400 cm)
FMovementBehaviorConfig::MakeSupporter();   // Medium-far, moderate rest (500 cm)
FMovementBehaviorConfig::MakeElite();       // Relentless pressure, very short rest (350 cm)

float BaseDamage;              // Base damage value
TSubclassOf<UDamageType> DamageType;  // Damage type class
float ImpulseStrength;         // Physics impulse on hit
 
bool bCanBeBlocked;            // Can target block this?
bool bCanBeParried;            // Can target parry this?
 
bool bCanCritical;             // Can this crit?
float CriticalMultiplier;      // Damage multiplier on crit
float CriticalChance;          // Base crit chance (0.0-1.0)

Name: DA_SwordDamage
 
BaseDamage: 25.0
DamageType: UDamageType_Physical
ImpulseStrength: 500.0
 
bCanBeBlocked: true
bCanBeParried: true
 
bCanCritical: true
CriticalMultiplier: 2.0
CriticalChance: 0.1

// In weapon Blueprint:
DamageConfig: DA_SwordDamage