BehaviorTreeConfig.cpp

Go to the documentation of this file.

#include "Utils/BehaviorTreeConfig.h"
#include "Utils/Logger.h"
#include <algorithm>
#include <wx/file.h>
#include <wx/fileconf.h>
#include <wx/filename.h>
 
namespace EmberCore {
 
BehaviorTreeConfig::BehaviorTreeConfig() {
    // Initialize with default values (already set in header)
    ClampValues();
}
 
void BehaviorTreeConfig::ResetToDefaults() {
    LOG_INFO("Config", "Resetting configuration to defaults");
 
    // Reset sync settings
    syncSettings_ = SyncSettings{};
 
    // Reset visual settings
    visualSettings_ = VisualSettings{};
 
    // Reset interaction settings
    interactionSettings_ = InteractionSettings{};
 
    // Reset debug settings
    debugSettings_ = DebugSettings{};
 
    ClampValues();
    NotifyChange("all", "reset_to_defaults");
}
 
bool BehaviorTreeConfig::LoadFromFile(const EmberCore::String &filename) {
    LOG_INFO("Config", "Loading configuration from: " + filename);
 
    if (!wxFile::Exists(filename)) {
        LOG_WARNING("Config", "Configuration file does not exist: " + filename);
        return false;
    }
 
    try {
        wxFileConfig config(filename);
 
        // Load sync settings
        config.SetPath("/Sync");
        syncSettings_.enableHierarchyToScene = config.ReadBool("EnableHierarchyToScene", true);
        syncSettings_.enableSceneToHierarchy = config.ReadBool("EnableSceneToHierarchy", true);
        syncSettings_.enableAutoCenter = config.ReadBool("EnableAutoCenter", true);
        syncSettings_.enableSelectionHighlight = config.ReadBool("EnableSelectionHighlight", true);
        syncSettings_.enableHoverEffects = config.ReadBool("EnableHoverEffects", true);
        syncSettings_.centerWithAnimation = config.ReadBool("CenterWithAnimation", false);
        syncSettings_.centeringSpeed = config.ReadDouble("CenteringSpeed", 1.0);
        syncSettings_.preventSyncLoops = config.ReadBool("PreventSyncLoops", true);
 
        // Load visual settings
        config.SetPath("/Visual");
        visualSettings_.selectionBorderWidth = config.ReadLong("SelectionBorderWidth", 3);
        visualSettings_.hoverBorderWidth = config.ReadLong("HoverBorderWidth", 2);
        visualSettings_.highlightOpacity = config.ReadDouble("HighlightOpacity", 1.0);
        visualSettings_.enableAnimations = config.ReadBool("EnableAnimations", true);
        visualSettings_.animationDuration = config.ReadLong("AnimationDuration", 200);
 
        // Load interaction settings
        config.SetPath("/Interaction");
        interactionSettings_.enableDoubleClickExpand = config.ReadBool("EnableDoubleClickExpand", true);
        interactionSettings_.enableRightClickMenu = config.ReadBool("EnableRightClickMenu", true);
        interactionSettings_.enableKeyboardNavigation = config.ReadBool("EnableKeyboardNavigation", true);
        interactionSettings_.enableDragAndDrop = config.ReadBool("EnableDragAndDrop", false);
        interactionSettings_.requireCtrlForMultiSelect = config.ReadBool("RequireCtrlForMultiSelect", true);
        interactionSettings_.enableMiddleClickCenter = config.ReadBool("EnableMiddleClickCenter", true);
        interactionSettings_.doubleClickSpeed = config.ReadLong("DoubleClickSpeed", 500);
 
        // Load debug settings
        config.SetPath("/Debug");
        debugSettings_.enableSyncLogging = config.ReadBool("EnableSyncLogging", false);
        debugSettings_.enablePerformanceMetrics = config.ReadBool("EnablePerformanceMetrics", false);
        debugSettings_.enableDebugOverlay = config.ReadBool("EnableDebugOverlay", false);
        debugSettings_.verboseLogging = config.ReadBool("VerboseLogging", false);
 
        ClampValues();
        NotifyChange("all", "loaded_from_file");
 
        LOG_INFO("Config", "Configuration loaded successfully");
        return true;
    } catch (const std::exception &e) {
        LOG_ERROR("Config", "Error loading configuration: " + std::string(e.what()));
        return false;
    }
}
 
bool BehaviorTreeConfig::SaveToFile(const EmberCore::String &filename) const {
    LOG_INFO("Config", "Saving configuration to: " + filename);
 
    try {
        wxFileName fn(filename);
        // Ensure directory exists
        if (!fn.DirExists()) {
            fn.Mkdir(wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
        }
 
        wxFileConfig config(filename);
 
        // Save sync settings
        config.SetPath("/Sync");
        config.Write("EnableHierarchyToScene", syncSettings_.enableHierarchyToScene);
        config.Write("EnableSceneToHierarchy", syncSettings_.enableSceneToHierarchy);
        config.Write("EnableAutoCenter", syncSettings_.enableAutoCenter);
        config.Write("EnableSelectionHighlight", syncSettings_.enableSelectionHighlight);
        config.Write("EnableHoverEffects", syncSettings_.enableHoverEffects);
        config.Write("CenterWithAnimation", syncSettings_.centerWithAnimation);
        config.Write("CenteringSpeed", syncSettings_.centeringSpeed);
        config.Write("PreventSyncLoops", syncSettings_.preventSyncLoops);
 
        // Save visual settings
        config.SetPath("/Visual");
        config.Write("SelectionBorderWidth", visualSettings_.selectionBorderWidth);
        config.Write("HoverBorderWidth", visualSettings_.hoverBorderWidth);
        config.Write("HighlightOpacity", visualSettings_.highlightOpacity);
        config.Write("EnableAnimations", visualSettings_.enableAnimations);
        config.Write("AnimationDuration", visualSettings_.animationDuration);
 
        // Save interaction settings
        config.SetPath("/Interaction");
        config.Write("EnableDoubleClickExpand", interactionSettings_.enableDoubleClickExpand);
        config.Write("EnableRightClickMenu", interactionSettings_.enableRightClickMenu);
        config.Write("EnableKeyboardNavigation", interactionSettings_.enableKeyboardNavigation);
        config.Write("EnableDragAndDrop", interactionSettings_.enableDragAndDrop);
        config.Write("RequireCtrlForMultiSelect", interactionSettings_.requireCtrlForMultiSelect);
        config.Write("EnableMiddleClickCenter", interactionSettings_.enableMiddleClickCenter);
        config.Write("DoubleClickSpeed", interactionSettings_.doubleClickSpeed);
 
        // Save debug settings
        config.SetPath("/Debug");
        config.Write("EnableSyncLogging", debugSettings_.enableSyncLogging);
        config.Write("EnablePerformanceMetrics", debugSettings_.enablePerformanceMetrics);
        config.Write("EnableDebugOverlay", debugSettings_.enableDebugOverlay);
        config.Write("VerboseLogging", debugSettings_.verboseLogging);
 
        config.Flush();
 
        LOG_INFO("Config", "Configuration saved successfully");
        return true;
    } catch (const std::exception &e) {
        LOG_ERROR("Config", "Error saving configuration: " + std::string(e.what()));
        return false;
    }
}
 
void BehaviorTreeConfig::RegisterChangeCallback(const ConfigChangeCallback &callback) {
    changeCallbacks_.push_back(callback);
}
 
void BehaviorTreeConfig::UnregisterChangeCallback(const ConfigChangeCallback &callback) {
    // Note: This is a simplified implementation. In production, you might want
    // to store callbacks with IDs for easier removal.
    LOG_WARNING("Config", "UnregisterChangeCallback not fully implemented");
}
 
void BehaviorTreeConfig::SetSyncEnabled(bool hierarchyToScene, bool sceneToHierarchy) {
    bool changed = false;
 
    if (syncSettings_.enableHierarchyToScene != hierarchyToScene) {
        syncSettings_.enableHierarchyToScene = hierarchyToScene;
        NotifyChange("sync", "hierarchy_to_scene");
        changed = true;
    }
 
    if (syncSettings_.enableSceneToHierarchy != sceneToHierarchy) {
        syncSettings_.enableSceneToHierarchy = sceneToHierarchy;
        NotifyChange("sync", "scene_to_hierarchy");
        changed = true;
    }
 
    if (changed) {
        LOG_INFO("Config", "Sync settings updated - H→S: " + std::to_string(hierarchyToScene) +
                               ", S→H: " + std::to_string(sceneToHierarchy));
    }
}
 
void BehaviorTreeConfig::SetCenteringEnabled(bool enabled, bool animated) {
    bool changed = false;
 
    if (syncSettings_.enableAutoCenter != enabled) {
        syncSettings_.enableAutoCenter = enabled;
        NotifyChange("sync", "auto_center");
        changed = true;
    }
 
    if (syncSettings_.centerWithAnimation != animated) {
        syncSettings_.centerWithAnimation = animated;
        NotifyChange("sync", "center_animation");
        changed = true;
    }
 
    if (changed) {
        LOG_INFO("Config", "Centering settings updated - Enabled: " + std::to_string(enabled) +
                               ", Animated: " + std::to_string(animated));
    }
}
 
void BehaviorTreeConfig::SetHighlightingEnabled(bool enabled) {
    if (syncSettings_.enableSelectionHighlight != enabled) {
        syncSettings_.enableSelectionHighlight = enabled;
        NotifyChange("sync", "selection_highlight");
        LOG_INFO("Config", "Highlighting enabled: " + std::to_string(enabled));
    }
}
 
void BehaviorTreeConfig::SetDebugMode(bool enabled) {
    debugSettings_.enableSyncLogging = enabled;
    debugSettings_.verboseLogging = enabled;
    NotifyChange("debug", "debug_mode");
    LOG_INFO("Config", "Debug mode: " + std::to_string(enabled));
}
 
bool BehaviorTreeConfig::ValidateSettings() const { return GetValidationErrors().empty(); }
 
std::vector<std::string> BehaviorTreeConfig::GetValidationErrors() const {
    std::vector<std::string> errors;
 
    // Validate sync settings
    if (syncSettings_.centeringSpeed < 0.1f || syncSettings_.centeringSpeed > 5.0f) {
        errors.push_back("Centering speed must be between 0.1 and 5.0");
    }
 
    // Validate visual settings
    if (visualSettings_.selectionBorderWidth < 1 || visualSettings_.selectionBorderWidth > 10) {
        errors.push_back("Selection border width must be between 1 and 10");
    }
    if (visualSettings_.highlightOpacity < 0.0f || visualSettings_.highlightOpacity > 1.0f) {
        errors.push_back("Highlight opacity must be between 0.0 and 1.0");
    }
    if (visualSettings_.animationDuration < 50 || visualSettings_.animationDuration > 2000) {
        errors.push_back("Animation duration must be between 50 and 2000 ms");
    }
 
    // Validate interaction settings
    if (interactionSettings_.doubleClickSpeed < 100 || interactionSettings_.doubleClickSpeed > 2000) {
        errors.push_back("Double-click speed must be between 100 and 2000 ms");
    }
 
    return errors;
}
 
void BehaviorTreeConfig::NotifyChange(const std::string &category, const std::string &setting) {
    for (const auto &callback : changeCallbacks_) {
        try {
            callback(category, setting);
        } catch (const std::exception &e) {
            LOG_ERROR("Config", "Error in change callback: " + std::string(e.what()));
        }
    }
}
 
void BehaviorTreeConfig::ClampValues() {
    // Clamp sync settings
    syncSettings_.centeringSpeed = std::max(0.1f, std::min(5.0f, syncSettings_.centeringSpeed));
 
    // Clamp visual settings
    visualSettings_.selectionBorderWidth = std::max(1, std::min(10, visualSettings_.selectionBorderWidth));
    visualSettings_.hoverBorderWidth = std::max(1, std::min(10, visualSettings_.hoverBorderWidth));
    visualSettings_.highlightOpacity = std::max(0.0f, std::min(1.0f, visualSettings_.highlightOpacity));
    visualSettings_.animationDuration = std::max(50, std::min(2000, visualSettings_.animationDuration));
 
    // Clamp interaction settings
    interactionSettings_.doubleClickSpeed = std::max(100, std::min(2000, interactionSettings_.doubleClickSpeed));
}
 
// BehaviorTreeConfigManager implementation
BehaviorTreeConfigManager &BehaviorTreeConfigManager::GetInstance() {
    static BehaviorTreeConfigManager instance;
    return instance;
}
 
bool BehaviorTreeConfigManager::IsSyncEnabled(bool hierarchyToScene) const {
    return hierarchyToScene ? config_.GetSyncSettings().enableHierarchyToScene
                            : config_.GetSyncSettings().enableSceneToHierarchy;
}
 
bool BehaviorTreeConfigManager::IsCenteringEnabled() const { return config_.GetSyncSettings().enableAutoCenter; }
 
bool BehaviorTreeConfigManager::IsHighlightingEnabled() const {
    return config_.GetSyncSettings().enableSelectionHighlight;
}
 
} // namespace EmberCore