TreeBuilder.cpp

Go to the documentation of this file.

#include "Network/Builder/TreeBuilder.h"
 
#include "Core/BlackboardEntry.h"
 
namespace Ember {
namespace Network {
 
TreeBuilder::BuildResult TreeBuilder::Build(const Protocol::TreeInit *tree_init) {
    BuildResult result;
    m_nodeCount = 0;
 
    if (!tree_init) {
        result.error = "TreeInit is null";
        return result;
    }
 
    if (!tree_init->tree_id()) {
        result.error = "TreeInit missing tree_id";
        return result;
    }
 
    if (!tree_init->root()) {
        result.error = "TreeInit missing root node";
        return result;
    }
 
    std::string treeName = tree_init->tree_name() ? tree_init->tree_name()->str() : tree_init->tree_id()->str();
 
    auto tree = std::make_shared<EmberCore::BehaviorTree>(treeName);
 
    tree->SetMetadata("tree_id", tree_init->tree_id()->str());
 
    auto rootNode = BuildNode(tree_init->root());
    if (!rootNode) {
        result.error = "Failed to build root node";
        return result;
    }
 
    tree->SetRootNode(std::move(rootNode));
 
    if (tree_init->blackboards()) {
        BuildBlackboards(tree.get(), tree_init->blackboards());
    }
 
    if (tree_init->metadata()) {
        for (const auto *kv : *tree_init->metadata()) {
            if (kv->key()) {
                std::string value = kv->value() ? kv->value()->str() : "";
                tree->SetMetadata(kv->key()->str(), value);
            }
        }
    }
 
    result.success = true;
    result.tree = tree;
    result.node_count = m_nodeCount;
 
    return result;
}
 
std::unique_ptr<EmberCore::Node> TreeBuilder::BuildNode(const Protocol::NodeDefinition *def) {
    if (!def) {
        return nullptr;
    }
 
    std::string name = def->name() ? def->name()->str() : "Unnamed";
    EmberCore::Node::Type nodeType = ConvertNodeType(def->node_type());
 
    auto node = std::make_unique<EmberCore::Node>(name, nodeType);
    m_nodeCount++;
 
    if (def->subtype()) {
        node->SetAttribute("subtype", def->subtype()->str());
    }
 
    if (def->description()) {
        node->SetAttribute("description", def->description()->str());
    }
 
    node->SetAttribute("tcp_node_id", std::to_string(def->id()));
 
    if (def->attributes()) {
        for (const auto *kv : *def->attributes()) {
            if (kv->key()) {
                std::string value = kv->value() ? kv->value()->str() : "";
                node->SetAttribute(kv->key()->str(), value);
            }
        }
    }
 
    if (def->children()) {
        for (const auto *childDef : *def->children()) {
            auto childNode = BuildNode(childDef);
            if (childNode) {
                node->AddChild(std::move(childNode));
            }
        }
    }
 
    return node;
}
 
void TreeBuilder::BuildBlackboards(
    EmberCore::BehaviorTree *tree,
    const flatbuffers::Vector<flatbuffers::Offset<Protocol::BlackboardDefinition>> *blackboards) {
    if (!tree || !blackboards) {
        return;
    }
 
    for (const auto *bbDef : *blackboards) {
        if (!bbDef || !bbDef->id()) {
            continue;
        }
 
        auto blackboard = std::make_unique<EmberCore::Blackboard>(bbDef->id()->str());
 
        if (bbDef->entries()) {
            for (const auto *entryDef : *bbDef->entries()) {
                if (!entryDef || !entryDef->key()) {
                    continue;
                }
 
                std::string key = entryDef->key()->str();
                std::string typeStr = entryDef->value_type() ? entryDef->value_type()->str() : "STRING";
                std::string value = entryDef->value() ? entryDef->value()->str() : "";
 
                EmberCore::BlackboardEntry::DataType dataType = EmberCore::BlackboardEntry::ParseDataType(typeStr);
 
                blackboard->AddEntry(key, dataType, value);
            }
        }
 
        tree->AddBlackboard(std::move(blackboard));
    }
}
 
EmberCore::Node::Type TreeBuilder::ConvertNodeType(Protocol::NodeType fb_type) {
    switch (fb_type) {
    case Protocol::NodeType_Action:
        return EmberCore::Node::Type::Action;
    case Protocol::NodeType_Control:
        return EmberCore::Node::Type::Control;
    case Protocol::NodeType_Condition:
        return EmberCore::Node::Type::Condition;
    case Protocol::NodeType_Decorator:
        return EmberCore::Node::Type::Decorator;
    case Protocol::NodeType_SubTree:
        return EmberCore::Node::Type::BehaviorTree;
    default:
        return EmberCore::Node::Type::None;
    }
}
 
} // namespace Network
} // namespace Ember