StateManager.cpp

Go to the documentation of this file.

#include "Network/Builder/StateManager.h"
 
#include <algorithm>
 
namespace Ember {
namespace Network {
 
StateManager::StateManager(std::shared_ptr<EmberCore::BehaviorTree> tree) : m_tree(std::move(tree)) {}
 
void StateManager::ApplyTickUpdate(const Protocol::TickUpdate *update) {
    if (!update) {
        return;
    }
 
    std::lock_guard<std::mutex> lock(m_mutex);
 
    m_currentTick = update->tick_number();
 
    if (update->execution_path()) {
        m_executionPath.clear();
        m_executionPath.reserve(update->execution_path()->size());
        for (auto id : *update->execution_path()) {
            m_executionPath.push_back(id);
        }
    }
 
    if (update->states()) {
        bool isDelta = update->is_delta();
 
        if (!isDelta) {
            for (auto &pair : m_nodeStates) {
                pair.second = Protocol::NodeStatus_Idle;
            }
        }
 
        for (const auto *state : *update->states()) {
            if (!state) {
                continue;
            }
 
            int64_t nodeId = state->id();
            NodeStatus newStatus = state->status();
 
            auto it = m_nodeStates.find(nodeId);
            NodeStatus oldStatus = (it != m_nodeStates.end()) ? it->second : Protocol::NodeStatus_Idle;
 
            m_nodeStates[nodeId] = newStatus;
 
            if (oldStatus != newStatus) {
                m_changedNodeIds.push_back(nodeId);
                NotifyStateChange(nodeId, oldStatus, newStatus);
            }
        }
    }
 
    if (m_historyEnabled) {
        SaveSnapshot();
    }
 
    NotifyTick(m_currentTick);
}
 
void StateManager::ApplyBlackboardUpdate(const Protocol::BlackboardUpdate *update) {
    if (!update || !m_tree) {
        return;
    }
 
    std::lock_guard<std::mutex> lock(m_mutex);
 
    if (!update->blackboard_id()) {
        return;
    }
 
    auto *blackboard = m_tree->GetBlackboard(update->blackboard_id()->str());
    if (!blackboard) {
        return;
    }
 
    if (update->updates()) {
        for (const auto *entryUpdate : *update->updates()) {
            if (!entryUpdate || !entryUpdate->key()) {
                continue;
            }
 
            auto *entry = blackboard->GetEntry(entryUpdate->key()->str());
            if (entry && entryUpdate->value()) {
                entry->SetValue(entryUpdate->value()->str());
            }
        }
    }
}
 
void StateManager::Reset() {
    std::lock_guard<std::mutex> lock(m_mutex);
 
    for (auto &pair : m_nodeStates) {
        NodeStatus oldStatus = pair.second;
        pair.second = Protocol::NodeStatus_Idle;
 
        if (oldStatus != Protocol::NodeStatus_Idle) {
            NotifyStateChange(pair.first, oldStatus, Protocol::NodeStatus_Idle);
        }
    }
 
    m_executionPath.clear();
    m_currentTick = 0;
 
    NotifyTick(0);
}
 
StateManager::NodeStatus StateManager::GetNodeStatus(int64_t node_id) const {
    std::lock_guard<std::mutex> lock(m_mutex);
 
    auto it = m_nodeStates.find(node_id);
    if (it != m_nodeStates.end()) {
        return it->second;
    }
    return Protocol::NodeStatus_Idle;
}
 
std::vector<int64_t> StateManager::GetAndClearChangedNodes() {
    std::lock_guard<std::mutex> lock(m_mutex);
    std::vector<int64_t> result;
    result.swap(m_changedNodeIds);
    return result;
}
 
void StateManager::EnableHistory(size_t max_ticks) {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_historyEnabled = true;
    m_maxHistoryTicks = max_ticks;
}
 
void StateManager::DisableHistory() {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_historyEnabled = false;
    m_history.clear();
}
 
void StateManager::SeekToTick(int64_t tick_number) {
    std::lock_guard<std::mutex> lock(m_mutex);
 
    auto it = std::find_if(m_history.begin(), m_history.end(),
                           [tick_number](const TickSnapshot &s) { return s.tick_number == tick_number; });
 
    if (it == m_history.end()) {
        return;
    }
 
    m_currentTick = it->tick_number;
    m_nodeStates = it->states;
    m_executionPath = it->execution_path;
}
 
void StateManager::AddStateChangeCallback(StateChangeCallback callback) {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_stateCallbacks.push_back(std::move(callback));
}
 
void StateManager::AddTickCallback(TickCallback callback) {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_tickCallbacks.push_back(std::move(callback));
}
 
void StateManager::ClearCallbacks() {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_stateCallbacks.clear();
    m_tickCallbacks.clear();
}
 
void StateManager::NotifyStateChange(int64_t node_id, NodeStatus old_status, NodeStatus new_status) {
    for (const auto &callback : m_stateCallbacks) {
        if (callback) {
            callback(node_id, old_status, new_status);
        }
    }
}
 
void StateManager::NotifyTick(int64_t tick_number) {
    for (const auto &callback : m_tickCallbacks) {
        if (callback) {
            callback(tick_number);
        }
    }
}
 
void StateManager::SaveSnapshot() {
    TickSnapshot snapshot;
    snapshot.tick_number = m_currentTick;
    snapshot.states = m_nodeStates;
    snapshot.execution_path = m_executionPath;
 
    m_history.push_back(std::move(snapshot));
 
    while (m_history.size() > m_maxHistoryTicks) {
        m_history.erase(m_history.begin());
    }
}
 
} // namespace Network
} // namespace Ember