StateManager.h

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <unordered_map>
#include <vector>
 
#include "Core/BehaviorTree.h"
#include "Network/Schema/generated/ember_protocol_generated.h"
 
namespace Ember {
namespace Network {
 
class StateManager {
  public:
    using NodeStatus = Protocol::NodeStatus;
    using StateChangeCallback = std::function<void(int64_t node_id, NodeStatus old_status, NodeStatus new_status)>;
    using TickCallback = std::function<void(int64_t tick_number)>;
 
    struct TickSnapshot {
        int64_t tick_number = 0;
        int64_t timestamp_ms = 0;
        std::unordered_map<int64_t, NodeStatus> states;
        std::vector<int64_t> execution_path;
    };
 
    explicit StateManager(std::shared_ptr<EmberCore::BehaviorTree> tree);
    ~StateManager() = default;
 
    void ApplyTickUpdate(const Protocol::TickUpdate *update);
 
    void ApplyBlackboardUpdate(const Protocol::BlackboardUpdate *update);
 
    void Reset();
 
    NodeStatus GetNodeStatus(int64_t node_id) const;
    int64_t GetCurrentTick() const { return m_currentTick; }
    const std::vector<int64_t> &GetExecutionPath() const { return m_executionPath; }
 
    std::vector<int64_t> GetAndClearChangedNodes();
 
    void EnableHistory(size_t max_ticks = 1000);
    void DisableHistory();
    bool IsHistoryEnabled() const { return m_historyEnabled; }
    const std::vector<TickSnapshot> &GetHistory() const { return m_history; }
    void SeekToTick(int64_t tick_number);
 
    void AddStateChangeCallback(StateChangeCallback callback);
    void AddTickCallback(TickCallback callback);
 
    void ClearCallbacks();
 
  private:
    void NotifyStateChange(int64_t node_id, NodeStatus old_status, NodeStatus new_status);
    void NotifyTick(int64_t tick_number);
    void SaveSnapshot();
 
    std::shared_ptr<EmberCore::BehaviorTree> m_tree;
 
    std::unordered_map<int64_t, NodeStatus> m_nodeStates;
    std::vector<int64_t> m_executionPath;
    int64_t m_currentTick = 0;
 
    bool m_historyEnabled = false;
    size_t m_maxHistoryTicks = 1000;
    std::vector<TickSnapshot> m_history;
 
    std::vector<int64_t> m_changedNodeIds;
 
    std::vector<StateChangeCallback> m_stateCallbacks;
    std::vector<TickCallback> m_tickCallbacks;
 
    mutable std::mutex m_mutex;
};
 
} // namespace Network
} // namespace Ember