DefaultTreeFactory.cpp

Go to the documentation of this file.

#include "Adapters/DefaultTreeFactory.h"
#include "Core/BehaviorTree.h"
#include "Core/Node.h"
#include <memory>
 
namespace EmberCore {
 
std::shared_ptr<ITreeStructure> DefaultTreeFactory::CreateTree(const EmberCore::String &name) {
    // Create a BehaviorTree with a root node
    auto behaviorTree = std::make_shared<BehaviorTree>(name);
    auto root = std::make_shared<Node>(name, Node::Type::Control);
    behaviorTree->SetRootNode(root);
 
    // Create DirectTreeAdapter that wraps BehaviorTree
    auto adapter = std::make_shared<DirectTreeAdapter>(behaviorTree);
 
    return adapter;
}
 
std::shared_ptr<ITreeNode> DefaultTreeFactory::CreateNode(const EmberCore::String &name, ITreeNode::NodeType type) {
    // Convert the abstract node type to the concrete Node::Type
    Node::Type concrete_type = ConvertNodeType(type);
 
    // Create a new Node using the current implementation
    std::unique_ptr<Node> node;
    switch (concrete_type) {
    case Node::Type::Action:
        node = NodeFactory::CreateActionNode(name);
        break;
    case Node::Type::Control:
        node = NodeFactory::CreateControlNode(name);
        break;
    case Node::Type::Condition:
        node = NodeFactory::CreateConditionNode(name);
        break;
    case Node::Type::Decorator:
        node = NodeFactory::CreateDecoratorNode(name);
        break;
    default:
        node = std::make_unique<Node>(name, Node::Type::None);
        break;
    }
 
    // Create an adapter that wraps the node
    auto adapter = std::make_shared<NodeAdapter>(node.get());
 
    // Store the node in the adapter to maintain ownership
    // Note: This is a simplified approach. In a real implementation,
    // you might want to use a more sophisticated ownership model
 
    return adapter;
}
 
std::shared_ptr<ITreeStructure> DefaultTreeFactory::CreateSampleTree() {
    // Create a BehaviorTree with sample data
    auto behaviorTree = std::make_shared<BehaviorTree>("Sample Tree");
    auto sampleTree = NodeFactory::CreateSampleTree();
 
    // Convert unique_ptr to shared_ptr and set in BehaviorTree
    auto sharedTree = std::shared_ptr<Node>(sampleTree.release());
    behaviorTree->SetRootNode(sharedTree);
 
    // Create DirectTreeAdapter that wraps BehaviorTree
    auto adapter = std::make_shared<DirectTreeAdapter>(behaviorTree);
 
    return adapter;
}
 
Node::Type DefaultTreeFactory::ConvertNodeType(ITreeNode::NodeType type) const {
    switch (type) {
    case ITreeNode::NodeType::Action:
        return Node::Type::Action;
    case ITreeNode::NodeType::Control:
        return Node::Type::Control;
    case ITreeNode::NodeType::Condition:
        return Node::Type::Condition;
    case ITreeNode::NodeType::Decorator:
        return Node::Type::Decorator;
    default:
        return Node::Type::None;
    }
}
 
ITreeNode::NodeType DefaultTreeFactory::ConvertNodeType(Node::Type type) const {
    switch (type) {
    case Node::Type::Action:
        return ITreeNode::NodeType::Action;
    case Node::Type::Control:
        return ITreeNode::NodeType::Control;
    case Node::Type::Condition:
        return ITreeNode::NodeType::Condition;
    case Node::Type::Decorator:
        return ITreeNode::NodeType::Decorator;
    default:
        return ITreeNode::NodeType::Unknown;
    }
}
 
} // namespace EmberCore