BehaviorTreeValidator.h

Go to the documentation of this file.

#pragma once
 
#include "Core/BehaviorTree.h"
#include "Parsers/ParserConfig.h"
#include "Types/Types.h"
#include <algorithm>
#include <memory>
#include <vector>
 
namespace EmberCore {

class BehaviorTreeValidator {
  public:
    enum class Severity {
        ERROR,  // Critical issue - should prevent loading
        WARNING // Issue that should be warned about but can be ignored
    };
 
    struct ValidationIssue {
        Severity severity;
        EmberCore::String message;
        EmberCore::String node_path; // Path to problematic node (e.g., "Root/Sequence/Action")
 
        ValidationIssue(Severity sev, const EmberCore::String &msg, const EmberCore::String &path = "")
            : severity(sev), message(msg), node_path(path) {}
    };
 
    struct ValidationResult {
        bool is_valid;
        std::vector<ValidationIssue> issues;
 
        ValidationResult() : is_valid(true) {}
 
        void AddError(const EmberCore::String &message, const EmberCore::String &node_path = "") {
            issues.emplace_back(Severity::ERROR, message, node_path);
            is_valid = false;
        }
 
        void AddWarning(const EmberCore::String &message, const EmberCore::String &node_path = "") {
            issues.emplace_back(Severity::WARNING, message, node_path);
        }
 
        bool HasErrors() const {
            return std::any_of(issues.begin(), issues.end(),
                               [](const ValidationIssue &issue) { return issue.severity == Severity::ERROR; });
        }
 
        bool HasWarnings() const {
            return std::any_of(issues.begin(), issues.end(),
                               [](const ValidationIssue &issue) { return issue.severity == Severity::WARNING; });
        }
 
        size_t ErrorCount() const {
            return std::count_if(issues.begin(), issues.end(),
                                 [](const ValidationIssue &issue) { return issue.severity == Severity::ERROR; });
        }
 
        size_t WarningCount() const {
            return std::count_if(issues.begin(), issues.end(),
                                 [](const ValidationIssue &issue) { return issue.severity == Severity::WARNING; });
        }
    };
 
    BehaviorTreeValidator();
    explicit BehaviorTreeValidator(const ParserConfig &config);

    ValidationResult Validate(const BehaviorTree *tree) const;

    static ValidationResult ValidateWithConfig(const BehaviorTree *tree, const ParserConfig &config);
 
  private:
    ParserConfig config_;
 
    // Validation methods
    void ValidateTreeStructure(const BehaviorTree *tree, ValidationResult &result) const;
    void ValidateNode(const Node *node, ValidationResult &result, std::vector<const Node *> &visited,
                      const EmberCore::String &path) const;
    void ValidateNodeType(const Node *node, ValidationResult &result, const EmberCore::String &path) const;
    void ValidateNodeAttributes(const Node *node, ValidationResult &result, const EmberCore::String &path) const;
    void ValidateChildCount(const Node *node, ValidationResult &result, const EmberCore::String &path) const;
    void ValidateBlackboards(const BehaviorTree *tree, ValidationResult &result) const;
 
    // Helper methods
    EmberCore::String BuildNodePath(const EmberCore::String &parent_path, const Node *node) const;
    bool HasCycles(const Node *node, std::vector<const Node *> &visited) const;
};
 
} // namespace EmberCore