Move world on unordered_map and object_ptr

Core/Core/RenderEngine/RenderEngine.cpp

@@ -991,7 +991,7 @@ RenderEngine::~RenderEngine()
 void RenderEngine::start()
 {
     World* world = core_.GetGameInstance()->GetWorld();
-    std::vector<Mesh*> meshes = world->GetActorsByClass<Mesh>();
+    std::vector<UType::object_ptr<Mesh>> meshes = world->GetActorsByClass<Mesh>();
     for (auto& i : meshes)
         i->load_model(i->GetModelName());
         

Core/Game/Actors/Actor.cpp

@@ -8,7 +8,7 @@ void Actor::OnDestroy()
 {
 }
 
-Actor::Actor()
+Actor::Actor() : loc(new Vector3D), rot(new Vector3D), scale(new Vector3D)
 {
     SetType(Classes::Actor);
 }
@@ -60,9 +60,3 @@ void Actor::RemoveTag(const std::string& tag) noexcept
 {
     tags.remove(tag);
 }
-
-void Actor::Destroy()
-{
-    OnDestroy();
-    //world_->actors.remove(this);
-}

Core/Game/Actors/Actor.hpp

@@ -15,6 +15,7 @@ GENERATE_META(Actor)
 class Actor : public ISave, public IRTTI
 {
     World* world_;
+    std::string name_;
     
     UType::object_ptr<Vector3D> loc, rot, scale;
 
@@ -53,9 +54,9 @@ public:
     void AddTag(const std::string& tag) noexcept;
     void RemoveTag(const std::string& tag) noexcept;
     const std::list<std::string>& GetTags() const { return tags; }
-    void Destroy();
 
     World* GetWorld() const { return world_; }
+    const std::string& GetName() const { return name_; }
 
     friend class World;
 };

Core/Game/World/World.cpp

@@ -8,32 +8,49 @@ World::World(GameInstance& game_instance) : game_instance(game_instance)
 
 World::~World()
 {
-    actors.clear();
+    actors_map.clear();
 }
 
 void World::BeginPlay()
 {
-    for (auto& i : actors)
-        i->BeginPlay();
+    for (auto& i : actors_map)
+        i.second->BeginPlay();
 }
 
 void World::Tick(double delta_time)
 {
-    for (auto& i : actors)
-        i->Tick(delta_time);
+    for (auto& i : actors_map)
+        i.second->Tick(delta_time);
 }
 
 std::shared_ptr<SaveMap> World::save()
 {
     std::shared_ptr<SaveMap> save = std::make_shared<SaveMap>("World");
-    save->SaveListObject("Actors", std::move(reinterpret_cast<std::list<UType::object_ptr<ISave>>&>(actors)));
     return save;
 }
 
 void World::load(std::shared_ptr<SaveMap> save)
 {
-    actors = std::move(reinterpret_cast<std::list<UType::object_ptr<Actor>>&>(save->GetListObject("Actors")));
+    std::vector<std::string> actors_IDs = save->GetVectorString("ActorsIDs");
+    std::list<UType::object_ptr<Actor>> act = std::move(reinterpret_cast<std::list<UType::object_ptr<Actor>>&>(save->GetListObject("Actors")));
 
-    for (auto& i : actors)
-        i->world_ = this;
-}
+    size_t i_id = 0;
+    for (auto& i : act)
+    {
+        auto[it, flag] = actors_map.try_emplace(actors_IDs[i_id], i);
+        it->second->world_ = this;
+        it->second->name_ = it->first;
+        i_id++;
+    }
+}
+
+void World::DestroyActor(UType::object_ptr<Actor> ptr)
+{
+    if (ptr.get() == nullptr)
+        return;
+    
+    std::string name = ptr->GetName();
+    actors_map.erase(name);
+    ptr->OnDestroy();
+    ptr.destroy();
+}

Core/Game/World/World.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <list>
+#include <unordered_map>
 #include <vector>
 #include <string>
 
@@ -16,8 +17,7 @@ class World : public ISave
 {
     GameInstance& game_instance;
     
-    // Actors only
-    std::list<UType::object_ptr<Actor>> actors;
+    std::unordered_map<std::string, UType::object_ptr<Actor>> actors_map;
 
 public:
     World(GameInstance& game_instance);
@@ -33,37 +33,39 @@ public:
     void load(std::shared_ptr<SaveMap> save) override;
 #pragma endregion
     
-    template<class T, class Container = std::vector<T*>>
-    Container GetActorsByClass()
+    template<class T>
+    std::vector<UType::object_ptr<T>> GetActorsByClass()
     {
-        Container list;
-        for (auto i = actors.cbegin(); i != actors.cend(); ++i)
+        std::vector<UType::object_ptr<T>> list;
+        for (auto i = actors_map.cbegin(); i != actors_map.cend(); ++i)
         {
-            if (T* cast_object = RTTI::dyn_cast<T, Actor>((*i).get()))
-                list.push_back(cast_object);
+            if (T* cast_object = RTTI::dyn_cast<T, Actor>(i->second.get()))
+                list.push_back(UType::object_ptr<T>(cast_object));
         }
         return list;
     }
     
     template<class T>
-    T* SpawnActorFormClass(const Vector3D& loc = { 0, 0, 0 }, const Vector3D& rot = { 0, 0, 0 })
+    UType::object_ptr<T> SpawnActorFormClass(std::string name, const Vector3D& loc = { 0, 0, 0 }, const Vector3D& rot = { 0, 0, 0 })
     {
-        T* object = new T();
+        UType::object_ptr<T> object(new T());
         object->SetActorLocate(loc);
         object->SetActorRotate(rot);
         static_cast<Actor*>(object)->world_ = this;
-        actors.push_back(object);
+        actors_map.try_emplace(name, object);
         return object;
     }
 
+    void DestroyActor(UType::object_ptr<Actor> ptr);
+
     template<class T, class Container = std::vector<T*>>
     Container GetActorsByTag(std::string tag)
     {
         Container container;
 
-        for (auto& i : actors)
+        for (auto& i : actors_map)
         {
-            const std::list<std::string>& tags = i->GetTags();
+            const std::list<std::string>& tags = i.second->GetTags();
             for (auto& j : tags)
             {
                 if (j == tag)
@@ -73,5 +75,11 @@ public:
         
         return container;
     }
+
+    template<class T>
+    UType::object_ptr<T> GetActorByID(const std::string& id)
+    {
+        return actors_map[id];
+    }
 };