diff --git a/assets/player.png b/assets/player.png
new file mode 100644
index 0000000000000000000000000000000000000000..c84d047f428c2c2dadeff99120314ec06d313048
Binary files /dev/null and b/assets/player.png differ
diff --git a/assets/player.png.old b/assets/player.png.old
new file mode 100644
index 0000000000000000000000000000000000000000..70456833ec2e399ebc897d12cc6abd8f1423db91
Binary files /dev/null and b/assets/player.png.old differ
diff --git a/source/engine/graphics/front/object/TileArray.cpp b/source/engine/graphics/front/object/TileArray.cpp
index 475635b88783b1fe8b956d43f45d4e7fd15689b7..78953d5c33c07c542ba22949a5b88ad26e48cbef 100644
--- a/source/engine/graphics/front/object/TileArray.cpp
+++ b/source/engine/graphics/front/object/TileArray.cpp
@@ -3,8 +3,8 @@
#include <iostream>
namespace megu {
- TileArray::TileArray(const std::filesystem::path & path, size_t width, size_t height, float size, size_t lenght)
- : _width(width), _height(height), _size(size) {
+ TileArray::TileArray(const std::filesystem::path & path, size_t width, size_t height, float tileSize, size_t lenght)
+ : _width(width), _height(height), _tileSize(tileSize) {
megu::TextureBuffer buffer(path);
this->_texture.store(buffer);
diff --git a/source/engine/graphics/front/object/TileArray.hpp b/source/engine/graphics/front/object/TileArray.hpp
index c4191dc76ff1e2a79032889a7ab51104cf693088..b8862f5da55eb2e6926da3132fb0f768ede3022f 100644
--- a/source/engine/graphics/front/object/TileArray.hpp
+++ b/source/engine/graphics/front/object/TileArray.hpp
@@ -27,7 +27,8 @@ namespace megu {
inline size_t width() const {return this->_width;}
inline size_t height() const {return this->_height;}
- inline float size() const {return this->_size;}
+ inline float getTileSize() const {return this->_tileSize;}
+ inline const Vec3 & getSize() const {return this->_transformation.scaling();}
inline void setUv(size_t x, size_t y, const glm::vec4 & uv) {this->_uvs[y][x] = uv;}
@@ -41,7 +42,7 @@ namespace megu {
Transformable _transformation;
Texture _texture;
size_t _width, _height;
- float _size;
+ float _tileSize;
std::vector<std::vector<glm::vec4>> _uvs;
};
}
\ No newline at end of file
diff --git a/source/engine/physic/back/SquareBox.cpp b/source/engine/physic/back/SquareBox.cpp
index a8b45757ce6210507cc6e700c8dc8cdf4f520b1a..13927a5991530f51f8fe78cf177d46344cd983cf 100644
--- a/source/engine/physic/back/SquareBox.cpp
+++ b/source/engine/physic/back/SquareBox.cpp
@@ -1,5 +1,7 @@
#include "SquareBox.hpp"
+#include <iostream>
+
namespace megu {
SquareBox::SquareBox(const Position & position, const Dimension & dimension)
: _position(position), _dimension(dimension) {}
@@ -31,21 +33,21 @@ namespace megu {
this->_position.move(direction.x(), direction.y(), direction.z());
}
- bool SquareBox::contain(const Position & position) const {
- if(position >= this->_position && position <= (this->_position + Position(this->_dimension))) {
- return true;
- }
- return false;
- }
+ bool SquareBox::intersect(const SquareBox & squareBox) const {
+ const Position & a = squareBox.position();
+ const Dimension & as = squareBox.dimension();
+ const Position & b = this->_position;
+ const Dimension & bs = this->_dimension;
- bool SquareBox::intersect(const SquareBox & SquareBox) const {
- const Cube cube = SquareBox.asCube();
- for(const auto & position : cube) {
- if(this->contain(position)) {
- return true;
- }
+ bool x = std::max(a.x(), b.x()) < std::min(a.x() + as.x, b.x() + bs.x);
+ bool y = std::max(a.y(), b.y()) < std::min(a.y() + as.y, b.y() + bs.y);
+
+ bool z = true;
+ if(a.z() != 0 && b.z() != 0) {
+ z = std::max(a.z(), b.z()) < std::min(a.z() + as.z, b.z() + bs.z);
}
- return false;
+
+ return x && y && z;
}
bool SquareBox::operator==(const SquareBox & squareBox) const {
diff --git a/source/engine/physic/back/SquareBox.hpp b/source/engine/physic/back/SquareBox.hpp
index aa2e7dfcabf023c96e175cf7e12a5e9da589e076..47afd297c6c8d8801e0e1dceb44127dee7cb1b4f 100644
--- a/source/engine/physic/back/SquareBox.hpp
+++ b/source/engine/physic/back/SquareBox.hpp
@@ -28,8 +28,6 @@ namespace megu {
Cube asCube() const;
void move(const Direction &);
-
- bool contain(const Position &) const;
bool intersect(const SquareBox &) const;
bool operator==(const SquareBox &) const;
diff --git a/source/engine/physic/front/engine/Engine.cpp b/source/engine/physic/front/engine/Engine.cpp
index d32f1b3d6d37a74e455b2b449fc64686ac1bbb79..764b16321ac372da28446e901a41f2000a8c4d51 100644
--- a/source/engine/physic/front/engine/Engine.cpp
+++ b/source/engine/physic/front/engine/Engine.cpp
@@ -53,6 +53,7 @@ namespace megu {
for(auto & target : this->_statics[priority]) {
if(source.get().isColliding(target)) {
this->_collisions.insert(Collision(source, target));
+ this->_collisions.insert(Collision(target, source));
}
}
diff --git a/source/engine/physic/front/object/Tangible.cpp b/source/engine/physic/front/object/Tangible.cpp
index eb6b3dfc334af60e1c98006ed0c792fd9a42b118..5915036ae78d16ee36f5064c4c3401e732adf10d 100644
--- a/source/engine/physic/front/object/Tangible.cpp
+++ b/source/engine/physic/front/object/Tangible.cpp
@@ -1,5 +1,7 @@
#include "Tangible.hpp"
+#include <iostream>
+
namespace megu {
Tangible::Tangible(const Position & position, const Dimension & dimension)
: _box(position, dimension) {}
@@ -11,6 +13,10 @@ namespace megu {
return false;
}
+ bool Tangible::isColliding(const SquareBox & box) const {
+ return this->_box.intersect(box);
+ }
+
bool Tangible::operator==(const Tangible & entity) const {
return this->_box == entity._box;
}
diff --git a/source/engine/physic/front/object/Tangible.hpp b/source/engine/physic/front/object/Tangible.hpp
index 8345cf52c03fa3e2c6393e434da938f6ac44f923..28a00967240f54b4d5d45d9f63284a28f36de8c4 100644
--- a/source/engine/physic/front/object/Tangible.hpp
+++ b/source/engine/physic/front/object/Tangible.hpp
@@ -25,6 +25,7 @@ namespace megu {
inline void move(float x, float y, float z = 0.f) {return this->move(Direction(x, y, z));}
bool isColliding(const Tangible &) const;
+ bool isColliding(const SquareBox &) const;
bool operator==(const Tangible &) const;
//bool operator!=(const Tangible &) const;
diff --git a/source/game/Game.cpp b/source/game/Game.cpp
index 0b838bb17b94bfd3f0f76ea8d3482981ea2fb2d5..eb156096f11444b9b4a4e5012095621548456874 100644
--- a/source/game/Game.cpp
+++ b/source/game/Game.cpp
@@ -6,6 +6,8 @@
#include <game/back/object/Player.hpp>
#include <game/back/object/Enemy.hpp>
#include <game/back/object/Level.hpp>
+#include <game/back/object/Terrain.hpp>
+#include <game/back/object/tile/TileSolide.hpp>
#include <game/object/Test.hpp>
#include <game/utility/FrameCouter.hpp>
@@ -23,23 +25,31 @@ namespace megu::game {
FrameCounter counter;
kernel::Kernel kernel(window);
- auto path = std::filesystem::path("assets/textures/Neera.png");
- megu::game::Object object(path);
- //kernel.add(&object);
-
- Player player(16, 16, 16, 16, path);
+ auto path = std::filesystem::path("assets/player.png");
+ //megu::game::Object object(path);
+
+ Player player(0, 0, 32, 32, path);
Enemy enemy(64, 64, 16, 16, path);
+ Terrain terrain(0.f, 0.f, 32.f, 32.f, "assets/tilemap.png", 4, 4, 32.f, 16);
+
+ terrain.setTileEvent(1, new TileSolide(32.f));
+ terrain.setValue(1, 1, 1);
+ terrain.setValue(0, 1, 2);
+
Level level("STZ");
- level.add(&player);
- level.add(&enemy);
+ terrain.setup(kernel, level);
+ terrain.apply(kernel);
+
+ //level.add(&enemy);
+ level.add(&player);
player.setup(kernel, level);
player.apply(kernel);
- enemy.setup(kernel, level);
- enemy.apply(kernel);
+ //enemy.setup(kernel, level);
+ //enemy.apply(kernel);
std::cout << "..." << std::endl;
diff --git a/source/game/back/GameObject.hpp b/source/game/back/GameObject.hpp
index d587ea1cb39eb65b1632ab2487101386526b0cf0..72aa6e966cdb0043ac9042c646e58bfd7d4126c4 100644
--- a/source/game/back/GameObject.hpp
+++ b/source/game/back/GameObject.hpp
@@ -1,7 +1,7 @@
#pragma once
#include <kernel/front/Kernel.hpp>
-#include <game/back/message/Behavior.hpp>
+#include <game/back/message/Event.hpp>
namespace megu::game {
class Level;
@@ -13,14 +13,17 @@ namespace megu::game {
virtual void apply(kernel::Kernel &) = 0;
};
- class GameProps : public GameObject {
+ class GameEvent {
+ public:
+ virtual void on(const kernel::Prop &, const Event &) = 0;
+ virtual std::optional<Event> on() const = 0;
+ };
+
+ class GameProps : public GameObject, public GameEvent {
public:
GameProps(kernel::Prop * prop)
: _props(prop) {}
- virtual void on(const Behavior &) = 0;
- virtual std::optional<Behavior> on() const = 0;
-
inline kernel::Prop * get() {return this->_props;}
private:
diff --git a/source/game/back/message/Behavior.cpp b/source/game/back/message/Behavior.cpp
deleted file mode 100644
index 8fe8d2e05c83ec44077b1217fd5d5362958f557e..0000000000000000000000000000000000000000
--- a/source/game/back/message/Behavior.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "Behavior.hpp"
-
-namespace megu::game {
- Behavior::Behavior(const kernel::Prop & author, uint32_t type)
- : _type(type), _stats(author) {}
-
- uint32_t Behavior::get(uint32_t key) const {
- return this->_stats.get(key);
- }
-
- void Behavior::set(uint32_t key, uint32_t value) {
- this->_stats.set(key, value);
- }
-
- uint32_t Behavior::operator&(const uint32_t & type) const {
- return this->_type & type;
- }
-}
\ No newline at end of file
diff --git a/source/game/back/message/Behavior.hpp b/source/game/back/message/Behavior.hpp
deleted file mode 100644
index 6a6dce2be8438016fa10415d753ebaf69ae789ba..0000000000000000000000000000000000000000
--- a/source/game/back/message/Behavior.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma once
-
-#include "StatsAlterator.hpp"
-
-namespace megu::game {
- class Behavior {
- public:
- enum Type : uint32_t {
- SOLID = 1,
- DAMAGE = 2,
- };
-
- Behavior() = delete;
- Behavior(const kernel::Prop &, uint32_t);
-
- uint32_t get(uint32_t) const;
- void set(uint32_t, uint32_t);
-
-
- uint32_t operator&(const uint32_t &) const;
-
- private:
- uint32_t _type;
- StatsAlterator _stats;
- };
-}
-
-
-
\ No newline at end of file
diff --git a/source/game/back/message/Event.cpp b/source/game/back/message/Event.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f7fdd7e9a261f4c957aaf361ffa722a01bde0ba8
--- /dev/null
+++ b/source/game/back/message/Event.cpp
@@ -0,0 +1,18 @@
+#include "Event.hpp"
+
+namespace megu::game {
+ Event::Event(uint32_t type)
+ : _type(type) {}
+
+ std::optional<uint32_t> Event::get(size_t key) const {
+ return this->_stats.get(key);
+ }
+
+ void Event::set(size_t key, uint32_t value) {
+ this->_stats.set(key, value);
+ }
+
+ bool Event::operator&(const uint32_t & type) const {
+ return (this->_type & type) != 0;
+ }
+}
\ No newline at end of file
diff --git a/source/game/back/message/Event.hpp b/source/game/back/message/Event.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..889bccb28d25879c6f412b8a21ee61acb1751101
--- /dev/null
+++ b/source/game/back/message/Event.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "StatsAlterator.hpp"
+
+namespace megu::game {
+ class Event {
+ public:
+ enum Type : uint32_t {
+ SOLID = 1,
+ DAMAGE = 2,
+ };
+
+ Event() = delete;
+ Event(uint32_t);
+
+ std::optional<uint32_t> get(size_t) const;
+ void set(size_t, uint32_t);
+
+ bool operator&(const uint32_t &) const;
+
+ private:
+ uint32_t _type;
+ StatsAlterator<uint32_t> _stats;
+ };
+}
+
+
+
\ No newline at end of file
diff --git a/source/game/back/message/StatsAlterator.cpp b/source/game/back/message/StatsAlterator.cpp
deleted file mode 100644
index 4ea95898c790b6c76fb564f4b986d70280f70370..0000000000000000000000000000000000000000
--- a/source/game/back/message/StatsAlterator.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "StatsAlterator.hpp"
-
-namespace megu::game {
- StatsAlterator::StatsAlterator(const kernel::Prop & author)
- : _author(author) {}
-
- uint32_t StatsAlterator::get(uint32_t key) const {
- if(this->_stats.contains(key)) {
- return this->_stats.at(key);
- }
- return 0;
- }
-
- void StatsAlterator::set(uint32_t key, uint32_t value) {
- this->_stats[key] = value;
- }
-
- const uint32_t & StatsAlterator::operator[](const uint32_t & key) const {
- if(this->_stats.contains(key)) {
- return this->_stats.at(key);
- }
- throw std::runtime_error("Cannot get stats value");
- }
-
- uint32_t & StatsAlterator::operator[](const uint32_t & key) {
- if(this->_stats.contains(key)) {
- return this->_stats.at(key);
- }
- throw std::runtime_error("Cannot get stats value");
- }
-}
\ No newline at end of file
diff --git a/source/game/back/message/StatsAlterator.hpp b/source/game/back/message/StatsAlterator.hpp
index f8ceaf528affb73e1860d91472deb66cd08d12f3..e4acfc4cf5a62f3d4b8e0f7cc608c345a720195f 100644
--- a/source/game/back/message/StatsAlterator.hpp
+++ b/source/game/back/message/StatsAlterator.hpp
@@ -3,19 +3,19 @@
#include <kernel/front/props/Props.hpp>
namespace megu::game {
+ template <class D>
class StatsAlterator {
public:
- StatsAlterator() = delete;
- StatsAlterator(const kernel::Prop &);
+ StatsAlterator() = default;
- uint32_t get(uint32_t) const;
- void set(uint32_t, uint32_t);
+ std::optional<D> get(size_t) const;
+ void set(size_t, D);
- const uint32_t & operator[](const uint32_t &) const;
- uint32_t & operator[](const uint32_t &);
+ std::optional<D> operator[](size_t) const;
private:
- std::map<uint32_t, uint32_t> _stats;
- const kernel::Prop & _author;
+ std::map<size_t, D> _stats;
};
-}
\ No newline at end of file
+}
+
+#include "StatsAlterator.tpp"
\ No newline at end of file
diff --git a/source/game/back/message/StatsAlterator.tpp b/source/game/back/message/StatsAlterator.tpp
new file mode 100644
index 0000000000000000000000000000000000000000..155e4e3a214bb2d5da482a233a875983290f60f8
--- /dev/null
+++ b/source/game/back/message/StatsAlterator.tpp
@@ -0,0 +1,21 @@
+#include "StatsAlterator.hpp"
+
+namespace megu::game {
+ template <class D>
+ std::optional<D> StatsAlterator<D>::get(size_t key) const {
+ if(this->_stats.contains(key)) {
+ return this->_stats.at(key);
+ }
+ return {};
+ }
+
+ template <class D>
+ void StatsAlterator<D>::set(size_t key, D value) {
+ this->_stats[key] = value;
+ }
+
+ template <class D>
+ std::optional<D> StatsAlterator<D>::operator[](size_t key) const {
+ return this->get(key);
+ }
+}
\ No newline at end of file
diff --git a/source/game/back/object/Enemy.cpp b/source/game/back/object/Enemy.cpp
index b8f416a014d45fc6d26ec874c3bab4f1553d307d..5e93f2bf1365aeeb69d157ba7fc6af8b3bd275bb 100644
--- a/source/game/back/object/Enemy.cpp
+++ b/source/game/back/object/Enemy.cpp
@@ -18,25 +18,28 @@ namespace megu::game {
this->_sprite.setSize({51.f, 98.f});
this->_movable.setCollideLambda([this, &level](kernel::Kernel &, kernel::PhysicEngine &, Identifiable & id, kernel::Physical<kernel::PhysicEngine> & comp, double) {
- auto event = level.get(id)->on();
- if(event.has_value()) {
- this->on(event.value());
+ auto object = level.get(id);
+ if(object.has_value()) {
+ auto event = object->get().on();
+ if(event.has_value()) {
+ this->on(*object->get().get(), event.value());
+ }
}
});
}
- void Enemy::on(const Behavior & event) {
- if(event & Behavior::Type::SOLID) {
+ void Enemy::on(const kernel::Prop &, const Event & event) {
+ if(event & Event::Type::SOLID) {
this->onSolide(event);
}
- if(event & Behavior::Type::DAMAGE) {
+ if(event & Event::Type::DAMAGE) {
this->onDamage(event);
}
}
- std::optional<Behavior> Enemy::on() const {
- Behavior b(*this, Behavior::DAMAGE);
+ std::optional<Event> Enemy::on() const {
+ Event b(Event::DAMAGE);
b.set(0, 10);
return b;
@@ -50,11 +53,11 @@ namespace megu::game {
kernel.add(this);
}
- void Enemy::onDamage(const Behavior &) {
+ void Enemy::onDamage(const Event &) {
std::cout << "Enemy Got Damage !" << std::endl;
}
- void Enemy::onSolide(const Behavior &) {
+ void Enemy::onSolide(const Event &) {
std::cout << "Enemy Got Solide !" << std::endl;
}
}
\ No newline at end of file
diff --git a/source/game/back/object/Enemy.hpp b/source/game/back/object/Enemy.hpp
index 7de282494d0d9df9e47bf49374cea0889a6cdc37..89bacf93a7c541db9d8941550d3edbdb839eb1c2 100644
--- a/source/game/back/object/Enemy.hpp
+++ b/source/game/back/object/Enemy.hpp
@@ -1,7 +1,7 @@
#pragma once
-#include <game/back/GameObject.hpp>
#include <kernel/front/props/PropsDynamic.hpp>
+#include <game/back/GameObject.hpp>
#include <game/back/object/Level.hpp>
namespace megu::game {
@@ -16,11 +16,11 @@ namespace megu::game {
void apply(kernel::Kernel &) override;
- void on(const Behavior &) override;
- std::optional<Behavior> on() const override;
+ void on(const kernel::Prop &, const Event &) override;
+ std::optional<Event> on() const override;
- void onDamage(const Behavior &);
- void onSolide(const Behavior &);
+ void onDamage(const Event &);
+ void onSolide(const Event &);
private:
kernel::Sprite _sprite;
diff --git a/source/game/back/object/Level.cpp b/source/game/back/object/Level.cpp
index 8dc9f55502095e848a5ea5388931ca20c50a73db..5fbbcfdd34eaa8874a794b385bfd95acc06008c3 100644
--- a/source/game/back/object/Level.cpp
+++ b/source/game/back/object/Level.cpp
@@ -4,8 +4,13 @@ namespace megu::game {
Level::Level(const std::string & name)
: _name(name) {}
- GameProps * Level::get(Identifiable & id) const {
- return this->_objecs.at(id.id());
+ std::optional<std::reference_wrapper<GameProps>> Level::get(Identifiable & id) const {
+ for(auto it = this->_objecs.begin(); it != this->_objecs.end(); ++it) {
+ if(it->first == id) {
+ return *it->second;
+ }
+ }
+ return {};
}
void Level::add(GameProps * prop) {
diff --git a/source/game/back/object/Level.hpp b/source/game/back/object/Level.hpp
index 3f047c9d8965ea52c0c37ee71e22360a3c0f9a96..f82e2a930dff57af02d59b96452deb84c63731f5 100644
--- a/source/game/back/object/Level.hpp
+++ b/source/game/back/object/Level.hpp
@@ -12,7 +12,7 @@ namespace megu::game {
void add(GameProps *);
- GameProps * get(Identifiable &) const;
+ std::optional<std::reference_wrapper<GameProps>> get(Identifiable &) const;
virtual void apply(kernel::Kernel &) override final;
virtual void setup(kernel::Kernel &, Level &) override;
diff --git a/source/game/back/object/Player.cpp b/source/game/back/object/Player.cpp
index df16c72a6b6b1754435a1d13757d4c22147d99c4..d77418f2075d663d2a3673659c5879b767084f7a 100644
--- a/source/game/back/object/Player.cpp
+++ b/source/game/back/object/Player.cpp
@@ -7,6 +7,7 @@ namespace megu::game {
Player::Player(float x, float y, float w, float h, std::filesystem::path & path)
: kernel::PropsPlayable(this->_sprite, this->_movable), GameProps(this), _sprite(path), _movable(x, y, w, h) {
this->_sprite.setPosition({x, y});
+ this->_sprite.setLayerObject(2);
}
void Player::move(float x, float y) {
@@ -17,28 +18,32 @@ namespace megu::game {
void Player::setup(kernel::Kernel & kernel, Level & level) {
this->setControl(kernel.window(), new PlayerKeyProfile(*this));
- this->_sprite.setFrame({0.f, 0.f, 51.f, 98.f});
- this->_sprite.setSize({51.f, 98.f});
+ this->_sprite.setFrame({0.f, 0.f, 16.f, 16.f});
+ this->_sprite.setSize({32.f, 32.f});
this->_movable.setCollideLambda([this, &level](kernel::Kernel &, kernel::PhysicEngine &, Identifiable & id, kernel::Physical<kernel::PhysicEngine> & comp, double) {
- auto event = level.get(id)->on();
- if(event.has_value()) {
- this->on(event.value());
+ auto object = level.get(id);
+
+ if(object.has_value()) {
+ auto event = object.value().get().on();
+ if(event.has_value()) {
+ this->on(*object.value().get().get(), event.value());
+ }
}
});
}
- void Player::on(const Behavior & event) {
- if((event & Behavior::Type::SOLID) != 0) {
+ void Player::on(const kernel::Prop &, const Event & event) {
+ if((event & Event::Type::SOLID) != 0) {
this->onSolide(event);
}
- if((event & Behavior::Type::DAMAGE) != 0) {
+ if((event & Event::Type::DAMAGE) != 0) {
this->onDamage(event);
}
}
- std::optional<Behavior> Player::on() const {
+ std::optional<Event> Player::on() const {
return {};
}
@@ -50,12 +55,12 @@ namespace megu::game {
kernel.add(this);
}
- void Player::onDamage(const Behavior & b) {
+ void Player::onDamage(const Event & b) {
std::cout << "Player Got Damage !" << std::endl;
- std::cout << "I take " << b.get(0) << " damage !" << std::endl;
+ std::cout << "I take " << b.get(0).value_or(0) << " damage !" << std::endl;
}
- void Player::onSolide(const Behavior &) {
+ void Player::onSolide(const Event &) {
std::cout << "Player Got Solide !" << std::endl;
}
}
\ No newline at end of file
diff --git a/source/game/back/object/Player.hpp b/source/game/back/object/Player.hpp
index 8fa5deaf930922495643e29703b8f0c18530109c..f97e2646ba94a488cc4a70210221fe8c40c60243 100644
--- a/source/game/back/object/Player.hpp
+++ b/source/game/back/object/Player.hpp
@@ -16,11 +16,11 @@ namespace megu::game {
void apply(kernel::Kernel &) override;
- void on(const Behavior &) override;
- std::optional<Behavior> on() const override;
+ void on(const kernel::Prop &, const Event &) override;
+ std::optional<Event> on() const override;
- void onDamage(const Behavior &);
- void onSolide(const Behavior &);
+ void onDamage(const Event &);
+ void onSolide(const Event &);
private:
kernel::Sprite _sprite;
diff --git a/source/game/back/object/Terrain.cpp b/source/game/back/object/Terrain.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dceb37eb2f5c00682d1bfded001ca43fd97fe3e0
--- /dev/null
+++ b/source/game/back/object/Terrain.cpp
@@ -0,0 +1,58 @@
+#include "Terrain.hpp"
+
+#include <game/back/object/Level.hpp>
+
+namespace megu::game {
+ Terrain::Terrain(float x, float y, float w, float h, const std::filesystem::path & path, size_t r, size_t c , float size, size_t tileSize)
+ : PropsTileMap(this->_graphic, this->_physic), GameProps(this), _graphic(path, r, c, size, tileSize), _physic(x, y, r * w, c * h) {
+ //! Taille Pour 1 tile !
+ this->_graphic.setSize({w, h});
+ }
+
+ void Terrain::setValue(size_t x, size_t y, size_t value) {
+ this->_graphic.setValue(x, y, value);
+ if(this->_event.contains(value)) {
+ this->_physic.push({static_cast<float>(x) * this->_graphic.getSize().x, (this->_graphic.getSize().y * (this->_graphic.height()- 1)) - static_cast<float>(y) * this->_graphic.getSize().y}, *this->_event[value]);
+ }
+ }
+
+ void Terrain::setTileEvent(size_t id, Tile * tile) {
+ this->_event[id] = std::shared_ptr<Tile>(tile);
+ }
+
+ void Terrain::setup(kernel::Kernel & kernel, Level & level) {
+ this->_physic.setCollideLambda([this, &level](kernel::Kernel &, kernel::PhysicEngine &, Identifiable & id, kernel::Tile & tile, double) {
+ auto it = this->_event.begin();
+ for(; it != this->_event.end(); ++it) {
+ if(*it->second == tile) {
+ break;
+ }
+ }
+
+ if(it != this->_event.end()) {
+ auto object = level.get(id);
+ auto event = it->second->on();
+
+ if(event.has_value() && object.has_value()) {
+ object.value().get().on(*this, event.value());
+ }
+ }
+ });
+ }
+
+ void Terrain::destroy(kernel::Kernel & kernel, Level & level) {
+ this->_event.clear();
+ }
+
+ void Terrain::apply(kernel::Kernel & kernel) {
+ kernel.add(this);
+ }
+
+ void Terrain::on(const kernel::Prop &, const Event & event) {
+ // The terrain itself don't react.
+ }
+
+ std::optional<Event> Terrain::on() const {
+ return {};
+ }
+}
\ No newline at end of file
diff --git a/source/game/back/object/Terrain.hpp b/source/game/back/object/Terrain.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..8fa99ec8fe29eada72f9686506f29034f2bc1c4a
--- /dev/null
+++ b/source/game/back/object/Terrain.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <kernel/front/props/PropsTileMap.hpp>
+#include <kernel/front/component/physic/TileArray.hpp>
+#include <kernel/front/component/graphic/TileMap.hpp>
+
+#include <game/back/GameObject.hpp>
+#include <game/back/object/tile/Tile.hpp>
+
+namespace megu::game {
+ class Terrain : public kernel::PropsTileMap, public GameProps {
+ public:
+ Terrain() = delete;
+ Terrain(float, float, float, float, const std::filesystem::path &, size_t, size_t, float, size_t);
+
+ void setValue(size_t, size_t, size_t);
+ void setTileEvent(size_t, Tile *);
+
+ void setup(kernel::Kernel &, Level &) override;
+ void destroy(kernel::Kernel &, Level &) override;
+ void apply(kernel::Kernel &) override;
+
+ void on(const kernel::Prop &, const Event &) override;
+ std::optional<Event> on() const override;
+
+ private:
+ kernel::Tilemap _graphic;
+ kernel::TileArray _physic;
+ std::map<size_t, std::shared_ptr<Tile>> _event;
+
+ };
+}
\ No newline at end of file
diff --git a/source/game/back/object/tile/Tile.cpp b/source/game/back/object/tile/Tile.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e25518716f412192697f627c492ec7d302408bfc
--- /dev/null
+++ b/source/game/back/object/tile/Tile.cpp
@@ -0,0 +1,6 @@
+#include "Tile.hpp"
+
+namespace megu::game {
+ Tile::Tile(float d)
+ : kernel::Tile(0, 0, d) {}
+}
\ No newline at end of file
diff --git a/source/game/back/object/tile/Tile.hpp b/source/game/back/object/tile/Tile.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ec35a38075d97b86e828ec338a788a8ce3c943b7
--- /dev/null
+++ b/source/game/back/object/tile/Tile.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <kernel/front/component/physic/Tile.hpp>
+#include <game/back/GameObject.hpp>
+
+#include <iostream>
+
+namespace megu::game {
+ class Tile : public kernel::Tile, public GameEvent {
+ public:
+ Tile() = delete;
+ Tile(float d);
+ };
+}
\ No newline at end of file
diff --git a/source/game/back/object/tile/TileSolide.cpp b/source/game/back/object/tile/TileSolide.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..91d1ae735a504fb834897df6c207ac81988a19d0
--- /dev/null
+++ b/source/game/back/object/tile/TileSolide.cpp
@@ -0,0 +1,14 @@
+#include "TileSolide.hpp"
+
+namespace megu::game {
+ TileSolide::TileSolide(float d)
+ : Tile(d) {}
+
+ void TileSolide::on(const kernel::Prop &, const Event &) {
+ //...
+ }
+
+ std::optional<Event> TileSolide::on() const {
+ return Event(Event::Type::SOLID);
+ }
+}
\ No newline at end of file
diff --git a/source/game/back/object/tile/TileSolide.hpp b/source/game/back/object/tile/TileSolide.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..84424f23fc812f297583af0de5817c6e20ae03f0
--- /dev/null
+++ b/source/game/back/object/tile/TileSolide.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Tile.hpp"
+
+namespace megu::game {
+ class TileSolide : public Tile {
+ public:
+ TileSolide(float d);
+
+ void on(const kernel::Prop &, const Event &) override;
+ std::optional<Event> on() const override;
+ };
+}
\ No newline at end of file
diff --git a/source/game/front/profile/PlayerKeys.cpp b/source/game/front/profile/PlayerKeys.cpp
index 3d835a9608372fdf2b3bbd79baabec266b103c75..ffeafb6565ff487403ac897e08fdcf338015fd5e 100644
--- a/source/game/front/profile/PlayerKeys.cpp
+++ b/source/game/front/profile/PlayerKeys.cpp
@@ -6,19 +6,19 @@ namespace megu::game {
void PlayerKeyProfile::on(Key key, int code, Action action, Mod mode) {
if(key == Keyboard::Key::ARROW_UP) {
- this->_player.move(0.f, 1.f);
+ this->_player.move(0.f, 0.5f);
}
if(key == Keyboard::Key::ARROW_DOWN) {
- this->_player.move(0.f, -1.f);
+ this->_player.move(0.f, -0.5f);
}
if(key == Keyboard::Key::ARROW_LEFT) {
- this->_player.move(-1.f, 0.f);
+ this->_player.move(-0.5f, 0.f);
}
if(key == Keyboard::Key::ARROW_RIGHT) {
- this->_player.move(1.f, 0.f);
+ this->_player.move(0.5f, 0.f);
}
}
}
\ No newline at end of file
diff --git a/source/kernel/back/linker/UniqueLinker.tpp b/source/kernel/back/linker/UniqueLinker.tpp
index 907a1069285edf757a78d2645791143bc2531cad..4a83e21a1f4d37b053af5e6887fa854b370f9726 100644
--- a/source/kernel/back/linker/UniqueLinker.tpp
+++ b/source/kernel/back/linker/UniqueLinker.tpp
@@ -20,8 +20,8 @@ namespace megu::kernel {
this->_delete.clear();
for(auto & [layer, object] : this->_await) {
- this->_stored.insert({layer, object});
- size_t id = engine.get().push<T>(layer.layer, layer.object, this->_stored[layer], this->_module.get());
+ this->_stored.insert({layer, {object, 0}});
+ size_t id = engine.get().push<T>(layer.layer, layer.object, this->_stored.at(layer).first.get(), this->_module.get());
this->_ids[layer] = id;
}
@@ -31,7 +31,7 @@ namespace megu::kernel {
template <class T>
void UniqueGraphicLinker<T>::unlink(T & object) {
for(auto & [layer, obj] : this->_stored) {
- if(&(obj.get()) == &object) {
+ if(&(obj.first.get()) == &object) {
this->_delete.insert(layer);
}
}
diff --git a/source/kernel/front/Kernel.cpp b/source/kernel/front/Kernel.cpp
index 59c942825165b1a4f735c27a083499b1cb197838..b69022ea59d1d298f4d29346425347666c4e4598 100644
--- a/source/kernel/front/Kernel.cpp
+++ b/source/kernel/front/Kernel.cpp
@@ -27,6 +27,7 @@ namespace megu::kernel {
void Kernel::add(Prop * props) {
this->_props[props->id()] = props;
auto * pComponent = props->getPhysicComponent();
+
if(pComponent != nullptr) {
this->_pEngine.add(*this, *pComponent);
this->_pResolver.add(*pComponent);
diff --git a/source/kernel/front/component/graphic/TileMap.hpp b/source/kernel/front/component/graphic/TileMap.hpp
index 6d6ad9d8c548d4ca646ce4de432ca6ccd6911fb0..648beddcef7e9dda26389c05220a7b0a4a7b5035 100644
--- a/source/kernel/front/component/graphic/TileMap.hpp
+++ b/source/kernel/front/component/graphic/TileMap.hpp
@@ -11,7 +11,7 @@
#include <engine/graphics/front/module/TileArray_Module.hpp>
namespace megu::kernel {
- class Tilemap : public Graphical<GraphicEngine>, public TileArray {
+ class Tilemap : public Graphical<GraphicEngine>, public megu::TileArray {
public:
struct TilePosition {
size_t x = 0;
diff --git a/source/kernel/front/component/physic/Fixed.cpp b/source/kernel/front/component/physic/Fixed.cpp
index a887afd090ad8f1f811536d509d7548a10a19dc4..1b0f4cadec4a523e8d6f42a4522ac3c16cf7ee5c 100644
--- a/source/kernel/front/component/physic/Fixed.cpp
+++ b/source/kernel/front/component/physic/Fixed.cpp
@@ -3,8 +3,8 @@
#include <kernel/front/Kernel.hpp>
namespace megu::kernel {
- Fixed::Fixed(float x, float y, float w, float h)
- : TangibleStatic(Position(x, y), Dimension(w, h, 0.f)) {}
+ Fixed::Fixed(float x, float y, float w, float h, CollideLambda cl, UpdateLambda ul)
+ : TangibleStatic(Position(x, y), Dimension(w, h, 0.f)), _collide(cl), _update(ul) {}
void Fixed::update_physic(double time) const {
if(this->_update != nullptr) {
diff --git a/source/kernel/front/component/physic/Fixed.hpp b/source/kernel/front/component/physic/Fixed.hpp
index 7ef7041dd979575d8785f9ded64c2258486f70eb..22fe2dd7c827a3861ecf8ea5148b2543651c5ae9 100644
--- a/source/kernel/front/component/physic/Fixed.hpp
+++ b/source/kernel/front/component/physic/Fixed.hpp
@@ -10,7 +10,7 @@
namespace megu::kernel {
class Fixed : public TangibleStatic, public Physical<PhysicEngine> {
public:
- Fixed(float x, float y, float w, float h);
+ Fixed(float x, float y, float w, float h, CollideLambda = nullptr, UpdateLambda = nullptr);
void update_physic(double) const override;
void on_collide(Kernel &, PhysicEngine &, Identifiable &, Physical &, double) override;
diff --git a/source/kernel/front/component/physic/FixedArray.cpp b/source/kernel/front/component/physic/FixedArray.cpp
deleted file mode 100644
index a0b61a78d87b2d8220e57b71e017bd8cebaf1129..0000000000000000000000000000000000000000
--- a/source/kernel/front/component/physic/FixedArray.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "FixedArray.hpp"
-
-#include <kernel/front/Kernel.hpp>
-
-namespace megu::kernel {
- std::optional<std::reference_wrapper<const TangibleStatic>> FixedArray::at(const Position & position) const {
- if(this->_tangibles.contains(position)) {
- return this->_tangibles.at(position);
- }
- return {};
- }
-
- void FixedArray::push(const Fixed & tangible) {
- this->_tangibles.insert({tangible.getPosition(), tangible});
- }
-
- void FixedArray::erase(const Fixed & tangible) {
- this->_tangibles.erase(tangible.getPosition());
- }
-
- void FixedArray::erase(const Position & position) {
- this->_tangibles.erase(position);
- }
-
- void FixedArray::on_collide(Kernel & kernel, PhysicEngine & engine, Identifiable & id, Physical & physical, double time) {
- auto & tangible = engine.get(physical);
- for(auto & [position, fixed] : this->_tangibles) {
- if(fixed.isColliding(tangible)) {
- physical.on_collide(kernel, engine, id, fixed, time);
- }
- }
- }
-
- void FixedArray::update_physic(double time) const {
- if(this->_update != nullptr) {
- this->_update(time);
- }
- }
-
- void FixedArray::apply(Kernel & kernel, PhysicEngine & engine) {
- engine.get().push(0, *this);
- }
-
- void FixedArray::unapply(Kernel & kernel, PhysicEngine & engine) {
- engine.get().remove(*this);
- }
-
- void FixedArray::setCollideLambda(CollideLambda lambda) {
- this->_collide = lambda;
- }
-
- void FixedArray::setUpdateLambda(UpdateLambda lambda) {
- this->_update = lambda;
- }
-}
\ No newline at end of file
diff --git a/source/kernel/front/component/physic/FixedArray.hpp b/source/kernel/front/component/physic/FixedArray.hpp
deleted file mode 100644
index 73f1dae84b17c81ad3502ca42f30a1ef4c8161da..0000000000000000000000000000000000000000
--- a/source/kernel/front/component/physic/FixedArray.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-
-#include <kernel/back/component/Physical.hpp>
-#include <kernel/back/engine/PhysicEngine.hpp>
-#include <vector>
-#include <functional>
-
-#include "Fixed.hpp"
-
-namespace megu::kernel {
- class FixedArray : public Physical<PhysicEngine>, public TangibleStatic {
- public:
- std::optional<std::reference_wrapper<const TangibleStatic>> at(const Position &) const;
-
- void push(const Fixed &);
- void erase(const Fixed &);
- void erase(const Position &);
-
- void setCollideLambda(CollideLambda);
- void setUpdateLambda(UpdateLambda);
-
- void update_physic(double) const override;
- void on_collide(Kernel &, PhysicEngine &, Identifiable &, Physical &, double) override;
- void apply(Kernel & k, PhysicEngine &) override;
- void unapply(Kernel & k, PhysicEngine &) override;
-
- private:
- std::map<Position, Fixed> _tangibles;
- CollideLambda _collide;
- UpdateLambda _update;
- };
-}
\ No newline at end of file
diff --git a/source/kernel/front/component/physic/Movable.cpp b/source/kernel/front/component/physic/Movable.cpp
index df0eef580b11262e8980a4dbaafe8a2bb19595d1..a48eae0092b1937e080581876bb29d095a1faced 100644
--- a/source/kernel/front/component/physic/Movable.cpp
+++ b/source/kernel/front/component/physic/Movable.cpp
@@ -1,8 +1,8 @@
#include "Movable.hpp"
namespace megu::kernel {
- Movable::Movable(float x, float y, float w, float h)
- : TangibleMovable(Position(x, y), Dimension(w, h, 0.f)) {}
+ Movable::Movable(float x, float y, float w, float h, CollideLambda cl, UpdateLambda ul)
+ : TangibleMovable(Position(x, y), Dimension(w, h, 0.f)), _collide(cl), _update(ul) {}
void Movable::update_physic(double time) {
if(this->_update != nullptr) {
diff --git a/source/kernel/front/component/physic/Movable.hpp b/source/kernel/front/component/physic/Movable.hpp
index bdb94e6deb1e6ab7e6efcb031757e84d4e164c24..45cd76036e0e8b49f33322e898cde4c51e0b5061 100644
--- a/source/kernel/front/component/physic/Movable.hpp
+++ b/source/kernel/front/component/physic/Movable.hpp
@@ -10,7 +10,7 @@
namespace megu::kernel {
class Movable : public TangibleMovable, public Physical<PhysicEngine> {
public:
- Movable(float x, float y, float w, float h);
+ Movable(float x, float y, float w, float h, CollideLambda = nullptr, UpdateLambda = nullptr);
void update_physic(double) override;
void on_collide(Kernel &, PhysicEngine &, Identifiable &, Physical &, double) override;
diff --git a/source/kernel/front/component/physic/Tile.cpp b/source/kernel/front/component/physic/Tile.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eafd5df0f733f3e601c00029beef051cba19a950
--- /dev/null
+++ b/source/kernel/front/component/physic/Tile.cpp
@@ -0,0 +1,26 @@
+#include "Tile.hpp"
+
+namespace megu::kernel {
+ Tile::Tile(float x, float y, float d)
+ : Fixed(x, y, d, d) {}
+
+ bool Tile::operator==(const Tile & tile) const {
+ return this->id() == tile.id();
+ }
+
+ bool Tile::operator>=(const Tile & tile) const {
+ return this->id() >= tile.id();
+ }
+
+ bool Tile::operator<=(const Tile & tile) const {
+ return this->id() <= tile.id();
+ }
+
+ bool Tile::operator>(const Tile & tile) const {
+ return this->id() > tile.id();
+ }
+
+ bool Tile::operator<(const Tile & tile) const {
+ return this->id() < tile.id();
+ }
+}
\ No newline at end of file
diff --git a/source/kernel/front/component/physic/Tile.hpp b/source/kernel/front/component/physic/Tile.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..112ac25c647e46aea37cadcaf5cd5e9177f7a831
--- /dev/null
+++ b/source/kernel/front/component/physic/Tile.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Fixed.hpp"
+
+namespace megu::kernel {
+ class Tile : public Fixed {
+ public:
+ Tile(float x, float y, float d);
+
+ bool operator==(const Tile &) const;
+ bool operator>=(const Tile &) const;
+ bool operator<=(const Tile &) const;
+ bool operator>(const Tile &) const;
+ bool operator<(const Tile &) const;
+ };
+}
\ No newline at end of file
diff --git a/source/kernel/front/component/physic/TileArray.cpp b/source/kernel/front/component/physic/TileArray.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4dd9bc5a2e7f68330b2ff2fdf2f4cbd1431c4cb7
--- /dev/null
+++ b/source/kernel/front/component/physic/TileArray.cpp
@@ -0,0 +1,69 @@
+#include "TileArray.hpp"
+
+#include <kernel/front/Kernel.hpp>
+
+namespace megu::kernel {
+ TileArray::TileArray(float x, float y, float w, float h, CollideLambda cl, UpdateLambda ul)
+ : TangibleStatic(Position(x, y), Dimension(w, h, 0.f)), _collide(cl), _update(ul) {}
+
+ std::optional<std::reference_wrapper<const Tile>> TileArray::at(const Position & position) const {
+ for(auto & [pos, tile] : this->_tiles) {
+ if(pos == position) {
+ return tile;
+ }
+ }
+
+ return std::optional<std::reference_wrapper<const Tile>>();
+ }
+
+ void TileArray::push(const Position & position, Tile & tile) {
+ this->_tiles.insert({position, tile});
+ }
+
+ void TileArray::erase(const Tile & tile) {
+ for(auto it = this->_tiles.begin(); it != this->_tiles.end();) {
+ if(it->second.get().id() == tile.id()) {
+ it = this->_tiles.erase(it);
+ }
+ else {
+ ++it;
+ }
+ }
+ }
+
+ void TileArray::on_collide(Kernel & kernel, PhysicEngine & engine, Identifiable & id, Physical & physical, double time) {
+ if(this->_collide == nullptr) {
+ return;
+ }
+
+ auto & tangible = engine.get(physical);
+ for(auto & [positon, tile] : this->_tiles) {
+ SquareBox box = SquareBox(positon, tile.get().getBox().dimension());
+ if(tangible.isColliding(box)) {
+ this->_collide(kernel, engine, id, tile, time);
+ }
+ }
+ }
+
+ void TileArray::update_physic(double time) const {
+ if(this->_update != nullptr) {
+ this->_update(time);
+ }
+ }
+
+ void TileArray::apply(Kernel & kernel, PhysicEngine & engine) {
+ engine.get().push(0, *this);
+ }
+
+ void TileArray::unapply(Kernel & kernel, PhysicEngine & engine) {
+ engine.get().remove(*this);
+ }
+
+ void TileArray::setCollideLambda(TileCollideLambda lambda) {
+ this->_collide = lambda;
+ }
+
+ void TileArray::setUpdateLambda(UpdateLambda lambda) {
+ this->_update = lambda;
+ }
+}
\ No newline at end of file
diff --git a/source/kernel/front/component/physic/TileArray.hpp b/source/kernel/front/component/physic/TileArray.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..a3ade2be082de59f2c3886c8b8d6b86245df4022
--- /dev/null
+++ b/source/kernel/front/component/physic/TileArray.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <kernel/back/component/Physical.hpp>
+#include <kernel/back/engine/PhysicEngine.hpp>
+#include <vector>
+#include <functional>
+
+#include "Tile.hpp"
+
+namespace megu::kernel {
+ class TileArray : public Physical<PhysicEngine>, public TangibleStatic {
+ public:
+ TileArray(float, float, float, float, CollideLambda = nullptr, UpdateLambda = nullptr);
+
+ std::optional<std::reference_wrapper<const Tile>> at(const Position &) const;
+
+ void push(const Position &, Tile &);
+ void erase(const Tile &);
+
+ using TileCollideLambda = std::function<void(Kernel &, PhysicEngine &, Identifiable &, Tile &, double)>;
+
+ void setCollideLambda(TileCollideLambda);
+ void setUpdateLambda(UpdateLambda);
+
+ void update_physic(double) const override;
+ void apply(Kernel & k, PhysicEngine &) override;
+ void unapply(Kernel & k, PhysicEngine &) override;
+ void on_collide(Kernel &, PhysicEngine &, Identifiable &, Physical &, double) override;
+
+ private:
+ std::map<Position, std::reference_wrapper<Tile>> _tiles;
+ TileCollideLambda _collide;
+ UpdateLambda _update;
+ };
+}
\ No newline at end of file
diff --git a/source/kernel/front/props/PropsTileMap.cpp b/source/kernel/front/props/PropsTileMap.cpp
index 8ec7d35254127f697d93d44211bf2406bee8f96d..b00c76e66ab487fc10415792d1c64c9e5504282e 100644
--- a/source/kernel/front/props/PropsTileMap.cpp
+++ b/source/kernel/front/props/PropsTileMap.cpp
@@ -1,7 +1,7 @@
#include "PropsTileMap.hpp"
namespace megu::kernel {
- PropsTileMap::PropsTileMap(Tilemap & tilemap, FixedArray & fixedarray)
+ PropsTileMap::PropsTileMap(Tilemap & tilemap, TileArray & fixedarray)
: _graphic(tilemap), _physic(fixedarray) {}
}
\ No newline at end of file
diff --git a/source/kernel/front/props/PropsTileMap.hpp b/source/kernel/front/props/PropsTileMap.hpp
index eee3f716a81f363364e8c6981a3001f67522090d..993e9b52d90dcba507bae111ea76f52044c8c2f0 100644
--- a/source/kernel/front/props/PropsTileMap.hpp
+++ b/source/kernel/front/props/PropsTileMap.hpp
@@ -2,18 +2,18 @@
#include <kernel/front/props/Props.hpp>
#include <kernel/front/component/graphic/TileMap.hpp>
-#include <kernel/front/component/physic/FixedArray.hpp>
+#include <kernel/front/component/physic/TileArray.hpp>
namespace megu::kernel {
class PropsTileMap : public Prop {
public:
- PropsTileMap(Tilemap &, FixedArray &);
+ PropsTileMap(Tilemap &, TileArray &);
inline Prop::Graphical_Component * getGraphicComponent() override {return &this->_graphic;}
inline Prop::Physical_Component * getPhysicComponent() override {return &this->_physic;}
private:
Tilemap & _graphic;
- FixedArray & _physic;
+ kernel::TileArray & _physic;
};
}
\ No newline at end of file