Changing Props -> BasicProps

source/engine/graphics/front/object/TileArray.cpp

@@ -3,7 +3,7 @@
 #include <iostream>
 
 namespace megu {
-    TileArray::TileArray(const std::filesystem::path & path, size_t width, size_t height, float size)
+    TileArray::TileArray(const std::filesystem::path & path, size_t width, size_t height, float size, size_t lenght)
     : _width(width), _height(height), _size(size) {
         megu::TextureBuffer buffer(path);
         this->_texture.store(buffer);
@@ -14,7 +14,7 @@ namespace megu {
         for(size_t x = 0; x < width; ++x) {
             std::vector<glm::vec4> rows;
             for(size_t y = 0; y < height; ++y) {
-                rows.push_back({0.f, 0.f, twidth, theight});
+                rows.push_back({0.f, this->_texture.height() - lenght, lenght, lenght});
             }
             this->_uvs.push_back(rows);
         }

source/engine/graphics/front/object/TileArray.hpp

@@ -13,7 +13,7 @@
 namespace megu {
     class TileArray : public Quads {
         public:
-            TileArray(const std::filesystem::path &, size_t, size_t, float);
+            TileArray(const std::filesystem::path &, size_t, size_t, float, size_t);
 
             inline void setPosition(const Vec2 & pos)   {this->_transformation.setPosition(pos.x, pos.y);}
             inline void setOrigine(const Vec2 & pos)    {this->_transformation.setOrigine(pos.x, pos.y);}

source/game/Game.cpp

@@ -20,17 +20,10 @@ namespace megu::game {
             FrameCounter counter;
 
             kernel::Kernel kernel(window);
-
-            /* object */
             auto path = std::filesystem::path("assets/textures/Neera.png");
             megu::game::Object object(path);
             kernel.add(&object);
 
-            /*megu::game::Object object2(path);
-            object2.tmp_setPos(20, 0);
-            kernel.add(&object2);*/
-            /* ------ */
-
             while(window.isOpen()) {
                 counter.count(Window::Time());
                 window.pollEvents();

source/game/back/GameObject.hpp

+#pragma once
+
+namespace megu::game {
+    class GameObject {
+        public:
+            virtual void setup() = 0;
+            virtual void destroy() = 0;
+    };
+}
\ No newline at end of file

source/game/back/message/Receiver.hpp

+#pragma once
+
+#include <game/back/GameObject.hpp>
+
+namespace megu::game {
+    class Message;
+
+    class Collider : public GameObject {
+        public:
+            Collider<>
+
+            virtual void setup();
+
+            virtual void on(Message &);
+            virtual Message make()
+    };
+}
\ No newline at end of file

source/game/back/object/Terrain.hpp

+#pragma once
+
+#include <kernel/front/props/PropsTileMap.hpp>
+
+namespace megu::game {
+    class Terrain : public kernel::PropsTileMap {
+        public:
+            Terrain(float, float);
+
+        private:
+            kernel::Tilemap _graphicMap;
+            kernel::FixedArray _solidMap;
+    };
+}
\ No newline at end of file

source/game/object/Test.cpp

@@ -2,16 +2,45 @@
 
 namespace megu::game {
     Object::Object(std::filesystem::path & path)
-    : _physic(0, 0, 64, 64), _graphic(path), _map("assets/tilemap.png", 2, 2, 16.f, 16) {
+    : _physic(0, 0, 64, 64), _graphic(path), _map("assets/tilemap.png", 8, 8, 8.f, 16, 0.125) {
         this->_graphic.setFrame({0.f, 0.f, 51.f, 98.f});
         this->_graphic.setSize({51.f, 98.f});
 
-        this->_map.setValue(0, 0, 1);
-        this->_map.setValue(1, 0, 2);
-        this->_map.setValue(0, 1, 1);
-        this->_map.setValue(1, 1, 1);
+        size_t tab[8][8] = {
+            {44,  45,  44,  47, 2, 1, 1, 1},
+            {45,  45,  44,  47, 1, 1, 1, 1},
+            {45,  44,  44,  47, 1, 1, 1, 1},
+            {22,  22,  22,  23, 1, 1, 2, 1},
+            {28,  28,  28,  29, 1, 1, 1, 1},
+            { 1,   2,   1,   1, 1, 1, 1, 1},
+            { 1,   2,   1,   1, 1, 1, 1, 1},
+            { 1,   1,   1,   2, 1, 1, 1, 1}
+        };
 
-        this->_map.addAnimation(0, 1, {18, 19, 20, 21});
-        this->_map.addAnimation(1, 1, {18, 19, 20, 21});
+        for(size_t i = 0; i < 8; ++i) {
+            for(size_t j = 0; j < 8; ++j) {
+                this->_map.setValue(j, i, tab[i][j]);
+            }
+        }
+
+        this->_map.addAnimation(0, 6, {18, 18, 20, 21});
+        this->_map.addAnimation(1, 6, {18, 18, 20, 21});
+        this->_map.addAnimation(2, 6, {18, 18, 20, 21});
+        this->_map.addAnimation(3, 6, {18, 18, 20, 21});
+        this->_map.addAnimation(4, 6, {18, 18, 20, 21});
+        this->_map.addAnimation(5, 6, {18, 18, 20, 21});
+        this->_map.addAnimation(6, 6, {18, 18, 20, 21});
+        this->_map.addAnimation(7, 6, {18, 18, 20, 21});
+
+        this->_map.addAnimation(0, 7, {24, 25, 26, 27});
+        this->_map.addAnimation(1, 7, {24, 25, 26, 27});
+        this->_map.addAnimation(2, 7, {24, 25, 26, 27});
+        this->_map.addAnimation(3, 7, {24, 25, 26, 27});
+        this->_map.addAnimation(4, 7, {24, 25, 26, 27});
+        this->_map.addAnimation(5, 7, {24, 25, 26, 27});
+        this->_map.addAnimation(6, 7, {24, 25, 26, 27});
+        this->_map.addAnimation(7, 7, {24, 25, 26, 27});
+
+        this->_map.setSize({360 / 8, 360 / 8});
     }
 }
\ No newline at end of file

source/game/object/Test.hpp

 #pragma once
 
-#include <kernel/back/props/Props.hpp>
+#include <kernel/front/props/Props.hpp>
 #include <kernel/front/component/physic/Fixed.hpp>
 #include <kernel/front/component/graphic/Sprite.hpp>
 #include <kernel/front/component/graphic/TileMap.hpp>
 
 namespace megu::game {
-    class Object : public kernel::Props {
+    class Object : public kernel::Prop {
         public:
             Object(std::filesystem::path &);
 
-            inline kernel::Physical<kernel::PhysicEngine> * getPhysicComponent() override {return &this->_physic;}
-            inline kernel::Graphical<kernel::GraphicEngine> * getGraphicComponent() override {return &this->_map;}
+            inline kernel::Prop::Physical_Component * getPhysicComponent() override {return &this->_physic;}
+            inline kernel::Prop::Graphical_Component * getGraphicComponent() override {return &this->_map;}
 
         private:
             kernel::Fixed _physic;

source/kernel/back/props/Graphical.hpp → source/kernel/back/component/Graphical.hpp

 #pragma once
 
 #include "Component.hpp"
+#include <engine/utility/Priority.hpp>
 
 namespace megu::kernel {
     template <class Ge>

source/kernel/back/props/Physical.hpp → source/kernel/back/component/Physical.hpp

 #pragma once
 
-#include <functional>
-
 #include "Component.hpp"
+
+#include <functional>
 #include <utility/Identifiable.hpp>
 
 namespace megu::kernel {

source/kernel/back/engine/GraphicEngine.hpp

@@ -10,7 +10,7 @@
 #include <engine/graphics/front/module/TileArray_Module.hpp>
 #include <engine/graphics/front/object/TileArray.hpp>
 
-#include <kernel/back/props/Graphical.hpp>
+#include <kernel/back/component/Graphical.hpp>
 
 namespace megu::kernel {
     class GraphicEngine : public Engine<megu::GraphicEngine, Graphical<GraphicEngine>, Renderable> {

source/kernel/back/engine/PhysicEngine.hpp

@@ -3,7 +3,7 @@
 #include "Engine.hpp"
 
 #include <engine/physic/front/engine/Engine.hpp>
-#include <kernel/back/props/Physical.hpp>
+#include <kernel/back/component/Physical.hpp>
 
 namespace megu::kernel {
     class PhysicEngine : public Engine<megu::PhysicEngine, Physical<PhysicEngine>, Tangible> {

source/kernel/front/Kernel.cpp

@@ -24,7 +24,7 @@ namespace megu::kernel {
         this->_pResolver.resolve(*this, this->_pEngine, time);
     }
 
-    void Kernel::add(Props * props) {
+    void Kernel::add(Prop * props) {
         this->_props[props->id()] = props;
         auto * pComponent = props->getPhysicComponent();
         if(pComponent != nullptr) {

source/kernel/front/Kernel.hpp

@@ -4,23 +4,24 @@
 
 #include <engine/io/Window.hpp>
 
-#include <kernel/back/engine/PhysicEngine.hpp>
-#include <kernel/back/engine/GraphicEngine.hpp>
-#include <kernel/back/props/Props.hpp>
+#include <kernel/front/props/Props.hpp>
 
-#include "resolver/PhysicResolver.hpp"
 #include "resolver/GraphicResolver.hpp"
+#include "resolver/PhysicResolver.hpp"
 
 namespace megu::kernel {
+    class PhysicResolver;
+    class GraphicResolver;
+
     class Kernel {
         public:
             Kernel(Window &);
            ~Kernel();
 
             void step();
-            void add(Props *);
+            void add(Prop *);
 
-            inline Identifiable_Map<Props> & props() {return this->_props;}
+            inline Identifiable_Map<Prop> & props() {return this->_props;}
 
             inline PhysicEngine & getPhysicEngine() {return this->_pEngine;}
             inline GraphicEngine & getGraphicEngine() {return this->_gEngine;}
@@ -31,7 +32,7 @@ namespace megu::kernel {
             PhysicEngine _pEngine; 
             GraphicEngine _gEngine;
 
-            Identifiable_Map<Props> _props;
+            Identifiable_Map<Prop> _props;
             PhysicResolver _pResolver;
             GraphicResolver _gResolver;
     };

source/kernel/front/component/graphic/Sprite.hpp

@@ -5,7 +5,7 @@
 #include <chrono>
 
 #include <kernel/back/engine/GraphicEngine.hpp>
-#include <kernel/back/props/Graphical.hpp>
+#include <kernel/back/component/Graphical.hpp>
 #include <kernel/back/linker/GraphicLinker.hpp>
 
 #include <engine/utility/ref_set.hpp>

source/kernel/front/component/graphic/TileMap.cpp

@@ -4,14 +4,17 @@ namespace megu::kernel {
     UniqueGraphicLinker<TileArray> Tilemap::_Linker = UniqueGraphicLinker<TileArray>();
 
     Tilemap::Tilemap(const std::filesystem::path & path, size_t width, size_t height, float size, size_t lenght, double aUpdate) 
-    : TileArray(path, width , height, size), _tileSize(lenght), _duration(aUpdate) {
+    : TileArray(path, width , height, size, lenght), _tileSize(lenght), _duration(aUpdate) {
         if(lenght % width != 0 && lenght % height != 0) {
             throw std::runtime_error("Tilemap dimension not matching tiles size.");
         }
 
-        for(size_t x = 0; x < this->texture().width() - this->_tileSize*2; x += this->_tileSize) {
-            for(size_t y = 0; y < this->texture().height() - this->_tileSize*2; y += this->_tileSize) {
-                this->_tilesPosition.push_back({y, x});
+        size_t tileWidth = this->texture().width() / this->_tileSize;
+        size_t tileHeight = this->texture().height() / this->_tileSize;
+        
+        for(size_t y = 0; y < tileHeight; ++y) {
+            for(size_t x = 0; x < tileWidth; ++x) {
+                this->_tilesPosition.push_back({x * this->_tileSize, y * this->_tileSize});
             }
         }
         
@@ -28,10 +31,19 @@ namespace megu::kernel {
            Tilemap::_Linker.setModule(new TileArray_Module{});
         }
 
-        this->setSize({width * size, height * size});
+        //this->setSize({width * size, height * size});
     }
 
     void Tilemap::setValue(size_t x, size_t y, size_t value) {
+        if(this->width() <= x || this->height() <= y) {
+            throw std::runtime_error("Set Tilemap coords out of range.");
+        }
+
+        if(value >= this->_tilesPosition.size()) {
+            std::cerr << value << " for " << this->_tilesPosition.size() << std::endl;
+            throw std::runtime_error("Set Tilemap value out of range.");
+        }
+
         TilePosition position = this->_tilesPosition[value];
         glm::vec4 uv = {position.x, 
                         this->texture().height()  - position.y - this->_tileSize, 
@@ -42,7 +54,12 @@ namespace megu::kernel {
         this->_tilesValue[x][y] = value;
     }
 
-    size_t Tilemap::getValue(size_t x, size_t y) {
+    size_t Tilemap::getValue(size_t x, size_t y) const {
+        TilePosition position = {x, y};
+        if(this->_animations.contains(position)) {
+            return this->_animations.at(position).first.at(this->_animations.at(position).second);
+        }
+
         if(this->_tilesValue.size() > x && this->_tilesValue[x].size() > y) {
             return this->_tilesValue[x][y];
         }
@@ -50,15 +67,16 @@ namespace megu::kernel {
     }
 
     void Tilemap::addAnimation(size_t x, size_t y, const std::vector<size_t> & ids) {
+        if(x < this->width() && y < this->height()) {
             this->_animations[{x, y}] = std::pair<std::vector<size_t>, size_t>(ids, 0);
         }
+    }
 
     void Tilemap::removeAnimation(size_t x, size_t y) {
         this->_animations.erase({x, y});
     }
 
     void Tilemap::update(double time) {
-        //... Peut-être des tiles animées si j'ai le temps 🙌 (spoiler non).
         if(this->_previous == 0.0) {
             this->_previous = time;
         }

source/kernel/front/component/graphic/TileMap.hpp

@@ -4,7 +4,7 @@
 #include <vector>
 
 #include <kernel/back/engine/GraphicEngine.hpp>
-#include <kernel/back/props/Graphical.hpp>
+#include <kernel/back/component/Graphical.hpp>
 #include <kernel/back/linker/UniqueLinker.hpp>
 
 #include <engine/graphics/front/object/TileArray.hpp>
@@ -17,29 +17,31 @@ namespace megu::kernel {
                 size_t x = 0;
                 size_t y = 0;
 
-                friend bool operator<(const TilePosition & p1, const TilePosition & p2) {
-                    if(p1.x == p2.x) {
-                        return p1.y < p2.y;
+                bool operator<(const TilePosition & p) const {
+                    if(this->x == p.x) {
+                        return this->y < p.y;
                     }
-                    return p1.x < p1.y;
+                    return this->y < p.y;
                 }
             };
 
             Tilemap(const std::filesystem::path &, size_t, size_t, float, size_t, double = 0.1);
 
             void setValue(size_t, size_t, size_t);
-            size_t getValue(size_t, size_t);
+            size_t getValue(size_t, size_t) const;
 
             void addAnimation(size_t, size_t, const std::vector<size_t> &);
             void removeAnimation(size_t, size_t);
 
+            const std::map<TilePosition, std::pair<std::vector<size_t>, size_t>, reference_sorter<TilePosition>> & animation() const {return this->_animations;}
+
             void update(double) override;
             void apply(Kernel &, GraphicEngine &) override;
 
         private:
             std::vector<TilePosition> _tilesPosition;
             std::vector<std::vector<size_t>> _tilesValue;
-            std::map<TilePosition, std::pair<std::vector<size_t>, size_t>> _animations;
+            std::map<TilePosition, std::pair<std::vector<size_t>, size_t>, reference_sorter<TilePosition>> _animations;
             TileArray_Module _module;
             size_t _tileSize;
             double _duration;

source/kernel/front/component/physic/Fixed.hpp

 #pragma once
 
-#include <kernel/back/props/Physical.hpp>
+#include <kernel/back/component/Physical.hpp>
 #include <kernel/back/engine/PhysicEngine.hpp>
 
 #include <engine/physic/front/object/TangibleStatic.hpp>