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

@@ -8,41 +8,43 @@
 #include <memory>
 #include <vector>
 
-/// Magic Srolls engine core
+/// Ядро движка Magic Srolls
 class MscEngine : public IMscEngineModuleAPI
 {
 private:
-  /// @brief Loaded modules list
+  /// @brief Загруженные модули
   std::vector<std::shared_ptr<MscEngineModule>> _modules;
 
-  /// @brief Common event bus
+  /// @brief Общая событийная шина движка
   MscEventBus _bus;
 
-  /// @brief Is engine running rn
+  /// @brief Флаг работы движка
   bool _isRunning = false;
 
-  /// @brief Last update time
+  /// @brief Время последнего тика
   clock::time_point _lastUpdate;
 
 public:
-  /// Actual version
+  /// @brief Номер ревизии
   static uint16_t REV;
 
   MscEngine(std::vector<std::shared_ptr<MscEngineModule>> modules);
+  ~MscEngine() = default;
 
-  /// @brief Start engine
+  /// @brief Запустить движок
   void start();
 
-  /// @brief Stop engine
+  /// @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::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;
+  void requestStop() override;
 };
 
 #endif // __MCS_ENGINE_HPP__

include/engine/core/engine_module_api.hpp

@@ -10,6 +10,7 @@
 
 class MscEngineModule;
 
+/// @brief Публичный API движка для модулей
 class IMscEngineModuleAPI
 {
 public:
@@ -17,22 +18,26 @@ public:
 
   virtual ~IMscEngineModuleAPI() = default;
 
-  /// @brief Get access to engine event bus
+  /// @brief Получить доступ к событийной шине
   virtual MscEventBus &getBus() = 0;
 
-  /// @brief Get access to loaded module list
+  /// @brief Получить список загруженных модулей
   virtual std::unordered_map<std::string, std::uint16_t>
   getLoadedModules() const = 0;
 
-  /// @brief Access module by its name
+  /// @brief Получить прямой доступ к модулю
-  virtual MscEngineModule &getModule(const std::string &name) = 0;
+  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
+  /// @brief Создать провайдер БД с указанным файлом
   virtual std::unique_ptr<MscEngineDBProvider>
   createDBProvider(const std::string &filepath) = 0;
+
+  /// @brief Запросить остановку движка
+  virtual void requestStop() = 0;
 };
 
 #endif // __MSC_ENGINE_MODULE_API_HPP__

src/engine/core/engine.cpp

@@ -132,12 +132,12 @@ MscEngine::getLoadedModules() const
   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);
@@ -153,3 +153,8 @@ MscEngine::createDBProvider(const std::string &filepath)
 {
   return std::make_unique<MscEngineDBProvider>(filepath);
 }
+
+void MscEngine::requestStop()
+{
+  this->stop(); // TODO: заменить на флаг
+}

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;
+}