Node.cpp

Go to the documentation of this file.

#include "Core/Node.h"
#include "Utils/Logger.h"
#include <algorithm>
#include <numeric>
 
namespace EmberCore {
 
// Static member initialization
size_t Node::next_id_ = 1;
 
// Constructor
Node::Node(const EmberCore::String &name, Type type)
    : name_(name), type_(type), status_(Status::Idle), id_(next_id_++), parent_(nullptr), position_(0, 0),
      visual_state_(VisualState::Normal), children_visible_(true), children_width_(0) {}
 
// Destructor
Node::~Node() {
    // Unique_ptr automatically handles cleanup of children
    for (auto &child : children_) {
        if (child) {
            child->parent_ = nullptr;
        }
    }
}
 
// Move constructor
Node::Node(Node &&other) noexcept
    : name_(std::move(other.name_)), type_(other.type_), status_(other.status_), id_(other.id_),
      children_(std::move(other.children_)), parent_(other.parent_), position_(other.position_),
      visual_state_(other.visual_state_), children_visible_(other.children_visible_),
      children_width_(other.children_width_), custom_attributes_(std::move(other.custom_attributes_)) {
    other.parent_ = nullptr;
    // Update parent pointers for moved children
    for (auto &child : children_) {
        if (child) {
            child->parent_ = this;
        }
    }
}
 
// Move assignment operator
Node &Node::operator=(Node &&other) noexcept {
    if (this != &other) {
        // Clean up current children
        for (auto &child : children_) {
            if (child) {
                child->parent_ = nullptr;
            }
        }
 
        // Move from other
        name_ = std::move(other.name_);
        type_ = other.type_;
        status_ = other.status_;
        id_ = other.id_;
        children_ = std::move(other.children_);
        parent_ = other.parent_;
        position_ = other.position_;
        visual_state_ = other.visual_state_;
        children_visible_ = other.children_visible_;
        children_width_ = other.children_width_;
        custom_attributes_ = std::move(other.custom_attributes_);
 
        other.parent_ = nullptr;
 
        // Update parent pointers for moved children
        for (auto &child : children_) {
            if (child) {
                child->parent_ = this;
            }
        }
    }
    return *this;
}
 
// Core node operations
void Node::AddChild(std::unique_ptr<Node> child) {
    if (!child) {
        LOG_ERROR("Node", "Attempting to add null child to node '" + name_ + "'");
        return;
    }
 
    if (child.get() == this) {
        LOG_ERROR("Node", "Attempting to add node '" + name_ + "' as child of itself");
        return;
    }
 
    // Check for cycles
    Node *ancestor = parent_;
    while (ancestor) {
        if (ancestor == child.get()) {
            LOG_ERROR("Node", "Adding child '" + child->name_ + "' to node '" + name_ + "' would create a cycle");
            return;
        }
        ancestor = ancestor->parent_;
    }
 
    child->parent_ = this;
    children_.push_back(std::move(child));
    OnChildAdded(children_.back().get());
}
 
void Node::RemoveChild(size_t index) {
    if (index >= children_.size()) {
        LOG_ERROR("Node", "Child index " + std::to_string(index) + " out of bounds for node '" + name_ + "' (has " +
                              std::to_string(children_.size()) + " children)");
        return;
    }
 
    Node *child = children_[index].get();
    OnChildRemoved(child);
    child->parent_ = nullptr;
    children_.erase(children_.begin() + index);
}
 
void Node::RemoveChild(Node *child) {
    size_t index = FindChildIndex(child);
    if (index != SIZE_MAX) {
        RemoveChild(index);
    }
}
 
std::unique_ptr<Node> Node::DetachChild(size_t index) {
    if (index >= children_.size()) {
        LOG_ERROR("Node", "Child index " + std::to_string(index) + " out of bounds for node '" + name_ + "'");
        return nullptr;
    }
 
    std::unique_ptr<Node> child = std::move(children_[index]);
    children_.erase(children_.begin() + index);
 
    if (child) {
        OnChildRemoved(child.get());
        child->parent_ = nullptr;
    }
 
    return child;
}
 
std::unique_ptr<Node> Node::DetachChild(Node *child) {
    size_t index = FindChildIndex(child);
    if (index != SIZE_MAX) {
        return DetachChild(index);
    }
    return nullptr;
}
 
// Deep copy functionality
std::unique_ptr<Node> Node::DeepCopy() const {
    auto copy = CreateCopy();
 
    // Copy children recursively
    for (const auto &child : children_) {
        if (child) {
            copy->AddChild(child->DeepCopy());
        }
    }
 
    return copy;
}
 
// Tree traversal and queries
Node *Node::FindChild(const EmberCore::String &name) const {
    auto it = std::find_if(children_.begin(), children_.end(),
                           [&name](const std::unique_ptr<Node> &child) { return child && child->name_ == name; });
    return it != children_.end() ? it->get() : nullptr;
}
 
Node *Node::FindChildById(size_t id) const {
    auto it = std::find_if(children_.begin(), children_.end(),
                           [id](const std::unique_ptr<Node> &child) { return child && child->id_ == id; });
    return it != children_.end() ? it->get() : nullptr;
}
 
Node *Node::GetChild(size_t index) const {
    if (index >= children_.size()) {
        return nullptr;
    }
    return children_[index].get();
}
 
// Layout and rendering support
int Node::CalculateSubtreeWidth(int node_width, int horizontal_spacing) const {
    if (children_.empty() || !children_visible_) {
        return node_width;
    }
 
    int total_width = 0;
    for (const auto &child : children_) {
        if (child) {
            total_width += child->CalculateSubtreeWidth(node_width, horizontal_spacing);
            total_width += horizontal_spacing;
        }
    }
 
    // Remove the last spacing
    if (!children_.empty()) {
        total_width -= horizontal_spacing;
    }
 
    return std::max(node_width, total_width);
}
 
// Tree validation and integrity
bool Node::IsValid() const {
    // Check for basic validity
    if (name_.empty()) {
        return false;
    }
 
    // Check for cycles
    if (HasCycles()) {
        return false;
    }
 
    // Validate children recursively
    for (const auto &child : children_) {
        if (!child || !child->IsValid()) {
            return false;
        }
 
        // Check parent-child relationship
        if (child->parent_ != this) {
            return false;
        }
    }
 
    return true;
}
 
bool Node::HasCycles() const {
    std::vector<const Node *> visited;
    return HasCyclesHelper(visited);
}
 
size_t Node::GetDepth() const {
    size_t max_depth = 0;
    for (const auto &child : children_) {
        if (child) {
            max_depth = std::max(max_depth, child->GetDepth());
        }
    }
    return max_depth + 1;
}
 
size_t Node::GetSubtreeNodeCount() const {
    return 1 + std::accumulate(children_.begin(), children_.end(), size_t(0),
                               [](size_t sum, const std::unique_ptr<Node> &child) {
                                   return sum + (child ? child->GetSubtreeNodeCount() : 0);
                               });
}
 
// Visitor pattern support
void Node::Accept(std::function<void(Node *)> visitor) {
    visitor(this);
    for (auto &child : children_) {
        if (child) {
            child->Accept(visitor);
        }
    }
}
 
void Node::Accept(std::function<void(const Node *)> visitor) const {
    visitor(this);
    for (const auto &child : children_) {
        if (child) {
            // Explicitly call the const version to avoid ambiguity
            static_cast<const Node *>(child.get())->Accept(visitor);
        }
    }
}
 
// Utility functions
EmberCore::String Node::GetTypeString() const {
    switch (type_) {
    case Type::Action:
        return "Action";
    case Type::Control:
        return "Control";
    case Type::Condition:
        return "Condition";
    case Type::Decorator:
        return "Decorator";
    case Type::None:
    default:
        return "None";
    }
}
 
EmberCore::String Node::GetStatusString() const {
    switch (status_) {
    case Status::Running:
        return "Running";
    case Status::Success:
        return "Success";
    case Status::Failure:
        return "Failure";
    case Status::Idle:
    default:
        return "Idle";
    }
}
 
std::vector<Node *> Node::GetAllChildren() {
    std::vector<Node *> result;
    result.reserve(children_.size());
    for (const auto &child : children_) {
        if (child) {
            result.push_back(child.get());
        }
    }
    return result;
}
 
std::vector<const Node *> Node::GetAllChildren() const {
    std::vector<const Node *> result;
    result.reserve(children_.size());
    for (const auto &child : children_) {
        if (child) {
            result.push_back(child.get());
        }
    }
    return result;
}
 
// Debug and serialization support
EmberCore::String Node::ToString() const {
    return "Node[" + std::to_string(id_) + "]: '" + name_ + "' (" + GetTypeString() + ", " + GetStatusString() +
           ") - " + std::to_string(children_.size()) + " children";
}
 
void Node::PrintTree(int indent) const {
    EmberCore::String indentStr(indent * 2, ' ');
    LOG_INFO("Node", indentStr + ToString());
 
    for (const auto &child : children_) {
        if (child) {
            child->PrintTree(indent + 1);
        }
    }
}
 
// Protected virtual methods
std::unique_ptr<Node> Node::CreateCopy() const {
    auto copy = std::make_unique<Node>(name_, type_);
    copy->status_ = status_;
    copy->position_ = position_;
    copy->visual_state_ = visual_state_;
    copy->children_visible_ = children_visible_;
    copy->children_width_ = children_width_;
 
    // FIXED: Let constructor auto-assign unique ID instead of copying
    // Each copy now gets its own unique ID from next_id_++
    // This prevents duplicate IDs when SubTree references are expanded
 
    // Copy custom attributes (including ID attribute for serialization)
    copy->custom_attributes_ = custom_attributes_;
 
    return copy;
}
 
void Node::OnChildAdded(Node *child) {
    // Default implementation - can be overridden by derived classes
    LOG_TRACE("Node", "Child '" + (child ? child->name_ : "null") + "' added to node '" + name_ + "'");
}
 
void Node::OnChildRemoved(Node *child) {
    // Default implementation - can be overridden by derived classes
    LOG_TRACE("Node", "Child '" + (child ? child->name_ : "null") + "' removed from node '" + name_ + "'");
}
 
// Private helper methods
bool Node::HasCyclesHelper(std::vector<const Node *> &visited) const {
    // Check if this node is already in the visited list (cycle detected)
    if (std::find(visited.begin(), visited.end(), this) != visited.end()) {
        return true;
    }
 
    visited.push_back(this);
 
    // Check children recursively
    bool has_cycle = std::any_of(children_.begin(), children_.end(), [&visited](const std::unique_ptr<Node> &child) {
        return child && child->HasCyclesHelper(visited);
    });
 
    visited.pop_back();
    return has_cycle;
}
 
size_t Node::FindChildIndex(Node *child) const {
    for (size_t i = 0; i < children_.size(); ++i) {
        if (children_[i].get() == child) {
            return i;
        }
    }
    return SIZE_MAX;
}
 
// NodeFactory implementation
std::unique_ptr<Node> NodeFactory::CreateActionNode(const EmberCore::String &name) {
    return std::make_unique<Node>(name, Node::Type::Action);
}
 
std::unique_ptr<Node> NodeFactory::CreateControlNode(const EmberCore::String &name) {
    return std::make_unique<Node>(name, Node::Type::Control);
}
 
std::unique_ptr<Node> NodeFactory::CreateConditionNode(const EmberCore::String &name) {
    return std::make_unique<Node>(name, Node::Type::Condition);
}
 
std::unique_ptr<Node> NodeFactory::CreateDecoratorNode(const EmberCore::String &name) {
    return std::make_unique<Node>(name, Node::Type::Decorator);
}
 
std::unique_ptr<Node> NodeFactory::CreateNode(const EmberCore::String &name, Node::Type type) {
    return std::make_unique<Node>(name, type);
}
 
std::unique_ptr<Node> NodeFactory::CreateSampleTree() {
    auto root = CreateControlNode("Root Selector");
 
    // Create a sample behavior tree structure
    auto patrol_sequence = CreateControlNode("Patrol Sequence");
    patrol_sequence->AddChild(CreateConditionNode("Has Patrol Route"));
    patrol_sequence->AddChild(CreateActionNode("Move to Next Waypoint"));
    patrol_sequence->AddChild(CreateActionNode("Wait at Waypoint"));
 
    auto combat_sequence = CreateControlNode("Combat Sequence");
    combat_sequence->AddChild(CreateConditionNode("Enemy in Range"));
    combat_sequence->AddChild(CreateActionNode("Attack Enemy"));
 
    auto idle_action = CreateActionNode("Idle");
 
    root->AddChild(std::move(combat_sequence));
    root->AddChild(std::move(patrol_sequence));
    root->AddChild(std::move(idle_action));
 
    return root;
}
 
// ====== CUSTOM ATTRIBUTES IMPLEMENTATION ======
 
void Node::SetAttribute(const EmberCore::String &name, const EmberCore::String &value) {
    if (name.empty()) {
        return; // Don't allow empty attribute names
    }
    custom_attributes_[name] = value;
}
 
EmberCore::String Node::GetAttribute(const EmberCore::String &name, const EmberCore::String &default_value) const {
    auto it = custom_attributes_.find(name);
    return (it != custom_attributes_.end()) ? it->second : default_value;
}
 
bool Node::HasAttribute(const EmberCore::String &name) const {
    return custom_attributes_.find(name) != custom_attributes_.end();
}
 
void Node::RemoveAttribute(const EmberCore::String &name) { custom_attributes_.erase(name); }
 
const std::map<EmberCore::String, EmberCore::String> &Node::GetAllAttributes() const { return custom_attributes_; }
 
size_t Node::GetAttributeCount() const { return custom_attributes_.size(); }
 
} // namespace EmberCore