Node.h

Go to the documentation of this file.

#pragma once
 
#include "Types/Types.h"
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <vector>
 
namespace EmberCore {

class Node {
  public:
    enum class Type {
        None,
        Action,      // Leaf nodes that perform actions
        Control,     // Control flow nodes (sequence, selector, parallel)
        Condition,   // Condition/decorator nodes
        Decorator,   // Modifier nodes that alter child behavior
        BehaviorTree // BehaviorTree definition node (visual wrapper)
    };

    enum class Status {
        Idle,    // Not yet executed
        Running, // Currently executing
        Success, // Execution completed successfully
        Failure  // Execution failed
    };

    enum class VisualState { Normal, Selected, Hovered, Highlighted };
 
  public:
    // Construction and destruction
    explicit Node(const String &name, Type type = Type::None);
    virtual ~Node();
 
    // Copy operations
    Node(const Node &other) = delete;
    Node &operator=(const Node &other) = delete;
 
    // Move operations
    Node(Node &&other) noexcept;
    Node &operator=(Node &&other) noexcept;
 
    // Core node operations
    void AddChild(std::unique_ptr<Node> child);
    void RemoveChild(size_t index);
    void RemoveChild(Node *child);
    std::unique_ptr<Node> DetachChild(size_t index);
    std::unique_ptr<Node> DetachChild(Node *child);
 
    // Deep copy functionality
    std::unique_ptr<Node> DeepCopy() const;
 
    // Tree traversal and queries
    Node *FindChild(const String &name) const;
    Node *FindChildById(size_t id) const;
    Node *GetParent() const { return parent_; }
    size_t GetChildCount() const { return children_.size(); }
    Node *GetChild(size_t index) const;
 
    // Node properties
    size_t GetId() const { return id_; }
    const String &GetName() const { return name_; }
    void SetName(const String &name) { name_ = name; }
 
    Type GetType() const { return type_; }
    void SetType(Type type) { type_ = type; }
 
    Status GetStatus() const { return status_; }
    void SetStatus(Status status) { status_ = status; }
 
    // Visual properties
    const Point &GetPosition() const { return position_; }
    void SetPosition(const Point &position) { position_ = position; }
 
    VisualState GetVisualState() const { return visual_state_; }
    void SetVisualState(VisualState state) { visual_state_ = state; }
 
    bool AreChildrenVisible() const { return children_visible_; }
    void SetChildrenVisible(bool visible) { children_visible_ = visible; }
    void ToggleChildrenVisibility() { children_visible_ = !children_visible_; }
 
    // Layout and rendering support
    int GetChildrenWidth() const { return children_width_; }
    void SetChildrenWidth(int width) { children_width_ = width; }
    int CalculateSubtreeWidth(int node_width, int horizontal_spacing) const;
 
    // Tree validation and integrity
    bool IsValid() const;
    bool HasCycles() const;
    size_t GetDepth() const;
    size_t GetSubtreeNodeCount() const;
 
    // Visitor pattern support
    void Accept(std::function<void(Node *)> visitor);
    void Accept(std::function<void(const Node *)> visitor) const;
 
    // Utility functions
    String GetTypeString() const;
    String GetStatusString() const;
    std::vector<Node *> GetAllChildren();
    std::vector<const Node *> GetAllChildren() const;
 
    // Custom attributes support (for XML properties)
    void SetAttribute(const String &name, const String &value);
    String GetAttribute(const String &name, const String &default_value = "") const;
    bool HasAttribute(const String &name) const;
    void RemoveAttribute(const String &name);
    const std::map<String, String> &GetAllAttributes() const;
    size_t GetAttributeCount() const;
 
    // Debug and serialization support
    String ToString() const;
    void PrintTree(int indent = 0) const;
 
  protected:
    // Virtual methods for extensibility
    virtual std::unique_ptr<Node> CreateCopy() const;
    virtual void OnChildAdded(Node *child);
    virtual void OnChildRemoved(Node *child);
 
  private:
    // Core properties
    String name_;
    Type type_;
    Status status_;
    size_t id_;
 
    // Tree structure
    std::vector<std::unique_ptr<Node>> children_;
    Node *parent_;
 
    // Visual properties
    Point position_;
    VisualState visual_state_;
    bool children_visible_;
    int children_width_;
 
    // Custom attributes (for XML properties and user data)
    std::map<String, String> custom_attributes_;
 
    // Static ID counter
    static size_t next_id_;
 
    // Helper methods
    void SetParent(Node *parent) { parent_ = parent; }
    bool HasCyclesHelper(std::vector<const Node *> &visited) const;
    size_t FindChildIndex(Node *child) const;
 
    friend class NodeFactory;
};

class NodeFactory {
  public:
    static std::unique_ptr<Node> CreateActionNode(const String &name);
    static std::unique_ptr<Node> CreateControlNode(const String &name);
    static std::unique_ptr<Node> CreateConditionNode(const String &name);
    static std::unique_ptr<Node> CreateDecoratorNode(const String &name);
 
    // Create node from type enum
    static std::unique_ptr<Node> CreateNode(const String &name, Node::Type type);
 
    // Create a sample behavior tree for testing
    static std::unique_ptr<Node> CreateSampleTree();
};
 
} // namespace EmberCore