Update Physic and Graphic Resolvers

source/kernel/front/resolver/GraphicResolver.cpp

 #include "GraphicResolver.hpp"
 
 namespace megu::kernel {
-    void GraphicResolver::resolve(double time, GraphicEngine &, const Identifiable_Map<Props> & props) {
-        for(auto & [id, object] : props) {
-            auto * component =  object->getGraphicComponent();
-            if(component != nullptr) {
-                component->update(time);
-            }
+    void GraphicResolver::resolve(Kernel & kernel, GraphicEngine & engine, double time) {
+        for(auto & component : this->components()) {
+            component.get().update(time);
         }
     }
 }
\ No newline at end of file

source/kernel/front/resolver/GraphicResolver.hpp

@@ -5,8 +5,8 @@
 #include <kernel/back/props/Props.hpp>
 
 namespace megu::kernel {
-    class GraphicResolver : public Resolver<GraphicEngine, Props> {
+    class GraphicResolver : public Resolver<GraphicEngine, Graphical<GraphicEngine>> {
         public:
-            void resolve(double, GraphicEngine &, const Identifiable_Map<Props> &) override;
+            void resolve(Kernel &, GraphicEngine &, double) override;
     };
 }
\ No newline at end of file

source/kernel/front/resolver/PhysicResolver.cpp

 #include "PhysicResolver.hpp"
 
 namespace megu::kernel {
-    void PhysicResolver::resolve(double time, PhysicEngine & engine, const Identifiable_Map<Props> & props) {
+    void PhysicResolver::resolve(Kernel & kernel, PhysicEngine & engine, double time) {
         auto & collisions = engine.get().collision();
 
         for(auto & collision : collisions) {
-            const Tangible & source = collision.source();
-            const Tangible & target = collision.target();
-
-            if(props.contains(source.id()) && props.contains(target.id())) {
-                Props * props_source = props.at(source.id()); 
-                Props * props_target = props.at(target.id());
-
-                auto * sComponent = props_source->getPhysicComponent();
-                auto * tComponent = props_target->getPhysicComponent();
-
-                if(sComponent != nullptr && tComponent != nullptr) {
-                    sComponent->on_collide(time, target, *tComponent);
-                }
+            auto source_comp = this->get(collision.source());
+            auto target_comp = this->get(collision.target());
 
+            if(source_comp.has_value() && target_comp.has_value()) {
+                source_comp.value().get().on_collide(kernel, engine, target_comp.value().get(), time);
             }
         }
 

source/kernel/front/resolver/PhysicResolver.hpp

@@ -5,8 +5,8 @@
 #include <kernel/back/props/Props.hpp>
 
 namespace megu::kernel {
-    class PhysicResolver : public Resolver<PhysicEngine, Props> {
+    class PhysicResolver : public Resolver<PhysicEngine, Physical<PhysicEngine>> {
         public:
-            void resolve(double, PhysicEngine &, const Identifiable_Map<Props> &) override;
+            void resolve(Kernel &, PhysicEngine &, double) override;
     };
 }
\ No newline at end of file

source/kernel/front/resolver/Resolver.hpp

 #pragma once
 
 #include <utility/Identifiable.hpp>
+#include <kernel/back/props/Component.hpp>
+#include <engine/utility/ref_set.hpp>
+#include <optional>
 
 namespace megu::kernel {
     template <class E, class O>
     class Resolver {
         public:
-            virtual void resolve(double, E &, const Identifiable_Map<O> &) = 0;
+            inline ref_set<O> & components() {return this->_components;}
+
+            void add(O &);
+            void erase(const Identifiable &);
+            std::optional<std::reference_wrapper<O>> get(const Identifiable &);
+
+            virtual void resolve(Kernel &, E &, double) = 0;
+
+        private:
+            ref_set<O> _components;
     };
 }
+
+#include "Resolver.tpp"
\ No newline at end of file

source/kernel/front/resolver/Resolver.tpp

+#include "Resolver.hpp"
+
+namespace megu::kernel {
+    template <class E, class O>
+    void Resolver<E, O>::add(O & c) {
+        this->_components.insert(c);
+    }
+
+    template <class E, class O>
+    void Resolver<E, O>::erase(const Identifiable & c) {
+        this->_components.erase(c);
+    }
+
+    template <class E, class O>
+    std::optional<std::reference_wrapper<O>> Resolver<E, O>::get(const Identifiable & c) {
+        for(auto & comp : this->_components) {
+            if(comp.get().id() == c.id()) {
+                return comp;
+            }
+        }
+        return {};
+    }
+}
\ No newline at end of file