.clang-format

@@ -0,0 +1,3 @@
+BasedOnStyle: LLVM
+IndentWidth: 2
+BreakBeforeBraces: Allman

.gitignore

@@ -7,6 +7,7 @@
 !/tests
 
 # Include files
+!/.clang-format
 !/.gitignore
 !/CMakeLists.txt
 !/Makefile

CMakeLists.txt

@@ -30,16 +30,25 @@ add_executable(engine_test
   src/engine/core/engine.cpp
   src/engine/core/engine_db_provider.cpp
 )
+add_executable(lifecycle_test
+  tests/engine/lifecycle_test.cpp
+  src/engine/core/engine.cpp
+  src/engine/core/engine_db_provider.cpp
+)
 
 target_include_directories(event_bus_test PUBLIC "${CMAKE_SOURCE_DIR}/include")
 target_link_libraries(event_bus_test PRIVATE SQLite::SQLite3)
 
-target_include_directories(db_provider_test PUBLIC "${CMAKE_SOURCE_DIR}/include")
+target_include_directories(db_provider_test PUBLIC
+                           "${CMAKE_SOURCE_DIR}/include")
 target_link_libraries(db_provider_test PRIVATE SQLite::SQLite3)
 
 target_include_directories(engine_test PUBLIC "${CMAKE_SOURCE_DIR}/include")
 target_link_libraries(engine_test PRIVATE SQLite::SQLite3)
 
+target_include_directories(lifecycle_test PUBLIC "${CMAKE_SOURCE_DIR}/include")
+target_link_libraries(lifecycle_test PRIVATE SQLite::SQLite3)
+
 add_test(
   NAME "Event Bus"
   COMMAND event_bus_test
@@ -52,3 +61,7 @@ add_test(
   NAME "Engine"
   COMMAND engine_test
 )
+add_test(
+  NAME "Lifecycle"
+  COMMAND lifecycle_test
+)

include/engine/core/engine.hpp

@@ -1,32 +1,50 @@
 #ifndef __MCS_ENGINE_HPP__
 #define __MCS_ENGINE_HPP__
 
+#include <cstdint>
+#include <engine/core/engine_db_provider.hpp>
 #include <engine/core/engine_module.hpp>
 #include <engine/core/engine_module_api.hpp>
-#include <engine/core/engine_db_provider.hpp>
-#include <cstdint>
 #include <memory>
 #include <vector>
 
-/// Magic Srolls engine core
+/// Ядро движка Magic Srolls
 class MscEngine : public IMscEngineModuleAPI
 {
 private:
-  /// Loaded modules list
+  /// @brief Загруженные модули
   std::vector<std::shared_ptr<MscEngineModule>> _modules;
+
+  /// @brief Общая событийная шина движка
   MscEventBus _bus;
 
+  /// @brief Флаг работы движка
+  bool _isRunning = false;
+
+  /// @brief Время последнего тика
+  clock::time_point _lastUpdate;
+
 public:
-  /// Actual version
+  /// @brief Номер ревизии
   static uint16_t REV;
 
   MscEngine(std::vector<std::shared_ptr<MscEngineModule>> modules);
+  ~MscEngine() = default;
+
+  /// @brief Запустить движок
+  void start();
+
+  /// @brief Остановить движок
+  void stop();
 
   MscEventBus &getBus() override;
-  std::unordered_map<std::string, std::uint16_t> getLoadedModules() const override;
-  MscEngineModule &getModule(const std::string &name) override;
+  std::unordered_map<std::string, std::uint16_t>
+  getLoadedModules() const override;
+  std::shared_ptr<MscEngineModule> &getModule(const std::string &name) override;
   std::unique_ptr<MscEngineDBProvider> createDBProvider() override;
-  std::unique_ptr<MscEngineDBProvider> createDBProvider(const std::string &filepath) override;
+  std::unique_ptr<MscEngineDBProvider>
+  createDBProvider(const std::string &filepath) override;
+  void requestStop() override;
 };
 
 #endif // __MCS_ENGINE_HPP__

include/engine/core/engine_module.hpp

@@ -1,8 +1,8 @@
 #ifndef __MCS_ENGINE_MODULE_HPP__
 #define __MCS_ENGINE_MODULE_HPP__
 
-#include "engine/utils/rev_range.hpp"
 #include "engine/core/engine_module_api.hpp"
+#include "engine/utils/rev_range.hpp"
 #include <cstdint>
 #include <string>
 #include <unordered_map>
@@ -23,8 +23,27 @@ public:
   virtual const std::unordered_map<std::string, MscRevisionRange> &
   getDependencies() const = 0;
 
-  /// Module initialization phase
+  /// @brief Module initialization
+  /// @param engine engine public API for modules
   virtual void onInitialize(IMscEngineModuleAPI &engine) = 0;
+
+  /// @brief Engine start event handler
+  /// @param engine engine public API for modules
+  virtual void onStart(IMscEngineModuleAPI &engine) = 0;
+
+  /// @brief Engine update cycle step
+  /// @param engine engine public API for modules
+  /// @param dt loop delta
+  virtual void onUpdate(IMscEngineModuleAPI &engine,
+                        IMscEngineModuleAPI::clock::duration dt) = 0;
+
+  /// @brief Engine stop event handler
+  /// @param engine engine public API for modules
+  virtual void onStop(IMscEngineModuleAPI &engine) = 0;
+
+  /// @brief Module destroying
+  /// @param engine engine public API for modules
+  virtual void onDestory(IMscEngineModuleAPI &engine) = 0;
 };
 
 #endif // __MCS_ENGINE_MODULE_HPP__

include/engine/core/engine_module_api.hpp

@@ -1,34 +1,43 @@
 #ifndef __MSC_ENGINE_MODULE_API_HPP__
 #define __MSC_ENGINE_MODULE_API_HPP__
 
+#include <cstdint>
 #include <engine/core/engine_bus.hpp>
 #include <engine/core/engine_db_provider.hpp>
-#include <cstdint>
+#include <memory>
 #include <string>
 #include <unordered_map>
-#include <memory>
 
 class MscEngineModule;
 
+/// @brief Публичный API движка для модулей
 class IMscEngineModuleAPI
 {
 public:
+  using clock = std::chrono::steady_clock;
+
   virtual ~IMscEngineModuleAPI() = default;
 
-  /// @brief Get access to engine event bus
+  /// @brief Получить доступ к событийной шине
   virtual MscEventBus &getBus() = 0;
 
-  /// @brief Get access to loaded module list
-  virtual std::unordered_map<std::string, std::uint16_t> getLoadedModules() const = 0;
+  /// @brief Получить список загруженных модулей
+  virtual std::unordered_map<std::string, std::uint16_t>
+  getLoadedModules() const = 0;
 
-  /// @brief Access module by its name
-  virtual MscEngineModule &getModule(const std::string &name) = 0;
+  /// @brief Получить прямой доступ к модулю
+  virtual std::shared_ptr<MscEngineModule> &
+  getModule(const std::string &name) = 0;
 
-  /// @brief Create database provider with in-memory database
+  /// @brief Создать провайдер БД с хранением в памяти
   virtual std::unique_ptr<MscEngineDBProvider> createDBProvider() = 0;
 
-  /// @brief Create database provider with file database
-  virtual std::unique_ptr<MscEngineDBProvider> createDBProvider(const std::string &filepath) = 0;
+  /// @brief Создать провайдер БД с указанным файлом
+  virtual std::unique_ptr<MscEngineDBProvider>
+  createDBProvider(const std::string &filepath) = 0;
+
+  /// @brief Запросить остановку движка
+  virtual void requestStop() = 0;
 };
 
 #endif // __MSC_ENGINE_MODULE_API_HPP__

include/engine/modules/test1/test1.hpp

@@ -1,21 +0,0 @@
-#ifndef __MSC_TEST_1_MODULE_HPP__
-#define __MSC_TEST_1_MODULE_HPP__
-
-#include "engine/core/engine_module.hpp"
-#include "engine/core/engine_module_api.hpp"
-#include <cstdint>
-
-class Test1Module : public MscEngineModule
-{
-public:
-  ~Test1Module() = default;
-
-  std::string getName() const override;
-  uint16_t getRev() const override;
-  const std::unordered_map<std::string, MscRevisionRange> &
-  getDependencies() const override;
-
-  void onInitialize(IMscEngineModuleAPI &engine) override;
-};
-
-#endif // __MSC_TEST_1_MODULE_HPP__

src/engine/core/engine.cpp

@@ -1,12 +1,16 @@
+#include "engine/core/engine_module_api.hpp"
+#include <chrono>
 #include <cstdint>
 #include <engine/core/engine.hpp>
+#include <functional>
 #include <memory>
 #include <stdexcept>
 #include <string>
+#include <thread>
 #include <unordered_map>
 #include <vector>
 
-uint16_t MscEngine::REV = 0;
+std::uint16_t MscEngine::REV = 1;
 
 MscEngine::MscEngine(std::vector<std::shared_ptr<MscEngineModule>> modules)
 {
@@ -49,17 +53,71 @@ MscEngine::MscEngine(std::vector<std::shared_ptr<MscEngineModule>> modules)
             std::to_string(current_rev));
       }
     }
+
+    module.get()->onInitialize(*this);
   }
 
   _modules = std::move(modules);
 }
 
-MscEventBus &MscEngine::getBus()
+void MscEngine::start()
 {
-  return _bus;
+  if (_isRunning)
+    return;
+
+  _isRunning = true;
+  _lastUpdate = clock::now();
+
+  for (auto &m : _modules)
+    m->onStart(*this);
+
+  constexpr auto tickDuration = std::chrono::milliseconds(50);
+  auto nextTick = clock::now();
+
+  using UpdateFn = std::function<void(IMscEngineModuleAPI & engine,
+                                      IMscEngineModuleAPI::clock::duration dt)>;
+  std::vector<UpdateFn> updateFns;
+  updateFns.reserve(_modules.size());
+
+  for (auto &m : _modules)
+    updateFns.emplace_back([m](IMscEngineModuleAPI &engine,
+                               IMscEngineModuleAPI::clock::duration dt)
+                           { m->onUpdate(engine, dt); });
+
+  while (_isRunning)
+  {
+    nextTick += tickDuration;
+    const auto currentTick = clock::now();
+    const auto dt = currentTick - _lastUpdate;
+
+    // TODO: process
+
+    for (auto upd : updateFns)
+      upd(*this, dt);
+
+    _lastUpdate = currentTick;
+
+    std::this_thread::sleep_until(nextTick);
+    if (clock::now() > nextTick + std::chrono::seconds(1))
+      nextTick = clock::now();
+  }
+
+  for (auto &m : _modules)
+    m->onStop(*this);
 }
 
-std::unordered_map<std::string, std::uint16_t> MscEngine::getLoadedModules() const
+void MscEngine::stop()
+{
+  if (!_isRunning)
+    return;
+
+  _isRunning = false;
+}
+
+MscEventBus &MscEngine::getBus() { return _bus; }
+
+std::unordered_map<std::string, std::uint16_t>
+MscEngine::getLoadedModules() const
 {
   std::unordered_map<std::string, std::uint16_t> result;
   for (const auto &module : _modules)
@@ -74,12 +132,12 @@ std::unordered_map<std::string, std::uint16_t> MscEngine::getLoadedModules() con
   return result;
 }
 
-MscEngineModule &MscEngine::getModule(const std::string &name)
+std::shared_ptr<MscEngineModule> &MscEngine::getModule(const std::string &name)
 {
   for (auto &module : _modules)
   {
     if (module.get()->getName() == name)
-      return *module.get();
+      return module;
   }
 
   throw std::runtime_error("Module not found: " + name);
@@ -90,7 +148,13 @@ std::unique_ptr<MscEngineDBProvider> MscEngine::createDBProvider()
   return std::make_unique<MscEngineDBProvider>();
 }
 
-std::unique_ptr<MscEngineDBProvider> MscEngine::createDBProvider(const std::string &filepath)
+std::unique_ptr<MscEngineDBProvider>
+MscEngine::createDBProvider(const std::string &filepath)
 {
   return std::make_unique<MscEngineDBProvider>(filepath);
 }
+
+void MscEngine::requestStop()
+{
+  this->stop(); // TODO: заменить на флаг
+}

src/engine/modules/test1/test1.hpp

@@ -1,22 +0,0 @@
-#include "engine/modules/test1/test1.hpp"
-#include "engine/core/engine_module_api.hpp"
-#include "engine/utils/rev_range.hpp"
-#include <cstdint>
-#include <string>
-#include <unordered_map>
-
-std::string Test1Module::getName() const { return "test1"; }
-
-uint16_t Test1Module::getRev() const { return 1; }
-
-const std::unordered_map<std::string, MscRevisionRange> &
-Test1Module::getDependencies() const
-{
-  static const std::unordered_map<std::string, MscRevisionRange> deps{};
-  return deps;
-}
-
-void Test1Module::onInitialize(IMscEngineModuleAPI &engine)
-{
-  (void)(engine);
-}

src/main.cpp

@@ -1,16 +1,9 @@
-#include "engine/modules/test1/test1.hpp"
 #include <cstdio>
 #include <engine/core/engine.hpp>
-#include <memory>
 #include <stdlib.h>
-#include <vector>
 
 int main(int argc, char **argv)
 {
-  auto engine =
-      std::make_unique<MscEngine>(std::vector<std::shared_ptr<MscEngineModule>>{
-          std::make_shared<Test1Module>()});
-
-  printf("Hello, CMake, %p!\n", &engine);
+  printf("Hello, engine!\n");
   return 0;
 }

tests/engine/engine_test.cpp

@@ -1,149 +1,157 @@
 #include <cassert>
-#include <string>
 #include <cstdint>
-#include <memory>
-#include <stdexcept>
-#include <unordered_map>
-#include <engine/utils/rev_range.hpp>
 #include <engine/core/engine.hpp>
 #include <engine/core/engine_module.hpp>
+#include <engine/utils/rev_range.hpp>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
 
 class FirstTestModuleR1 : public MscEngineModule
 {
 public:
-    std::string getName() const override
-    {
-        return "first_tmod";
-    };
+  std::string getName() const override { return "first_tmod"; };
 
-    std::uint16_t getRev() const override
-    {
-        return 1;
-    }
+  std::uint16_t getRev() const override { return 1; }
 
-    const std::unordered_map<std::string, MscRevisionRange> &getDependencies() const override
-    {
-        static const std::unordered_map<std::string, MscRevisionRange> deps{};
-        return deps;
-    }
+  const std::unordered_map<std::string, MscRevisionRange> &
+  getDependencies() const override
+  {
+    static const std::unordered_map<std::string, MscRevisionRange> deps{};
+    return deps;
+  }
 
-    void onInitialize(IMscEngineModuleAPI &engine) override {}
+  void onInitialize(IMscEngineModuleAPI &engine) override {}
+  void onStart(IMscEngineModuleAPI &engine) override {}
+  void onUpdate(IMscEngineModuleAPI &engine,
+                IMscEngineModuleAPI::clock::duration dt) override
+  {
+  }
+  void onStop(IMscEngineModuleAPI &engine) override {}
+  void onDestory(IMscEngineModuleAPI &engine) override {}
 };
 
 class FirstTestModuleR2 : public MscEngineModule
 {
 public:
-    std::string getName() const override
-    {
-        return "first_tmod";
-    };
+  std::string getName() const override { return "first_tmod"; };
 
-    std::uint16_t getRev() const override
-    {
-        return 2;
-    }
+  std::uint16_t getRev() const override { return 2; }
 
-    const std::unordered_map<std::string, MscRevisionRange> &getDependencies() const override
-    {
-        static const std::unordered_map<std::string, MscRevisionRange> deps{};
-        return deps;
-    }
+  const std::unordered_map<std::string, MscRevisionRange> &
+  getDependencies() const override
+  {
+    static const std::unordered_map<std::string, MscRevisionRange> deps{};
+    return deps;
+  }
 
-    void onInitialize(IMscEngineModuleAPI &engine) override {}
+  void onInitialize(IMscEngineModuleAPI &engine) override {}
+  void onStart(IMscEngineModuleAPI &engine) override {}
+  void onUpdate(IMscEngineModuleAPI &engine,
+                IMscEngineModuleAPI::clock::duration dt) override
+  {
+  }
+  void onStop(IMscEngineModuleAPI &engine) override {}
+  void onDestory(IMscEngineModuleAPI &engine) override {}
 };
 
 class SecondTestModuleE1 : public MscEngineModule
 {
 public:
-    std::string getName() const override
-    {
-        return "second_tmod";
-    }
+  std::string getName() const override { return "second_tmod"; }
 
-    std::uint16_t getRev() const override
-    {
-        return 1;
-    }
+  std::uint16_t getRev() const override { return 1; }
 
-    const std::unordered_map<std::string, MscRevisionRange> &getDependencies() const override
-    {
-        static const std::unordered_map<std::string, MscRevisionRange> deps{
-            {"first_tmod", MscRevisionRange{1, 1}}};
-        return deps;
-    }
+  const std::unordered_map<std::string, MscRevisionRange> &
+  getDependencies() const override
+  {
+    static const std::unordered_map<std::string, MscRevisionRange> deps{
+        {"first_tmod", MscRevisionRange{1, 1}}};
+    return deps;
+  }
 
-    void onInitialize(IMscEngineModuleAPI &engine) override {}
+  void onInitialize(IMscEngineModuleAPI &engine) override {}
+  void onStart(IMscEngineModuleAPI &engine) override {}
+  void onUpdate(IMscEngineModuleAPI &engine,
+                IMscEngineModuleAPI::clock::duration dt) override
+  {
+  }
+  void onStop(IMscEngineModuleAPI &engine) override {}
+  void onDestory(IMscEngineModuleAPI &engine) override {}
 };
 
 class SecondTestModuleE2 : public MscEngineModule
 {
 public:
-    std::string getName() const override
-    {
-        return "second_tmod";
-    }
+  std::string getName() const override { return "second_tmod"; }
 
-    std::uint16_t getRev() const override
-    {
-        return 1;
-    }
+  std::uint16_t getRev() const override { return 1; }
 
-    const std::unordered_map<std::string, MscRevisionRange> &getDependencies() const override
-    {
-        static const std::unordered_map<std::string, MscRevisionRange> deps{
-            {"first_tmod", MscRevisionRange{1, 2}}};
-        return deps;
-    }
+  const std::unordered_map<std::string, MscRevisionRange> &
+  getDependencies() const override
+  {
+    static const std::unordered_map<std::string, MscRevisionRange> deps{
+        {"first_tmod", MscRevisionRange{1, 2}}};
+    return deps;
+  }
 
-    void onInitialize(IMscEngineModuleAPI &engine) override {}
+  void onInitialize(IMscEngineModuleAPI &engine) override {}
+  void onStart(IMscEngineModuleAPI &engine) override {}
+  void onUpdate(IMscEngineModuleAPI &engine,
+                IMscEngineModuleAPI::clock::duration dt) override
+  {
+  }
+  void onStop(IMscEngineModuleAPI &engine) override {}
+  void onDestory(IMscEngineModuleAPI &engine) override {}
 };
 
 void testSatisfiedModules()
 {
-    MscEngine engine({std::make_shared<FirstTestModuleR1>(),
-                      std::make_shared<SecondTestModuleE1>()});
+  MscEngine engine({std::make_shared<FirstTestModuleR1>(),
+                    std::make_shared<SecondTestModuleE1>()});
 }
 
 void testDuplicatedModules()
 {
-    try
-    {
-        MscEngine engine({
-            std::make_shared<FirstTestModuleR1>(),
-            std::make_shared<FirstTestModuleR2>(),
-        });
-        assert(false);
-    }
-    catch (const std::runtime_error &error)
-    {
-    }
+  try
+  {
+    MscEngine engine({
+        std::make_shared<FirstTestModuleR1>(),
+        std::make_shared<FirstTestModuleR2>(),
+    });
+    assert(false);
+  }
+  catch (const std::runtime_error &error)
+  {
+  }
 }
 
 void testUnsatisfiedModules()
 {
-    try
-    {
-        MscEngine engine({std::make_shared<FirstTestModuleR2>(),
-                          std::make_shared<SecondTestModuleE1>()});
-        assert(false);
-    }
-    catch (const std::runtime_error &error)
-    {
-    }
+  try
+  {
+    MscEngine engine({std::make_shared<FirstTestModuleR2>(),
+                      std::make_shared<SecondTestModuleE1>()});
+    assert(false);
+  }
+  catch (const std::runtime_error &error)
+  {
+  }
 }
 
 void testSatisfiedMultiversionModule()
 {
-    MscEngine engine({std::make_shared<FirstTestModuleR2>(),
-                      std::make_shared<SecondTestModuleE2>()});
+  MscEngine engine({std::make_shared<FirstTestModuleR2>(),
+                    std::make_shared<SecondTestModuleE2>()});
 }
 
 int main()
 {
-    testSatisfiedModules();
-    testDuplicatedModules();
-    testUnsatisfiedModules();
-    testSatisfiedMultiversionModule();
+  testSatisfiedModules();
+  testDuplicatedModules();
+  testUnsatisfiedModules();
+  testSatisfiedMultiversionModule();
 
-    return 0;
+  return 0;
 }

tests/engine/lifecycle_test.cpp

@@ -0,0 +1,64 @@
+#include "engine/core/engine.hpp"
+#include "engine/core/engine_module.hpp"
+#include "engine/utils/rev_range.hpp"
+#include <cassert>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+bool onInitWasCalled = false;
+bool onStartWasCalled = false;
+bool onUpdateWasCalled = false;
+bool onStopWasCalled = false;
+
+class TestModule : public MscEngineModule
+{
+public:
+  std::string getName() const override { return "test_mod"; }
+  std::uint16_t getRev() const override { return 1; }
+  const std::unordered_map<std::string, MscRevisionRange> &
+  getDependencies() const override
+  {
+    static const std::unordered_map<std::string, MscRevisionRange> deps{};
+    return deps;
+  }
+
+  void onInitialize(IMscEngineModuleAPI &engine) override
+  {
+    onInitWasCalled = true;
+  }
+
+  void onStart(IMscEngineModuleAPI &engine) override
+  {
+    onStartWasCalled = true;
+  }
+
+  void onUpdate(IMscEngineModuleAPI &engine,
+                IMscEngineModuleAPI::clock::duration dt) override
+  {
+    onUpdateWasCalled = true;
+    engine.requestStop();
+  }
+
+  void onStop(IMscEngineModuleAPI &engine) override { onStopWasCalled = true; }
+
+  void onDestory(IMscEngineModuleAPI &engine) override {}
+};
+
+void testStates()
+{
+  MscEngine engine({std::make_shared<TestModule>()});
+  engine.start();
+
+  assert(onInitWasCalled);
+  assert(onStartWasCalled);
+  assert(onUpdateWasCalled);
+  assert(onStopWasCalled);
+}
+
+int main()
+{
+  testStates();
+  return 0;
+}