World.h

#pragma once
 
// Standard.
#include <memory>
#include <chrono>
#include <string>
#include <variant>
#include <filesystem>
#include <unordered_set>
#include <mutex>
#include <atomic>
 
// Custom.
#include "misc/Globals.h"
#include "misc/Error.h"
 
// External.
#include "GcPtr.h"
 
namespace ne {
    class GameManager;
    class Node;
 
    struct CalledEveryFrameNodes {
        CalledEveryFrameNodes() = default;
 
        CalledEveryFrameNodes(const CalledEveryFrameNodes&) = delete;
        CalledEveryFrameNodes& operator=(const CalledEveryFrameNodes&) = delete;
 
        std::pair<std::recursive_mutex, std::unordered_set<Node*>> mtxFirstTickGroup;
 
        std::pair<std::recursive_mutex, std::unordered_set<Node*>> mtxSecondTickGroup;
    };
 
    class World {
        // Nodes notify the world about being spawned/despawned.
        friend class Node;
 
    public:
        World() = delete;
 
        World(const World&) = delete;
        World& operator=(const World&) = delete;
 
        World(World&&) = delete;
        World& operator=(World&&) = delete;
 
        ~World();
 
        static std::unique_ptr<World>
        createWorld(GameManager* pGameManager, size_t iWorldSize = Globals::getDefaultWorldSize());
 
        static std::variant<std::unique_ptr<World>, Error> loadNodeTreeAsWorld(
            GameManager* pGameManager,
            const std::filesystem::path& pathToNodeTree,
            size_t iWorldSize = Globals::getDefaultWorldSize());
 
        size_t getTotalSpawnedNodeCount();
 
        void destroyWorld();
 
        CalledEveryFrameNodes* getCalledEveryFrameNodes();
 
        std::pair<std::recursive_mutex, std::unordered_set<Node*>>* getReceivingInputNodes();
 
        sgc::GcPtr<Node> getRootNode();
 
        size_t getCalledEveryFrameNodeCount();
 
        float getWorldTimeInSeconds() const;
 
        size_t getWorldSize() const;
 
        bool isNodeSpawned(size_t iNodeId);
 
    private:
        World(GameManager* pGameManager, sgc::GcPtr<Node> pRootNode, size_t iWorldSize);
 
        void onNodeSpawned(Node* pNode);
 
        void onNodeDespawned(Node* pNode);
 
        void onSpawnedNodeChangedIsCalledEveryFrame(Node* pNode);
 
        void onSpawnedNodeChangedIsReceivingInput(Node* pNode);
 
        void addNodeToReceivingInputArray(Node* pNode);
 
        void addNodeToCalledEveryFrameArrays(Node* pNode);
 
        void removeNodeFromCalledEveryFrameArrays(Node* pNode);
 
        void removeNodeFromReceivingInputArray(Node* pNode);
 
        GameManager* pGameManager = nullptr;
 
        std::pair<std::recursive_mutex, bool> mtxIsDestroyed;
 
        std::pair<std::mutex, sgc::GcPtr<Node>> mtxRootNode;
 
        CalledEveryFrameNodes calledEveryFrameNodes;
 
        std::pair<std::recursive_mutex, std::unordered_set<Node*>> mtxReceivingInputNodes;
 
        std::pair<std::recursive_mutex, std::unordered_map<size_t, Node*>> mtxSpawnedNodes;
 
        std::atomic<size_t> iTotalSpawnedNodeCount{0};
 
        const size_t iWorldSize = 0;
 
        std::chrono::steady_clock::time_point timeWhenWorldCreated;
    };
} // namespace ne