New SEngineSettings struct. Works similarly to the

SLevelSettings struct, where it just holds info
about how the engine should be setup, and info
about the current state of the game (like CLevel's
SLevelSettings data being owned by it. CLevel does
not actually "own" that data, it just has a raw
pointer to it).

Author: ostanton

include/Tails/AssetCache.hpp

@@ -2,6 +2,7 @@
 #define TAILS_ASSETCACHE_HPP
 
 #include <Tails/Config.hpp>
+#include <Tails/Debug.hpp>
 
 #include <unordered_map>
 #include <string>
@@ -32,7 +33,10 @@ namespace tails
                 if (!get().m_data.contains(name)) return;
 
                 if (get().m_data[name].expired())
+                {
                     get().m_data.erase(name);
+                    CDebug::print("Erased asset \"", name, "\"");
+                }
             };
 
             std::shared_ptr<T> data {new T, std::bind(deleter, id)};

include/Tails/CMakeLists.txt

@@ -23,4 +23,5 @@ target_sources(
     EngineRegistry.hpp
     Debug.hpp
     Vector2.hpp
+    EngineSettings.hpp
 )

include/Tails/Engine.hpp

@@ -17,6 +17,7 @@
 namespace tails
 {
     class CClassRegistry;
+    struct SEngineSettings;
 
     struct TAILS_API SWindowProperties final
     {
@@ -36,12 +37,8 @@ namespace tails
     class TAILS_API CEngine final : public CObject, public ITickable, public sf::Drawable
     {
     public:
-        /**
-         * Sets up engine with "engine.json" as engine setup file
-         */
         CEngine();
-        explicit CEngine(const std::string& engineSetupFile,
-            std::vector<std::unique_ptr<CClassRegistry>>&& registries);
+        explicit CEngine(std::unique_ptr<SEngineSettings> engineSettings);
         ~CEngine() override;
 
         template<typename T, typename... Args>
@@ -64,26 +61,7 @@ namespace tails
         [[nodiscard]] const sf::View& getRenderView() const {return m_renderView;}
         [[nodiscard]] CWorld& getWorld() {return m_world;}
         [[nodiscard]] const CWorld& getWorld() const {return m_world;}
-
-        template<typename T>
-        [[nodiscard]] bool registryExists() const
-        {
-            return getRegistry<T>();
-        }
-
-        template<typename T>
-        [[nodiscard]] T* getRegistry() const
-        {
-            if (m_registries.empty()) return nullptr;
-            
-            for (auto& registry : m_registries)
-            {
-                if (auto castedRegistry = dynamic_cast<T*>(registry.get()))
-                    return castedRegistry;
-            }
-
-            return nullptr;
-        }
+        [[nodiscard]] SEngineSettings& getSettings() const {return *m_settings;}
 
     protected:
         void preTick() override;
@@ -92,7 +70,9 @@ namespace tails
         void postTick() override;
 
     private:
+        void initMembers();
         void initInternalRender();
+        void initWorldLevel(std::string path);
         void calculateInternalAspectRatio(sf::Vector2u windowSize);
 
         /**
@@ -126,14 +106,9 @@ namespace tails
 
         SRenderProperties m_renderProperties;
         SWindowProperties m_windowProperties;
+        std::unique_ptr<SEngineSettings> m_settings;
 
         float m_lifeTime {0.f};
-
-        /**
-         * The registries that handle all the serialisation stuff for engine and custom
-         * classes. They are set in the engine's constructor, and cannot be added after.
-         */
-        std::vector<std::unique_ptr<CClassRegistry>> m_registries;
     };
 }
 

include/Tails/EngineSettings.hpp

@@ -0,0 +1,56 @@
+#ifndef TAILS_ENGINESETTINGS_HPP
+#define TAILS_ENGINESETTINGS_HPP
+
+#include <Tails/Config.hpp>
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace tails
+{
+    class CClassRegistry;
+    struct SLevelSettings;
+    class CEngine;
+
+    /**
+     * Holds data for general engine setup and game-specific classes
+     */
+    struct TAILS_API SEngineSettings
+    {
+        friend CEngine;
+
+        SEngineSettings();
+
+        [[nodiscard]] const std::string& getSetupFilePath() const {return m_setupFilePath;}
+
+        template<typename T>
+        [[nodiscard]] T* getRegistry() const
+        {
+            if (m_registries.empty()) return nullptr;
+
+            for (auto& registry : m_registries)
+            {
+                if (auto castedRegistry = dynamic_cast<T*>(registry.get()))
+                    return castedRegistry;
+            }
+
+            return nullptr;
+        }
+
+        template<typename T>
+        [[nodiscard]] bool registryExists() const
+        {
+            return getRegistry<T>();
+        }
+
+        [[nodiscard]] SLevelSettings& getLevelSettings() const {return *m_levelSettings;}
+
+    private:
+        std::string m_setupFilePath;
+        std::vector<std::unique_ptr<CClassRegistry>> m_registries;
+        std::unique_ptr<SLevelSettings> m_levelSettings;
+    };
+}
+
+#endif // TAILS_ENGINESETTINGS_HPP

include/Tails/Level.hpp

@@ -63,7 +63,7 @@ namespace tails
         CLevel(std::string path);
 
         void open();
-        void setSettings(std::unique_ptr<SLevelSettings> settings);
+        void setSettings(SLevelSettings* settings);
 
         void preTick() override;
         void tick(float deltaTime) override;
@@ -80,7 +80,12 @@ namespace tails
         CEntity* spawnEntityImpl(std::unique_ptr<CEntity> entity, const sf::Vector2f& position, float rotation, const sf::Vector2f& scale);
 
         std::string m_path;
-        std::unique_ptr<SLevelSettings> m_settings;
+
+        /**
+         * Settings for the level (could be anything, like gravity scale, day length, etc.).
+         * Non-owning raw pointer because SEngineSettings owns the data for this
+         */
+        SLevelSettings* m_settings {nullptr};
 
         std::vector<std::unique_ptr<CEntity>> m_entities;
 

include/Tails/World.hpp

@@ -22,7 +22,7 @@ namespace tails
         friend CEngine;
 
     public:
-        CLevel* openLevel(std::string path, std::unique_ptr<SLevelSettings> settings = nullptr);
+        CLevel* openLevel(std::string path, SLevelSettings* settings = nullptr);
         bool closeLevel(CLevel* level);
 
         [[nodiscard]] CEngine& getEngine() const;

src/Tails/AssetCache.cpp

@@ -33,12 +33,19 @@ namespace tails
         const std::string& id, const std::string& path, const std::shared_ptr<IAssetData>& data)
     {
         // TODO - debug print on fail load
-        data->load(CDirectories::getDirectory(data->getType()) + path);
+        if (!data->load(CDirectories::getDirectory(data->getType()) + path))
+        {
+            // SFML has a print for this already, we're ok to not print this I think
+            //CDebug::print("Failed to load path ", path);
+            return nullptr;
+        }
 
         if (get().m_data.contains(id))
             get().m_data[id] = data;
         else
             get().m_data.try_emplace(id, data);
+
+        CDebug::print("Loaded \"", id, "\" {type: ", data->getType(), ", path: \"", path, "\"}");
 
         return data;
     }

src/Tails/CMakeLists.txt

@@ -18,4 +18,5 @@ add_library(
     ClassRegistry.cpp
     EngineRegistry.cpp
     Debug.cpp
+    EngineSettings.cpp
 )

src/Tails/Engine.cpp

@@ -5,6 +5,7 @@
 #include <Tails/Debug.hpp>
 #include <Tails/Vector2.hpp>
 #include <Tails/LevelSettings.hpp>
+#include <Tails/EngineSettings.hpp>
 
 #include <SFML/Graphics/Sprite.hpp>
 #include <SFML/Graphics/RenderWindow.hpp>
@@ -18,73 +19,57 @@ namespace tails
 {
     std::string SWindowProperties::toString() const
     {
-        return "Window properties:\nTitle - " + title + "\nResolution - " + SVector2u::toString(resolution);
+        return "Window properties:\nTitle - \"" + title + "\"\nResolution - " + SVector2u::toString(resolution);
     }
 
     std::string SRenderProperties::toString() const
     {
         return "Render properties:\nResolution - " + SVector2u::toString(resolution);
     }
 
-    // removed make_unique for engine registry here because it was causing compile errors
-    // to do with unique_ptr's deleted copy-constructor (I think). Couldn't fix it.
-    CEngine::CEngine() : CEngine("engine.json", {})
+    CEngine::CEngine() : CEngine(nullptr)
     {
     }
 
-    CEngine::CEngine(const std::string& engineSetupFile,
-        std::vector<std::unique_ptr<CClassRegistry>>&& registries)
-            : m_registries(std::move(registries))
+    CEngine::CEngine(std::unique_ptr<SEngineSettings> engineSettings)
+            : m_settings(std::move(engineSettings))
     {
-        // TODO - replace the above paramters with some SEngineSettings struct:
-        /*
-         * struct SEngineSettings
-         * {
-         *     string setupFile;
-         *     registries;
-         *     levelSettings;??
-         * }
-         *
-         * And maybe a templated constructor for this? or just take in a unique_ptr?
-         * so clients can derive the struct to add their own stuff. how would they use
-         * that stuff? no idea lol. maybe not. Would be nice to have a custom levelsettings
-         * struct though!
-         */
-        if (!getRegistry<CEngineRegistry>())
-            m_registries.emplace_back(std::make_unique<CEngineRegistry>());
+        // If input engine settings is null, use default
+        if (!engineSettings)
+            m_settings = std::make_unique<SEngineSettings>();
 
         // Setup world
         m_world.outer = this;
 
-        CDebug::print("Loading ", engineSetupFile);
+        CDebug::print("Loading ", m_settings->getSetupFilePath());
 
-        std::ifstream setupFile {engineSetupFile};
+        std::ifstream setupFile {m_settings->getSetupFilePath()};
         if (!setupFile.is_open())
         {
-            CDebug::print("Failed to find ", engineSetupFile);
-            initInternalRender();
-            m_world.openLevel("");
+            CDebug::print("Failed to find ", m_settings->getSetupFilePath());
+            initMembers();
             return;
         }
 
         nlohmann::json setupJson = nlohmann::json::parse(setupFile);
 
         if (setupJson.is_null())
         {
-            CDebug::print("Failed to load ", engineSetupFile);
-            initInternalRender();
-            m_world.openLevel("");
+            CDebug::print("Failed to load ", m_settings->getSetupFilePath());
+            initMembers();
             return;
         }
 
         CDebug::print(std::string("JSON is a valid "), setupJson.type_name());
+        CDebug::print();
 
         /* DIRECTORIES */
 
         if (const auto& dirJson = setupJson["dirs"]; !dirJson.is_null())
             CDirectories::loadDirectories(dirJson);
         else
             CDebug::print("Failed to load directories, using default");
+        CDebug::print();
 
         /* RENDER SETTINGS */
 
@@ -111,15 +96,15 @@ namespace tails
         /* WORLD AND LEVEL */
 
         if (const auto& defaultLevelJson = setupJson["default_level"]; !defaultLevelJson.is_null())
-            m_world.openLevel(defaultLevelJson.get<std::string>());
+            initWorldLevel(defaultLevelJson.get<std::string>());
         else
         {
             CDebug::print("Failed to open default level, opening blank level");
-            m_world.openLevel("");
+            initWorldLevel("");
         }
 
         if (const auto level = m_world.getLevel(0))
-            CDebug::print("Opened level - ", level->getSettings().name);
+            CDebug::print("Opened level - \"", level->getSettings().name, "\"");
         else
             CDebug::error("Created level is invalid!");
         CDebug::print();
@@ -148,7 +133,7 @@ namespace tails
         CDebug::print(m_windowProperties.toString());
         CDebug::print();
 
-        CDebug::print(engineSetupFile, " loaded");
+        CDebug::print(m_settings->getSetupFilePath(), " loaded");
         CDebug::print();
     }
 
@@ -160,6 +145,7 @@ namespace tails
 
     void CEngine::run()
     {
+        CDebug::print();
         CDebug::print("Initialising final render target");
         // Set default render target as window if it has not already been set
         if (!m_renderTarget)
@@ -170,6 +156,7 @@ namespace tails
                 ),
                 m_windowProperties.title
             );
+        CDebug::print();
 
         sf::Clock clock;
         const auto window = dynamic_cast<sf::RenderWindow*>(m_renderTarget.get());
@@ -258,6 +245,12 @@ namespace tails
         m_world.postTick();
     }
 
+    void CEngine::initMembers()
+    {
+        initInternalRender();
+        initWorldLevel("");
+    }
+
     void CEngine::initInternalRender()
     {
         CDebug::print("Initialising internal render target");
@@ -272,6 +265,11 @@ namespace tails
         m_renderView.setCenter(m_renderView.getSize() * 0.5f);
     }
 
+    void CEngine::initWorldLevel(std::string path)
+    {
+        m_world.openLevel(std::move(path), &m_settings->getLevelSettings());
+    }
+
     void CEngine::calculateInternalAspectRatio(sf::Vector2u windowSize)
     {
         const sf::Vector2f ratio {

src/Tails/EngineSettings.cpp

@@ -0,0 +1,12 @@
+#include <Tails/EngineSettings.hpp>
+#include <Tails/EngineRegistry.hpp>
+#include <Tails/LevelSettings.hpp>
+
+namespace tails
+{
+    SEngineSettings::SEngineSettings()
+        : m_setupFilePath("engine.json"), m_levelSettings(std::make_unique<SLevelSettings>())
+    {
+        m_registries.emplace_back(std::make_unique<CEngineRegistry>());
+    }
+}