ECS_Components_AI.h

Go to the documentation of this file.

/*
Olympe Engine V2 - 2025
Nicolas Chereau
nchereau@gmail.com
 
This file is part of Olympe Engine V2.
 
AI Components purpose: Define all AI-related components for the ECS architecture.
 
*/
 
#pragma once
 
#include "ECS_Entity.h"
#include "vector.h"
#include <cstdint>
#include "ECS_Systems_AI.h"
#include "ComponentRegistry.h"
 
// --- AI Blackboard Component ---
// Typed blackboard with explicit fields for performance (no std::map/std::string keys in hot path)
struct AIBlackboard_data
{
    // Mode tracking (exposed to BT for condition checks)
    int AIMode = 1;  // 1=Idle, 2=Patrol, 3=Combat, 4=Flee, 5=Investigate
    
    // Target tracking
    EntityID targetEntity = INVALID_ENTITY_ID;
    Vector lastKnownTargetPosition;
    float timeSinceTargetSeen = 0.0f;
    bool hasTarget = false;
    
    // Perception state
    float distanceToTarget = 0.0f;
    bool targetVisible = false;
    bool targetInRange = false;
    
    // Movement goals
    Vector moveGoal;
    bool hasMoveGoal = false;
    
    // Patrol state
    int currentPatrolPoint = 0;
    int currentPatrolIndex = 0;
    Vector patrolPoints[8]; // Fixed size for performance
    int patrolPointCount = 0;
    bool hasPatrolPath = false; 
    
    // Combat state
    float lastAttackTime = 0.0f;
    float attackCooldown = 1.0f;
    bool canAttack = true;
    
    // Stimulus tracking
    float lastDamageTaken = 0.0f;
    float damageAmount = 0.0f;
    Vector lastNoisePosition;
    bool heardNoise = false;
    float noiseCooldown = 0.0f;
    
    // NEW: Wander behavior state
    float wanderWaitTimer = 0.0f;           // Current timer
    float wanderTargetWaitTime = 0.0f;      // Target wait time
    Vector wanderDestination;               // Chosen destination point
    bool hasWanderDestination = false;      // Destination chosen?
    float wanderSearchRadius = 500.0f;      // Default search radius
    int wanderMaxSearchAttempts = 10;       // Default max attempts
};
AUTO_REGISTER_COMPONENT(AIBlackboard_data);
 
// --- AI Senses Component ---
// Perception parameters for the AI entity
struct AISenses_data
{
    float visionRadius = 300.0f;      // How far the entity can see
    float visionAngle = 180.0f;       // Field of view in degrees (360 = omnidirectional)
    float hearingRadius = 500.0f;     // How far the entity can hear sounds
    
    // Timeslicing parameters for performance
    float perceptionHz = 5.0f;        // Perception updates per second (default: 5 Hz = every 0.2s)
    float thinkHz = 10.0f;            // Decision/BT updates per second (default: 10 Hz = every 0.1s)
    
    // Internal timers (updated by systems)
    float nextPerceptionTime = 0.0f;
    float nextThinkTime = 0.0f;
    
    // Constructors
    AISenses_data() = default;
    AISenses_data(float vision, float hearing) 
        : visionRadius(vision), hearingRadius(hearing) {}
};
AUTO_REGISTER_COMPONENT(AISenses_data);
 
// --- AI State Component (HFSM) ---
// Hierarchical Finite State Machine mode/state
/**
 * @enum AIMode
 * @brief AI behavior modes for NPCs
 * @note Values start at 1 to match BT condition checks (AIMode == 1 for Idle, 2 for Patrol, 3 for Combat)
 */
enum class AIMode : uint8_t
{
    Idle = 1,        // Default wander/idle behavior
    Patrol = 2,      // Following patrol route
    Combat = 3,      // Engaging enemies
    Flee = 4,        // Running away from threats
    Investigate = 5, // Checking suspicious activity
    Dead = 6         // Entity is dead
};
 
struct AIState_data
{
    AIMode currentMode = AIMode::Idle;
    AIMode previousMode = AIMode::Idle;
    float timeInCurrentMode = 0.0f;
    
    // State transition thresholds
    float combatEngageDistance = 250.0f;
    float fleeHealthThreshold = 0.2f;      // Flee when health below 20%
    float investigateTimeout = 5.0f;        // Time to investigate before returning to patrol
};
AUTO_REGISTER_COMPONENT(AIState_data);
 
// --- Behavior Tree Runtime Component ---
// Per-entity behavior tree execution state
struct BehaviorTreeRuntime_data
{
    // Tree identification (RENAMED: Added AI prefix for clarity)
    uint32_t AITreeAssetId = 0;         // ID of the behavior tree asset to execute
    std::string AITreePath = "";        // Path to the tree asset 
    
    // Execution state (RENAMED: Added AI prefix for clarity)
    uint32_t AICurrentNodeIndex = 0;    // Index of the currently executing node
    uint8_t lastStatus = 0;             // Last node execution status (0=Running, 1=Success, 2=Failure)
    
    // Timeslicing state
    float nextThinkTime = 0.0f;         // When to next tick the behavior tree
    
    // Tree execution control
    bool isActive = true;               // Enable/disable tree execution
    bool needsRestart = false;          // Flag to restart tree from root
    
    // Constructors
    BehaviorTreeRuntime_data()
        : AITreeAssetId(0), AICurrentNodeIndex(0), lastStatus(0),
        nextThinkTime(0.0f), isActive(true), needsRestart(false)
    {
        SYSTEM_LOG << "[BehaviorTreeRuntime_data] Default constructor called: AITreeAssetId="
            << AITreeAssetId << std::endl;
    }
 
    BehaviorTreeRuntime_data(uint32_t treeId, bool active)
        : AITreeAssetId(treeId), isActive(active),
        AICurrentNodeIndex(0), lastStatus(0), nextThinkTime(0.0f), needsRestart(false)
    {
        SYSTEM_LOG << "[BehaviorTreeRuntime_data] Parameterized constructor called: AITreeAssetId="
            << treeId << ", active=" << active << std::endl;
    }
};
AUTO_REGISTER_COMPONENT(BehaviorTreeRuntime_data);
 
// --- Move Intent Component ---
// Movement intent that will be converted to Movement_data by AIMotionSystem
struct MoveIntent_data
{
    Vector targetPosition;               // Where to move
    float desiredSpeed = 100.0f;          // Speed multiplier (0.0 to 1.0, can exceed 1.0 for sprint)
    bool hasIntent = false;              // Whether this intent is active
    float arrivalThreshold = 5.0f;       // Distance at which we consider arrived
    
    // Pathfinding flags (for future expansion)
    bool usePathfinding = false;
    bool avoidObstacles = false;
};
AUTO_REGISTER_COMPONENT(MoveIntent_data);
 
// --- Attack Intent Component ---
// Attack intent for combat actions
struct AttackIntent_data
{
    EntityID targetEntity = INVALID_ENTITY_ID;
    Vector targetPosition;               // Attack position if no specific entity
    float damage = 10.0f;                // Damage to deal
    float range = 50.0f;                 // Attack range
    bool hasIntent = false;              // Whether this intent is active
    float cooldown = 1.0f;               // Time between attacks
    
    // Attack type (can be extended)
    enum class AttackType : uint8_t
    {
        Melee = 0,
        Ranged,
        Area
    };
    AttackType attackType = AttackType::Melee;
};
AUTO_REGISTER_COMPONENT(AttackIntent_data);