Wal.hpp

Go to the documentation of this file.

//
// Created by Zoe Roux on 2021-05-14.
//
 
 
#pragma once
 
#include <utility>
#include <vector>
#include <string>
#include <memory>
#include <typeinfo>
#include "Exception/WalError.hpp"
#include "System/ISystem.hpp"
#include "Models/Callback.hpp"
#include "Scene/Scene.hpp"
 
#if defined(PLATFORM_WEB)
#include <emscripten/emscripten.h>
#endif
 
namespace WAL
{
    class Entity;
 
    class Wal
    {
    private:
        std::vector<std::unique_ptr<ISystem>> _systems = {};
 
        std::shared_ptr<Scene> _scene;
 
        template<typename T>
        void _run(const Callback<Wal &, T &> &callback, T state = T())
        {
            auto lastTick = std::chrono::steady_clock::now();
            std::chrono::nanoseconds fBehind(0);
 
            while (!this->shouldClose) {
                auto now = std::chrono::steady_clock::now();
                std::chrono::nanoseconds dtime = now - lastTick;
                fBehind += dtime;
                lastTick = now;
 
                while (fBehind > Wal::timestep) {
                    fBehind -= Wal::timestep;
                    for (auto &system : this->_systems)
                        system->fixedUpdate();
                }
                for (auto &system : this->_systems)
                    system->update(dtime);
                this->_scene->applyChanges();
                callback(*this, state);
            }
        }
 
#if defined(PLATFORM_WEB)
        template<typename T>
        static void _runIteration(void *param)
        {
            static auto [wal, callback, state] = *reinterpret_cast<std::tuple<Wal &, const Callback<Wal &, T &> &, T &> *>(param);
            static auto lastTick = std::chrono::steady_clock::now();
            static std::chrono::nanoseconds fBehind(0);
 
            auto now = std::chrono::steady_clock::now();
            std::chrono::nanoseconds dtime = now - lastTick;
            fBehind += dtime;
            lastTick = now;
            while (fBehind > Wal::timestep) {
                fBehind -= Wal::timestep;
                for (auto &system : wal._systems)
                    system->fixedUpdate();
            }
            for (auto &system : wal._systems)
                system->update(dtime);
            wal._scene->applyChanges();
            callback(wal, state);
        }
#endif
    public:
        bool shouldClose = false;
        static constexpr std::chrono::nanoseconds timestep = std::chrono::milliseconds(32);
 
        std::shared_ptr<Scene> getScene() const
        {
            return this->_scene;
        }
 
        void changeScene(std::shared_ptr<Scene> newScene)
        {
            if (this->_scene) {
                for (auto &entity : this->_scene->getEntities()) {
                    for (auto &cmp : entity._components)
                        cmp.second->onStop();
                }
            }
            this->_scene = std::move(newScene);
            for (auto &entity : this->_scene->getEntities()) {
                for (auto &cmp : entity._components)
                    cmp.second->onStart();
            }
        }
 
        template<typename T, class ...Types>
        Wal &addSystem(Types &&...params)
        {
            const std::type_info &type = typeid(T);
            auto existing = std::find_if(this->_systems.begin(), this->_systems.end(), [&type] (auto &sys) {
                return typeid(*sys) == type;
            });
            if (existing != this->_systems.end())
                throw DuplicateError("A system of the type \"" + std::string(type.name()) + "\" already exists.");
            this->_systems.push_back(std::make_unique<T>(*this, std::forward<Types>(params)...));
            return *this;
        }
 
        template<typename T>
        Wal &addSystem(const T &system)
        {
            const std::type_info &type = typeid(T);
            auto existing = std::find_if(this->_systems.begin(), this->_systems.end(), [&type] (auto &sys) {
                return typeid(*sys) == type;
            });
            if (existing != this->_systems.end())
                throw DuplicateError("A system of the type \"" + std::string(type.name()) + "\" already exists.");
            this->_systems.push_back(std::make_unique<T>(system));
            return *this;
        }
 
        template<typename T>
        T &getSystem()
        {
            const std::type_info &type = typeid(T);
            auto existing = std::find_if(this->_systems.begin(), this->_systems.end(), [&type] (auto &sys) {
                return typeid(*sys) == type;
            });
            if (existing == this->_systems.end())
                throw NotFoundError("A system of the type \"" + std::string(type.name()) + "\" could not be found.");
            return *static_cast<T *>(existing->get());
        }
 
        template<typename T>
        Wal &removeSystem()
        {
            const std::type_info &type = typeid(T);
            auto existing = std::find_if(this->_systems.begin(), this->_systems.end(), [&type] (auto &sys) {
                return typeid(*sys) == type;
            });
            if (existing == this->_systems.end())
                throw NotFoundError("No system could be found with the type \"" + std::string(type.name()) + "\".");
            this->_systems.erase(existing);
            return *this;
        }
 
        template<typename T>
        void run(const Callback<Wal &, T &> &callback, T state = T())
        {
            #if defined(PLATFORM_WEB)
                std::tuple<Wal &, const Callback<Wal &, T &> &, T &> iterationParams(*this, callback, state);
                return emscripten_set_main_loop_arg((em_arg_callback_func)_runIteration<T>, (void *)&iterationParams, 0, 1);
            #else
                return this->_run(callback, state);
            #endif
        }
 
        Wal() = default;
        Wal(const Wal &) = delete;
        ~Wal() = default;
        Wal &operator=(const Wal &) = delete;
    };
} // namespace WAL