memory related refactor

src/world/World.cpp

@@ -1,8 +1,10 @@
 #include "World.hpp"
 
 #include "Level.hpp"
+
 #include "../content/Content.hpp"
 #include "../content/ContentLUT.hpp"
+#include "../debug/Logger.hpp"
 #include "../files/WorldFiles.hpp"
 #include "../items/Inventories.hpp"
 #include "../objects/Player.hpp"
@@ -13,9 +15,10 @@
 #include "../world/WorldGenerators.hpp"
 
 #include <memory>
-#include <iostream>
 #include <glm/glm.hpp>
 
+static debug::Logger logger("world");
+
 world_load_error::world_load_error(std::string message) 
     : std::runtime_error(message) {
 }
@@ -64,35 +67,38 @@ void World::write(Level* level) {
     }
 
     wfile->write(this, content);
-	auto playerFile = dynamic::Map();
-    {
-        auto& players = playerFile.putList("players");
-        for (auto object : level->objects) {
-            if (std::shared_ptr<Player> player = std::dynamic_pointer_cast<Player>(object)) {
-                players.put(player->serialize());
-            }
+    auto playerFile = dynamic::Map();
+
+    auto& players = playerFile.putList("players");
+    for (auto object : level->objects) {
+        if (auto player = std::dynamic_pointer_cast<Player>(object)) {
+            players.put(player->serialize());
         }
     }
     files::write_json(wfile->getPlayerFile(), &playerFile);
 }
 
-Level* World::create(std::string name, 
-                     std::string generator,
-                     fs::path directory, 
-                     uint64_t seed,
-                     EngineSettings& settings, 
-                     const Content* content,
-                     const std::vector<ContentPack>& packs
+std::unique_ptr<Level> World::create(
+    std::string name, 
+    std::string generator,
+    fs::path directory, 
+    uint64_t seed,
+    EngineSettings& settings, 
+    const Content* content,
+    const std::vector<ContentPack>& packs
 ) {
-    auto world = new World(name, generator, directory, seed, settings, content, packs);
-    auto level = new Level(world, content, settings);
-    return level;
+    auto world = std::make_unique<World>(
+        name, generator, directory, seed, settings, content, packs
+    );
+    return std::make_unique<Level>(std::move(world), content, settings);
 }
 
-Level* World::load(fs::path directory,
-                   EngineSettings& settings,
-                   const Content* content,
-                   const std::vector<ContentPack>& packs) {
+std::unique_ptr<Level> World::load(
+    fs::path directory,
+    EngineSettings& settings,
+    const Content* content,
+    const std::vector<ContentPack>& packs
+) {
     auto world = std::make_unique<World>(
         ".", WorldGenerators::getDefaultGeneratorID(), directory, 0, settings, content, packs
     );
@@ -102,23 +108,27 @@ Level* World::load(fs::path directory,
         throw world_load_error("could not to find world.json");
     }
 
-    auto level = new Level(world.get(), content, settings);
+    auto level = std::make_unique<Level>(std::move(world), content, settings);
     {
         fs::path file = wfile->getPlayerFile();
         if (!fs::is_regular_file(file)) {
-            std::cerr << "warning: player.json does not exists" << std::endl;
+            logger.warning() << "player.json does not exists";
         } else {
             auto playerFile = files::read_json(file);
             if (playerFile->has("players")) {
                 level->objects.clear();
                 auto players = playerFile->list("players");
                 for (size_t i = 0; i < players->size(); i++) {
-                    auto player = level->spawnObject<Player>(glm::vec3(0, DEF_PLAYER_Y, 0), DEF_PLAYER_SPEED, level->inventories->create(DEF_PLAYER_INVENTORY_SIZE));
+                    auto player = level->spawnObject<Player>(
+                        glm::vec3(0, DEF_PLAYER_Y, 0), 
+                        DEF_PLAYER_SPEED, 
+                        level->inventories->create(DEF_PLAYER_INVENTORY_SIZE)
+                    );
                     player->deserialize(players->map(i));
                     level->inventories->store(player->getInventory());
                 }
             } else {
-	            auto player = level->getObject<Player>(0);
+                auto player = level->getObject<Player>(0);
                 player->deserialize(playerFile.get());
                 level->inventories->store(player->getInventory());
             }
@@ -128,8 +138,10 @@ Level* World::load(fs::path directory,
     return level;
 }
 
-ContentLUT* World::checkIndices(const fs::path& directory, 
-                                const Content* content) {
+std::shared_ptr<ContentLUT> World::checkIndices(
+    const fs::path& directory, 
+    const Content* content
+) {
     fs::path indicesFile = directory/fs::path("indices.json");
     if (fs::is_regular_file(indicesFile)) {
         return ContentLUT::create(indicesFile, content);
@@ -178,10 +190,9 @@ void World::deserialize(dynamic::Map* root) {
     generator = root->get("generator", generator);
     seed = root->get("seed", seed);
 
-    if(generator == "") {
+    if (generator == "") {
         generator = WorldGenerators::getDefaultGeneratorID();
     }
-
     auto verobj = root->map("version");
     if (verobj) {
         int major=0, minor=-1;
@@ -189,14 +200,12 @@ void World::deserialize(dynamic::Map* root) {
         verobj->num("minor", minor);
         std::cout << "world version: " << major << "." << minor << std::endl;
     }
-
     auto timeobj = root->map("time");
     if (timeobj) {
         timeobj->num("day-time", daytime);
         timeobj->num("day-time-speed", daytimeSpeed);
         timeobj->num("total-time", totalTime);
     }
-    
     nextInventoryId = root->get("next-inventory-id", 2);
 }