BehaviorTree.h

Go to the documentation of this file.

#pragma once

 
#include "BlackboardEntry.h"
#include "Node.h"
#include <functional>
#include <memory>
#include <unordered_map>
#include <vector>
 
namespace EmberCore {

struct XMLMetadata {
    struct Comment {
        EmberCore::String text;
        bool before_node; // true if comment appears before node, false if after
    };
 
    // Map node ID -> comments associated with that node
    std::unordered_map<size_t, std::vector<Comment>> node_comments;
 
    // Document-level comments (header, footer)
    std::vector<EmberCore::String> header_comments;
    std::vector<EmberCore::String> footer_comments;
 
    // Formatting hints
    int indent_size = 4;
    bool use_tabs = false;
};

class BehaviorTree {
  public:
    enum class ExecutionState {
        Idle,      // Not running
        Running,   // Currently executing
        Paused,    // Execution paused
        Completed, // Finished successfully
        Failed     // Finished with failure
    };

    struct ValidationResult {
        bool is_valid = true;
        std::vector<EmberCore::String> errors;
        std::vector<EmberCore::String> warnings;
 
        void AddError(const EmberCore::String &error) {
            errors.push_back(error);
            is_valid = false;
        }
 
        void AddWarning(const EmberCore::String &warning) { warnings.push_back(warning); }
    };
 
  public:
    explicit BehaviorTree(const EmberCore::String &name = "Behavior Tree");

    ~BehaviorTree();
 
    // Tree structure management
    void SetRootNode(std::unique_ptr<Node> root);
    void SetRootNode(std::shared_ptr<Node> root); // New: shared_ptr support
    Node *GetRootNode() const { return root_node_ ? root_node_.get() : root_node_shared_.get(); }
    std::shared_ptr<Node> GetRootNodeShared() const { return root_node_shared_; } // New: shared access
    bool HasRootNode() const { return root_node_.get() || root_node_shared_.get(); }
 
    // Tree properties
    const EmberCore::String &GetName() const { return name_; }
    void SetName(const EmberCore::String &name) { name_ = name; }
 
    const EmberCore::String &GetDescription() const { return description_; }
    void SetDescription(const EmberCore::String &description) { description_ = description; }
 
    // Tree statistics
    size_t GetNodeCount() const;
    size_t GetMaxDepth() const;
    std::vector<Node *> GetAllNodes();
    std::vector<const Node *> GetAllNodes() const;
 
    // Node operations
    Node *FindNodeById(size_t id) const;
    Node *FindNodeByName(const EmberCore::String &name) const;
    std::vector<Node *> FindNodesByType(Node::Type type) const;
 
    // Tree manipulation
    bool AddNode(std::unique_ptr<Node> node, Node *parent = nullptr);
    bool RemoveNode(size_t node_id);
    bool MoveNode(size_t node_id, Node *new_parent);
    std::unique_ptr<Node> ExtractNode(size_t node_id);
 
    // Tree validation
    ValidationResult Validate() const;
    bool IsValid() const { return Validate().is_valid; }
    bool HasCycles() const;
 
    // Tree execution state
    ExecutionState GetExecutionState() const { return execution_state_; }
    void SetExecutionState(ExecutionState state) { execution_state_ = state; }
 
    // Tree operations
    void Clear();
    std::unique_ptr<BehaviorTree> Clone() const;
    void Reset(); // Reset all node states to default
 
    // Blackboard management
    void AddBlackboard(std::unique_ptr<Blackboard> blackboard);
    Blackboard *GetBlackboard(const EmberCore::String &id);
    const Blackboard *GetBlackboard(const EmberCore::String &id) const;
    bool HasBlackboard(const EmberCore::String &id) const;
    void RemoveBlackboard(const EmberCore::String &id);
    const std::map<EmberCore::String, std::unique_ptr<Blackboard>> &GetBlackboards() const { return blackboards_; }
    size_t GetBlackboardCount() const { return blackboards_.size(); }
    void ClearBlackboards();
 
    // Serialization
    EmberCore::String Serialize() const;
    bool Deserialize(const EmberCore::String &data);
 
    // File operations
    bool SaveToFile(const EmberCore::String &filename) const;
    bool LoadFromFile(const EmberCore::String &filename);
 
    // Visitor pattern
    void TraverseNodes(std::function<void(Node *)> visitor);
    void TraverseNodes(std::function<void(const Node *)> visitor) const;
    void TraversePreOrder(std::function<void(Node *)> visitor);
    void TraversePostOrder(std::function<void(Node *)> visitor);
 
    // Events and callbacks
    using NodeChangeCallback = std::function<void(Node *, const EmberCore::String &change_type)>;
    using TreeChangeCallback = std::function<void(const EmberCore::String &change_type)>;
 
    void SetNodeChangeCallback(NodeChangeCallback callback) { node_change_callback_ = callback; }
    void SetTreeChangeCallback(TreeChangeCallback callback) { tree_change_callback_ = callback; }
 
    // Debug utilities
    void PrintTree() const;
    EmberCore::String GetTreeStructure() const;
    std::unordered_map<Node::Type, size_t> GetNodeTypeStatistics() const;
 
    // Tree metadata
    void SetMetadata(const EmberCore::String &key, const EmberCore::String &value);
    EmberCore::String GetMetadata(const EmberCore::String &key) const;
    void RemoveMetadata(const EmberCore::String &key);
    const std::unordered_map<EmberCore::String, EmberCore::String> &GetAllMetadata() const { return metadata_; }
 
    // XML metadata (for comment/formatting preservation)
    XMLMetadata &GetXMLMetadata() { return xml_metadata_; }
    const XMLMetadata &GetXMLMetadata() const { return xml_metadata_; }
 
  protected:
    // Internal helper methods
    void NotifyNodeChange(Node *node, const EmberCore::String &change_type);
    void NotifyTreeChange(const EmberCore::String &change_type);
    void UpdateNodeIndex();
    Node *FindNodeRecursive(Node *current, std::function<bool(const Node *)> predicate) const;
    void CollectNodesRecursive(Node *current, std::vector<Node *> &nodes);
    void CollectNodesRecursive(const Node *current, std::vector<const Node *> &nodes) const;
 
  private:
    // Core tree data
    std::unique_ptr<Node> root_node_;
    std::shared_ptr<Node> root_node_shared_; // New: for shared ownership
    EmberCore::String name_;
    EmberCore::String description_;
    ExecutionState execution_state_;
 
    // Node lookup optimization
    std::unordered_map<size_t, Node *> node_index_;
 
    // Metadata storage
    std::unordered_map<EmberCore::String, EmberCore::String> metadata_;
 
    // XML metadata (comments and formatting)
    XMLMetadata xml_metadata_;
 
    // Blackboard storage
    std::map<EmberCore::String, std::unique_ptr<Blackboard>> blackboards_;
 
    // Event callbacks
    NodeChangeCallback node_change_callback_;
    TreeChangeCallback tree_change_callback_;
 
    // Helper methods
    ValidationResult ValidateNode(const Node *node, std::vector<const Node *> &visited) const;
    void BuildNodeIndex(Node *node);
};
 
// Utility functions
namespace BehaviorTreeUtils {
std::unique_ptr<BehaviorTree> CreateSampleTree();

std::unique_ptr<BehaviorTree> CreateEmptyTree(const EmberCore::String &name = "New Tree");

std::unique_ptr<BehaviorTree> MergeTrees(const BehaviorTree &tree1, const BehaviorTree &tree2);
} // namespace BehaviorTreeUtils
 
} // namespace EmberCore