Refactor: Move code to rutile module and namespace

src/rutile/core/engine.cppm

@@ -0,0 +1,104 @@
+module;
+
+#include <cassert>
+#include <memory>
+
+export module rutile.core.engine;
+
+import rutile.config;
+import rutile.core.render_server;
+import wrappers.sdl;
+
+export namespace rutile
+{
+    class Engine
+    {
+        // Whether this class is currently instantiated (to prevent multiple instances)
+        static bool instantiated_;
+
+        // If this is set to false, the application will exit
+        bool keep_running_ = true;
+
+        sdl::Window window_;
+        RenderServer render_server_;
+
+        // Private constructor
+        Engine(sdl::Window&& window, sdl::Renderer&& renderer)
+            : window_{std::move(window)},
+              render_server_{std::move(renderer)}
+        {
+            instantiated_ = true;
+        }
+
+        public:
+            Engine() = delete;
+
+            // No copy or move operations
+            Engine(const Engine&) = delete;
+            Engine& operator=(const Engine&) = delete;
+            Engine(Engine&&) = delete;
+            Engine& operator=(Engine&&) = delete;
+
+            ~Engine()
+            {
+                instantiated_ = false;
+            }
+
+            static std::unique_ptr<Engine> create()
+            {
+                // Prevent the class from being instantiated multiple times
+                assert(!instantiated_);
+
+                auto [sdl_window, sdl_renderer] = sdl::CreateWindowAndRenderer(
+                    config::get_window_title(),
+                    config::window_width,
+                    config::window_height,
+                    0
+                );
+
+                return std::unique_ptr<Engine>{
+                    new Engine{
+                        std::move(sdl_window),
+                        std::move(sdl_renderer)
+                    }
+                };
+            }
+
+            bool keep_running() const
+            {
+                return keep_running_;
+            }
+
+            sdl::Window& get_window()
+            {
+                return window_;
+            }
+
+            RenderServer& get_render_server()
+            {
+                return render_server_;
+            }
+
+            // Handles an SDL event. Returns true if the event has been handled.
+            bool handle_event(const sdl::Event* event)
+            {
+                if (event->type == sdl::EventType::Quit) {
+                    // Exit the application
+                    keep_running_ = false;
+                    return true;
+                }
+
+                return false;
+            }
+
+            void update()
+            {
+            }
+
+            void shutdown()
+            {
+            }
+    };
+
+    bool Engine::instantiated_ = false;
+}