Merge branch 'develop' into bomb_animator

CMakeLists.txt

@@ -95,15 +95,15 @@ target_link_libraries(bomberman PUBLIC wal ray)
 
 
 add_executable(unit_tests EXCLUDE_FROM_ALL
-	${SOURCES}
-	tests/EntityTests.cpp
-	tests/MainTest.cpp
-	tests/EngineTests.cpp
-	tests/CallbackTest.cpp
-	tests/MoveTests.cpp
-	tests/ViewTest.cpp
-	tests/CollisionTest.cpp
-)
+               ${SOURCES}
+               tests/EntityTests.cpp
+               tests/MainTest.cpp
+               tests/EngineTests.cpp
+               tests/CallbackTest.cpp
+               tests/MoveTests.cpp
+               tests/ViewTest.cpp
+               tests/CollisionTest.cpp
+               )
 target_include_directories(unit_tests PUBLIC sources)
 target_link_libraries(unit_tests PUBLIC wal ray)
 

lib/Ray/sources/Controllers/Gamepad.cpp

@@ -42,3 +42,8 @@ void RAY::Controller::GamePad::setID(int id)
 {
 	this->_id = id;
 }
+
+float RAY::Controller::GamePad::getAxisValue(int index)
+{
+	return GetGamepadAxisMovement(this->_id, index);
+}

lib/Ray/sources/Controllers/Gamepad.hpp

@@ -17,6 +17,7 @@ namespace RAY::Controller {
 	class GamePad {
 		public:
 			typedef ::GamepadButton Button;
+			typedef ::GamepadAxis Axis;
 
 			//! @brief A default constructor
 			//! @param The id of the controller 
@@ -44,6 +45,9 @@ namespace RAY::Controller {
 			//! @param Button The keycode of the button
 			bool isReleased(Button);
 
+			//! @brief Get the value of an axis
+			float getAxisValue(int index);
+
 			//! @brief Returns true if Button is up on the gamepad
 			//! @param Button The keycode of the button
 			bool isUp(Button);

sources/Component/Collision/CollisionComponent.cpp

@@ -4,31 +4,54 @@
 
 #include "Component/Collision/CollisionComponent.hpp"
 
-
-namespace BBM 
+namespace BBM
 {
 	CollisionComponent::CollisionComponent(WAL::Entity &entity)
-	: WAL::Component(entity)
-	{ }
+		: WAL::Component(entity)
+	{}
 
 	WAL::Component *CollisionComponent::clone(WAL::Entity &entity) const
 	{
 		return new CollisionComponent(entity);
 	}
 
-	CollisionComponent::CollisionComponent(WAL::Entity &entity, WAL::Callback<WAL::Entity &, const WAL::Entity &> onCollide, WAL::Callback<WAL::Entity &, const WAL::Entity &> onCollided, Vector3f bound)
-	: WAL::Component(entity), onCollide(onCollide), onCollided(onCollided), bound(bound)
-	{ }
+	CollisionComponent::CollisionComponent(WAL::Entity &entity,
+	                                       const WAL::Callback<WAL::Entity &, const WAL::Entity &, CollidedAxis> &onCollide,
+	                                       const WAL::Callback<WAL::Entity &, const WAL::Entity &, CollidedAxis> &onCollided,
+	                                       Vector3f positionOffset,
+	                                       Vector3f bound)
+		: WAL::Component(entity),
+		onCollide(onCollide),
+		onCollided(onCollided),
+		bound(bound),
+		positionOffset(positionOffset)
+	{}
 
-	CollisionComponent::CollisionComponent(WAL::Entity &entity, WAL::Callback<WAL::Entity &, const WAL::Entity &> onCollide, WAL::Callback<WAL::Entity &, const WAL::Entity &> onCollided, float boundSize)
-	: WAL::Component(entity), onCollide(onCollide), onCollided(onCollided), bound({boundSize, boundSize, boundSize})
-	{ }
+	CollisionComponent::CollisionComponent(WAL::Entity &entity,
+	                                       const WAL::Callback<WAL::Entity &, const WAL::Entity &, CollidedAxis> &onCollide,
+	                                       const WAL::Callback<WAL::Entity &, const WAL::Entity &, CollidedAxis> &onCollided,
+	                                       float positionOffset,
+	                                       float boundSize)
+		: WAL::Component(entity),
+		onCollide(onCollide),
+		onCollided(onCollided),
+		bound({boundSize, boundSize, boundSize}),
+		positionOffset({positionOffset, positionOffset, positionOffset})
+	{}
 
-	CollisionComponent::CollisionComponent(WAL::Entity &entity, Vector3f bound)
-	: WAL::Component(entity), onCollide(), onCollided(), bound(bound)
-	{ }
+	CollisionComponent::CollisionComponent(WAL::Entity &entity, Vector3f positionOffset, Vector3f bound)
+		: WAL::Component(entity),
+		onCollide(),
+		onCollided(),
+		bound(bound),
+		positionOffset(positionOffset)
+	{}
 
-	CollisionComponent::CollisionComponent(WAL::Entity &entity, float boundSize)
-	: WAL::Component(entity), onCollide(), onCollided(), bound({boundSize, boundSize, boundSize})
-	{ }
+	CollisionComponent::CollisionComponent(WAL::Entity &entity, float positionOffset, float boundSize)
+		: WAL::Component(entity),
+		onCollide(),
+		onCollided(),
+		bound({boundSize, boundSize, boundSize}),
+		positionOffset({positionOffset, positionOffset, positionOffset})
+	{}
 }

sources/Component/Collision/CollisionComponent.hpp

@@ -9,43 +9,61 @@
 #include "Component/Component.hpp"
 #include "Entity/Entity.hpp"
 
-namespace BBM 
+namespace BBM
 {
 	class CollisionComponent : public WAL::Component
 	{
-		private:
-		public:
-			//! @brief onCollide functions to be called
-			WAL::Callback<WAL::Entity &, const WAL::Entity &> onCollide;
-			//! @brief onCollided functions to be called
-			WAL::Callback<WAL::Entity &, const WAL::Entity &> onCollided;
-			//! @brief Bound size on all axis
-			Vector3f bound;
-			//! @inherit
-			WAL::Component *clone(WAL::Entity &entity) const override;
+	public:
+		//! @brief Used to tell the collided axis
+		//! @note Usage: (collidedAxis (int given by callback)) & CollidedAxis::X
+		enum CollidedAxis {
+			X = 1,
+			Y = 2,
+			Z = 4
+		};
 
-			//! @brief A component can't be instantiated, it should be derived.
-			explicit CollisionComponent(WAL::Entity &entity);
+		//! @brief onCollide functions to be called
+		WAL::Callback<WAL::Entity &, const WAL::Entity &, CollidedAxis> onCollide;
+		//! @brief onCollided functions to be called
+		WAL::Callback<WAL::Entity &, const WAL::Entity &, CollidedAxis> onCollided;
+		//! @brief Bound size on all axis
+		Vector3f bound;
+		//! @brief Offset from the position component
+		Vector3f positionOffset;
 
-			//! @brief Constructor with a WAL::Callback
-			CollisionComponent(WAL::Entity &entity, WAL::Callback<WAL::Entity &, const WAL::Entity &> onCollide, WAL::Callback<WAL::Entity &, const WAL::Entity &> onCollided,Vector3f bound);
+		//! @inherit
+		WAL::Component *clone(WAL::Entity &entity) const override;
 
-			//! @brief Constructor with a WAL::Callback, same boundSize for all axis
-			CollisionComponent(WAL::Entity &entity, WAL::Callback<WAL::Entity &, const WAL::Entity &> onCollide, WAL::Callback<WAL::Entity &, const WAL::Entity &> onCollided, float boundSize = 0);
+		//! @brief A component can't be instantiated, it should be derived.
+		explicit CollisionComponent(WAL::Entity &entity);
 
-			//! @brief Constructor of collider with no callback
-			CollisionComponent(WAL::Entity &entity, Vector3f bound);
+		//! @brief Constructor with a WAL::Callback
+		CollisionComponent(WAL::Entity &entity,
+		                   const WAL::Callback<WAL::Entity &, const WAL::Entity &, CollidedAxis> &onCollide,
+		                   const WAL::Callback<WAL::Entity &, const WAL::Entity &, CollidedAxis> &onCollided,
+		                   Vector3f positionOffset,
+		                   Vector3f bound);
 
-			//! @brief Constructor no callback, same boundSize for all axis
-			CollisionComponent(WAL::Entity &entity, float boundSize);
+		//! @brief Constructor with a WAL::Callback, same boundSize for all axis
+		CollisionComponent(WAL::Entity &entity,
+		                   const WAL::Callback<WAL::Entity &, const WAL::Entity &, CollidedAxis> &onCollide,
+		                   const WAL::Callback<WAL::Entity &, const WAL::Entity &, CollidedAxis> &onCollided,
+		                   float positionOffset,
+		                   float boundSize);
 
-			//! @brief Default copy constructor
-			CollisionComponent(const CollisionComponent &) = default;
+		//! @brief Constructor of collider with no callback
+		CollisionComponent(WAL::Entity &entity, Vector3f positionOffset, Vector3f bound);
 
-			//! @brief default destructor
-			~CollisionComponent() override = default;
+		//! @brief Constructor no callback, same boundSize & positionOffset for all axis
+		CollisionComponent(WAL::Entity &entity, float positionOffset, float boundSize);
 
-			//! @brief A component can't be assigned
-			CollisionComponent &operator=(const CollisionComponent &) = delete;
+		//! @brief Default copy constructor
+		CollisionComponent(const CollisionComponent &) = default;
+
+		//! @brief default destructor
+		~CollisionComponent() override = default;
+
+		//! @brief A component can't be assigned
+		CollisionComponent &operator=(const CollisionComponent &) = delete;
 	};
 }

sources/Component/Gamepad/GamepadComponent.hpp

@@ -10,6 +10,7 @@
 #include "Entity/Entity.hpp"
 
 using Button = RAY::Controller::GamePad::Button;
+using Axis = RAY::Controller::GamePad::Axis;
 using Gamepad = RAY::Controller::GamePad;
 
 namespace BBM
@@ -35,6 +36,11 @@ namespace BBM
 			//! @brief move down key
 			Button keyDown = GAMEPAD_BUTTON_LEFT_FACE_DOWN;
 
+			Axis LeftStickX = GAMEPAD_AXIS_LEFT_X;
+			Axis LeftStickY = GAMEPAD_AXIS_LEFT_Y;
+			Axis RightStickX = GAMEPAD_AXIS_RIGHT_X;
+			Axis RightStickY = GAMEPAD_AXIS_RIGHT_Y;
+
 			//! @inherit
 			WAL::Component *clone(WAL::Entity &entity) const override;
 

sources/Component/Keyboard/KeyboardComponent.hpp

@@ -23,9 +23,9 @@ namespace BBM
 			//! @brief pause key
 			Key keyPause = KEY_ESCAPE;
 			//! @brief move right key
-			Key keyRight = KEY_A;
+			Key keyRight = KEY_D;
 			//! @brief move left key
-			Key keyLeft = KEY_D;
+			Key keyLeft = KEY_A;
 			//! @brief move up key
 			Key keyUp = KEY_W;
 			//! @brief move down key

sources/Map/Map.cpp

@@ -3,7 +3,8 @@
 // Edited by Benjamin Henry on 5/26/21.
 //
 
-#include <Component/Collision/CollisionComponent.hpp>
+#include "Component/Collision/CollisionComponent.hpp"
+#include "System/Collision/CollisionSystem.hpp"
 #include "Map.hpp"
 #include <iostream>
 
@@ -11,23 +12,20 @@ namespace RAY3D = RAY::Drawables::Drawables3D;
 
 namespace BBM
 {
-	void MapGenerator::wallCollide(WAL::Entity &entity, const WAL::Entity &wall)
+	void MapGenerator::wallCollide(WAL::Entity &entity,
+	                               const WAL::Entity &wall,
+	                               CollisionComponent::CollidedAxis collidedAxis)
 	{
 		auto *mov = entity.tryGetComponent<MovableComponent>();
+
 		if (!mov)
 			return;
-		auto &pos = entity.getComponent<PositionComponent>();
-		const auto &wallPos = wall.getComponent<PositionComponent>();
-		auto diff = pos.position + mov->getVelocity() - wallPos.position;
-//		mov->_velocity = Vector3f();
-//		if (diff.x <= 0 && mov->_velocity.x < 0)
-//			mov->_velocity.x = 0;
-//		if (diff.x >= 0 && mov->_velocity.x > 0)
-//			mov->_velocity.x = 0;
-//		if (diff.z <= 0 && mov->_velocity.z < 0)
-//			mov->_velocity.z = 0;
-//		if (diff.z >= 0 && mov->_velocity.z > 0)
-//			mov->_velocity.z = 0;
+		if (collidedAxis & CollisionComponent::CollidedAxis::X)
+			mov->_velocity.x = 0;
+		if (collidedAxis & CollisionComponent::CollidedAxis::Y)
+			mov->_velocity.x = 0;
+		if (collidedAxis & CollisionComponent::CollidedAxis::Z)
+			mov->_velocity.z = 0;
 	}
 
 	void MapGenerator::wallDestroyed(WAL::Entity &entity)
@@ -58,8 +56,11 @@ namespace BBM
 				if (!(i % 2) && !(j % 2)) {
 					scene->addEntity("Unbreakable Wall")
 						.addComponent<PositionComponent>(i, 0, j)
-						.addComponent<CollisionComponent>(WAL::Callback<WAL::Entity &, const WAL::Entity &>(), &MapGenerator::wallCollide, .75)
-						.addComponent<Drawable3DComponent, RAY3D::Model>(unbreakableObj, std::make_pair(MAP_DIFFUSE, unbreakablePng));
+						.addComponent<CollisionComponent>(
+							WAL::Callback<WAL::Entity &, const WAL::Entity &, CollisionComponent::CollidedAxis>(),
+							&MapGenerator::wallCollide, 0.25, .75)
+						.addComponent<Drawable3DComponent, RAY3D::Model>(unbreakableObj,
+						                                                 std::make_pair(MAP_DIFFUSE, unbreakablePng));
 				}
 			}
 		}
@@ -72,25 +73,33 @@ namespace BBM
 
 		scene->addEntity("Bottom Wall")
 			.addComponent<PositionComponent>(Vector3f((width + 1) / 2, 0, -1))
-			.addComponent<CollisionComponent>(WAL::Callback<WAL::Entity &, const WAL::Entity &>(), &MapGenerator::wallCollide, .75)
+			.addComponent<CollisionComponent>(
+				WAL::Callback<WAL::Entity &, const WAL::Entity &, CollisionComponent::CollidedAxis>(),
+				&MapGenerator::wallCollide, 0.25, .75)
 			.addComponent<Drawable3DComponent, RAY3D::Model>(unbreakableObj,
 			                                                 std::make_pair(MAP_DIFFUSE, unbreakablePnj),
 			                                                 RAY::Vector3(width + 3, 1, 1));
 		scene->addEntity("Upper Wall")
 			.addComponent<PositionComponent>(Vector3f((width + 1) / 2, 0, height + 1))
-			.addComponent<CollisionComponent>(WAL::Callback<WAL::Entity &, const WAL::Entity &>(), &MapGenerator::wallCollide, .75)
+			.addComponent<CollisionComponent>(
+				WAL::Callback<WAL::Entity &, const WAL::Entity &, CollisionComponent::CollidedAxis>(),
+				&MapGenerator::wallCollide, 0.25, .75)
 			.addComponent<Drawable3DComponent, RAY3D::Model>(unbreakableObj,
 			                                                 std::make_pair(MAP_DIFFUSE, unbreakablePnj),
 			                                                 RAY::Vector3(width + 3, 1, 1));
 		scene->addEntity("Left Wall")
 			.addComponent<PositionComponent>(Vector3f(width + 1, 0, height / 2))
-			.addComponent<CollisionComponent>(WAL::Callback<WAL::Entity &, const WAL::Entity &>(), &MapGenerator::wallCollide, .75)
+			.addComponent<CollisionComponent>(
+				WAL::Callback<WAL::Entity &, const WAL::Entity &, CollisionComponent::CollidedAxis>(),
+				&MapGenerator::wallCollide, 0.25, .75)
 			.addComponent<Drawable3DComponent, RAY3D::Model>(unbreakableObj,
 			                                                 std::make_pair(MAP_DIFFUSE, unbreakablePnj),
 			                                                 RAY::Vector3(1, 1, height + 1));
 		scene->addEntity("Right Wall")
 			.addComponent<PositionComponent>(Vector3f(-1, 0, height / 2))
-			.addComponent<CollisionComponent>(WAL::Callback<WAL::Entity &, const WAL::Entity &>(), &MapGenerator::wallCollide, .75)
+			.addComponent<CollisionComponent>(
+				WAL::Callback<WAL::Entity &, const WAL::Entity &, CollisionComponent::CollidedAxis>(),
+				&MapGenerator::wallCollide, 0.25, .75)
 			.addComponent<Drawable3DComponent, RAY3D::Model>(unbreakableObj,
 			                                                 std::make_pair(MAP_DIFFUSE, unbreakablePnj),
 			                                                 RAY::Vector3(1, 1, height + 1));
@@ -106,7 +115,7 @@ namespace BBM
 				if (map[std::make_tuple(i, 0, j)] != HOLE && map[std::make_tuple(i, -1, j)] != BUMPER)
 					scene->addEntity("Unbreakable Wall")
 						.addComponent<PositionComponent>(Vector3f(i, -1, j))
-							.addComponent<Drawable3DComponent, RAY3D::Model>(floorObj,
+						.addComponent<Drawable3DComponent, RAY3D::Model>(floorObj,
 						                                                 std::make_pair(MAP_DIFFUSE, floorPng));
 			}
 		}
@@ -140,7 +149,9 @@ namespace BBM
 		scene->addEntity("Breakable Block")
 			.addComponent<PositionComponent>(coords)
 			.addComponent<HealthComponent>(1, &MapGenerator::wallDestroyed)
-			.addComponent<CollisionComponent>(WAL::Callback<WAL::Entity &, const WAL::Entity &>(), &MapGenerator::wallCollide, .75)
+			.addComponent<CollisionComponent>(
+				WAL::Callback<WAL::Entity &, const WAL::Entity &, CollisionComponent::CollidedAxis>(),
+				&MapGenerator::wallCollide, 0.25, .75)
 			.addComponent<Drawable3DComponent, RAY3D::Model>(breakableObj, std::make_pair(MAP_DIFFUSE, breakablePng));
 	}
 
@@ -173,7 +184,9 @@ namespace BBM
 
 		scene->addEntity("Unbreakable Block")
 			.addComponent<PositionComponent>(coords)
-			.addComponent<CollisionComponent>(WAL::Callback<WAL::Entity &, const WAL::Entity &>(), &MapGenerator::wallCollide, .75)
+			.addComponent<CollisionComponent>(
+				WAL::Callback<WAL::Entity &, const WAL::Entity &, CollisionComponent::CollidedAxis>(),
+				&MapGenerator::wallCollide, 0.25, .75)
 			.addComponent<Drawable3DComponent, RAY3D::Model>(UnbreakableObj,
 			                                                 std::make_pair(MAP_DIFFUSE, UnbreakablePng));
 	}
@@ -192,7 +205,8 @@ namespace BBM
 		if (coords.y == 0)
 			holeEntity.addComponent<Drawable3DComponent, RAY3D::Model>(holeObj, std::make_pair(MAP_DIFFUSE, holePng));
 		else
-			holeEntity.addComponent<Drawable3DComponent, RAY3D::Model>(secondFloorObj, std::make_pair(MAP_DIFFUSE, secondFloorPng));
+			holeEntity.addComponent<Drawable3DComponent, RAY3D::Model>(secondFloorObj,
+			                                                           std::make_pair(MAP_DIFFUSE, secondFloorPng));
 		/*.addComponent<CollisionComponent>([](WAL::Entity &other, const WAL::Entity &entity) {
 			if (other.hasComponent<HealthComponent>()) {
 				auto &health = other.getComponent<HealthComponent>();
@@ -337,7 +351,7 @@ namespace BBM
 		return (map);
 	}
 
-	void MapGenerator::loadMap(int width, int height, MapBlock map, std::shared_ptr<WAL::Scene> scene)
+	void MapGenerator::loadMap(int width, int height, MapBlock map, const std::shared_ptr<WAL::Scene> &scene)
 	{
 		generateWall(width, height, scene);
 		generateFloor(map, width, height, scene);

sources/Map/Map.hpp

@@ -27,150 +27,155 @@ namespace BBM
 
 	class MapGenerator
 	{
-		private:
-			//! @brief Enum of the block available.
-			enum BlockType {
-				NOTHING,
-				BREAKABLE,
-				HOLE,
-				UPPERFLOOR,
-				FLOOR,
-				BUMPER,
-				STAIRS,
-				SPAWNER,
-				UNBREAKABLE
-			};
+	private:
+		//! @brief Enum of the block available.
+		enum BlockType
+		{
+			NOTHING,
+			BREAKABLE,
+			HOLE,
+			UPPERFLOOR,
+			FLOOR,
+			BUMPER,
+			STAIRS,
+			SPAWNER,
+			UNBREAKABLE
+		};
 
-			using MapElem = std::function<void (Vector3f coords, std::shared_ptr<WAL::Scene> scene)>;
-			using MapBlock = std::map<std::tuple<int, int, int>, BlockType>;
+		using MapElem = std::function<void(Vector3f coords, std::shared_ptr<WAL::Scene> scene)>;
+		using MapBlock = std::map<std::tuple<int, int, int>, BlockType>;
 
-			//! @brief Generate random block type
-			static BlockType getRandomBlockType();
+		//! @brief Generate random block type
+		static BlockType getRandomBlockType();
 
-			//! @param map ASCII map
-			//! @param x x index on the block
-			//! @param z z index on the block
-			//! @param blockType blockType to compare with position
-			static bool isCloseToBlockType(std::map<std::tuple<int, int, int>, BlockType> map, int x, int y, int z, BlockType blockType);
+		//! @param map ASCII map
+		//! @param x x index on the block
+		//! @param z z index on the block
+		//! @param blockType blockType to compare with position
+		static bool isCloseToBlockType(std::map<std::tuple<int, int, int>, BlockType> map,
+		                               int x, int y, int z,
+		                               BlockType blockType);
 
-			//! @param width Width of the map
-			//! @param height Height of the map
-			//! @param scene Scene where the map is instanced
-			//! @brief Generate the unbreakable block of the map
-			static void generateUnbreakableBlock(int width, int height, std::shared_ptr<WAL::Scene> scene);
+		//! @param width Width of the map
+		//! @param height Height of the map
+		//! @param scene Scene where the map is instanced
+		//! @brief Generate the unbreakable block of the map
+		static void generateUnbreakableBlock(int width, int height, std::shared_ptr<WAL::Scene> scene);
 
-			//! @param width Width of the map
-			//! @param height Height of the map
-			//! @param scene Scene where the map is instanced
-			//! @brief Generate the wall of the map
-			static void generateWall(int width, int height, std::shared_ptr<WAL::Scene> scene);
+		//! @param width Width of the map
+		//! @param height Height of the map
+		//! @param scene Scene where the map is instanced
+		//! @brief Generate the wall of the map
+		static void generateWall(int width, int height, std::shared_ptr<WAL::Scene> scene);
 
-			//! @param width Width of the map
-			//! @param height Height of the map
-			//! @param scene Scene where the map is instanced
-			//! @brief Generate the floor of the map
-			static void generateFloor(MapBlock map, int width, int height, std::shared_ptr<WAL::Scene> scene);
+		//! @param width Width of the map
+		//! @param height Height of the map
+		//! @param scene Scene where the map is instanced
+		//! @brief Generate the floor of the map
+		static void generateFloor(MapBlock map, int width, int height, std::shared_ptr<WAL::Scene> scene);
 
-			//! @param coords coords of the element
-			//! @param scene Scene where the map is instanced
-			//! @brief Create element of the map
-			static void createElement(Vector3f coords, std::shared_ptr<WAL::Scene> scene, BlockType blockType);
+		//! @param coords coords of the element
+		//! @param scene Scene where the map is instanced
+		//! @brief Create element of the map
+		static void createElement(Vector3f coords, std::shared_ptr<WAL::Scene> scene, BlockType blockType);
 
-			//! @param coords coords of the element
-			//! @param scene Scene where the map is instanced
-			//! @brief Create breakable of the map
-			static void createBreakable(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
+		//! @param coords coords of the element
+		//! @param scene Scene where the map is instanced
+		//! @brief Create breakable of the map
+		static void createBreakable(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
 
-			//! @param coords coords of the element
-			//! @param scene Scene where the map is instanced
-			//! @brief Create unbreakable of the map
-			static void createUnbreakable(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
+		//! @param coords coords of the element
+		//! @param scene Scene where the map is instanced
+		//! @brief Create unbreakable of the map
+		static void createUnbreakable(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
 
-			//! @param coords coords of the element
-			//! @param scene Scene where the map is instanced
-			//! @brief Create hole of the map
-			static void createHole(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
+		//! @param coords coords of the element
+		//! @param scene Scene where the map is instanced
+		//! @brief Create hole of the map
+		static void createHole(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
 
-			//! @param coords coords of the element
-			//! @param scene Scene where the map is instanced
-			//! @brief Create bumper of the map
-			static void createBumper(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
+		//! @param coords coords of the element
+		//! @param scene Scene where the map is instanced
+		//! @brief Create bumper of the map
+		static void createBumper(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
 
-			//! @param coords coords of the element
-			//! @param scene Scene where the map is instanced
-			//! @brief Create floor of the map
-			static void createFloor(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
+		//! @param coords coords of the element
+		//! @param scene Scene where the map is instanced
+		//! @brief Create floor of the map
+		static void createFloor(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
 
-			//! @param coords coords of the element
-			//! @param scene Scene where the map is instanced
-			//! @brief Create upper floor of the map
-			static void createUpperFloor(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
+		//! @param coords coords of the element
+		//! @param scene Scene where the map is instanced
+		//! @brief Create upper floor of the map
+		static void createUpperFloor(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
 
 
-			//! @param coords coords of the element
-			//! @param scene Scene where the map is instanced
-			//! @brief Create stair of the map
-			static void createStairs(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
-			
-			//! @param map Map to load with block declared inside
-			//! @param width Width of the map
-			//! @param height Height of the map
-			//! @brief Generate map of block to be loaded
-			static MapBlock createSpawner(MapBlock map, int width, int height);
+		//! @param coords coords of the element
+		//! @param scene Scene where the map is instanced
+		//! @brief Create stair of the map
+		static void createStairs(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
 
-			//! @param map Map to load with block declared inside
-			//! @param width Width of the map
-			//! @param height Height of the map
-			//! @brief Generate height for the map
-			static MapBlock createHeight(MapBlock map, int width, int height);
+		//! @param map Map to load with block declared inside
+		//! @param width Width of the map
+		//! @param height Height of the map
+		//! @brief Generate map of block to be loaded
+		static MapBlock createSpawner(MapBlock map, int width, int height);
 
-			//! @param map Map to load with block declared inside
-			//! @param width Width of the map
-			//! @param height Height of the map
-			//! @brief Clean breakable on stairs, bumpers, etc..
-			static MapBlock cleanBreakable(MapBlock map, int width, int height);
+		//! @param map Map to load with block declared inside
+		//! @param width Width of the map
+		//! @param height Height of the map
+		//! @brief Generate height for the map
+		static MapBlock createHeight(MapBlock map, int width, int height);
 
-			
-			static const std::string assetsPath;
-
-			static const std::string wallAssetsPath;
-
-			static const std::string imageExtension;
-
-			static const std::string objExtension;
-
-			static const std::string unbreakableWallPath;
-
-			static const std::string breakableWallPath;
-
-			static const std::string floorPath;
-
-			static const std::string stairsPath;
-
-			static const std::string bumperPath;
-
-			static const std::string secondFloorPath;
-
-			static const std::string holePath;
-
-			static const std::string secondFloorHolePath;
-
-		public:
-			static void wallCollide(WAL::Entity &entity, const WAL::Entity &wall);
-			static void wallDestroyed(WAL::Entity &entity);
+		//! @param map Map to load with block declared inside
+		//! @param width Width of the map
+		//! @param height Height of the map
+		//! @brief Clean breakable on stairs, bumpers, etc..
+		static MapBlock cleanBreakable(MapBlock map, int width, int height);
 
 
-			//! @param width Width of the map
-			//! @param height Height of the map
-			//! @brief Generate map of block to be loaded
-			static MapBlock createMap(int width, int height);
+		static const std::string assetsPath;
+
+		static const std::string wallAssetsPath;
+
+		static const std::string imageExtension;
+
+		static const std::string objExtension;
+
+		static const std::string unbreakableWallPath;
+
+		static const std::string breakableWallPath;
+
+		static const std::string floorPath;
+
+		static const std::string stairsPath;
+
+		static const std::string bumperPath;
+
+		static const std::string secondFloorPath;
+
+		static const std::string holePath;
+
+		static const std::string secondFloorHolePath;
+
+	public:
+		static void wallCollide(WAL::Entity &entity,
+		                        const WAL::Entity &wall,
+		                        CollisionComponent::CollidedAxis collidedAxis);
+		static void wallDestroyed(WAL::Entity &entity);
+
+
+		//! @param width Width of the map
+		//! @param height Height of the map
+		//! @brief Generate map of block to be loaded
+		static MapBlock createMap(int width, int height);
+
+		//! @param width Width of the map
+		//! @param height Height of the map
+		//! @param map Map to load with block declared inside
+		//! @param scene Scene where the map is instanced
+		//! @brief Generate the map
+		static void loadMap(int width, int height, MapBlock map, const std::shared_ptr<WAL::Scene> &scene);
 
-			//! @param width Width of the map
-			//! @param height Height of the map
-			//! @param map Map to load with block declared inside
-			//! @param scene Scene where the map is instanced
-			//! @brief Generate the map
-			static void loadMap(int width, int height, MapBlock map, std::shared_ptr<WAL::Scene> scene);
-			
 	};
 } // namespace BBM

sources/Runner/Runner.cpp

@@ -79,8 +79,9 @@ namespace BBM
 			.addComponent<ControllableComponent>()
 			.addComponent<AnimatorComponent>()
 			.addComponent<KeyboardComponent>()
+			//.addComponent<GamepadComponent>(0)
 			.addComponent<AnimationsComponent>(RAY::ModelAnimations("assets/player/player.iqm"), 3)
-			.addComponent<CollisionComponent>(1)
+			.addComponent<CollisionComponent>(BBM::Vector3f{0.25, 0, 0.25}, BBM::Vector3f{.75, 2, .75})
 			.addComponent<MovableComponent>()
 			.addComponent<BombHolderComponent>()
 			.addComponent<HealthComponent>(1, [](WAL::Entity &entity) {
@@ -90,14 +91,15 @@ namespace BBM
 		scene->addEntity("camera")
 			.addComponent<PositionComponent>(8, 20, 7)
 			.addComponent<CameraComponent>(Vector3f(8, 0, 8));
-//		scene->addEntity("cube")
-//			.addComponent<PositionComponent>(5, 0, 5)
-//			.addComponent<Drawable3DComponent, RAY3D::Cube>(Vector3f(-5, 0, -5), Vector3f(3, 3, 3), RED)
-//			.addComponent<ControllableComponent>()
-//			.addComponent<KeyboardComponent>()
-//			.addComponent<CollisionComponent>(WAL::Callback<WAL::Entity &, const WAL::Entity &>(), &MapGenerator::wallCollide, 3);
+		/*scene->addEntity("cube")
+			.addComponent<PositionComponent>(-5, 0, -5)
+			.addComponent<Drawable3DComponent, RAY3D::Cube>(Vector3f(0, 0, 0), Vector3f(3, 3, 3), RED)
+			.addComponent<ControllableComponent>()
+			.addComponent<KeyboardComponent>()
+			.addComponent<CollisionComponent>(WAL::Callback<WAL::Entity &, const WAL::Entity &, int>(), &MapGenerator::wallCollide, -1, 3);*/
 		std::srand(std::time(nullptr));
 		MapGenerator::loadMap(16, 16, MapGenerator::createMap(16, 16), scene);
+
 		return scene;
 	}
 

sources/System/Collision/CollisionSystem.cpp

@@ -14,7 +14,7 @@ namespace BBM
 		: System(wal)
 	{ }
 
-	bool CollisionSystem::collide(Vector3f minA, Vector3f maxA, Vector3f minB, Vector3f maxB)
+	bool CollisionSystem::boxesCollide(Vector3f minA, Vector3f maxA, Vector3f minB, Vector3f maxB)
 	{
 		bool overlapX = (minA.x <= maxB.x && maxA.x >= minB.x) || (minB.x <= maxA.x && maxB.x >= minA.x);
 		bool overlapY = (minA.y <= maxB.y && maxA.y >= minB.y) || (minB.y <= maxA.y && maxB.y >= minA.y);
@@ -26,20 +26,51 @@ namespace BBM
 	void CollisionSystem::onFixedUpdate(WAL::ViewEntity<PositionComponent, CollisionComponent> &entity)
 	{
 		auto &posA = entity.get<PositionComponent>();
-		auto &col = entity.get<CollisionComponent>();
-		Vector3f position = posA.position;
-		if (auto *movable = entity->tryGetComponent<MovableComponent>())
-			position += movable->getVelocity();
-		Vector3f minA = Vector3f::min(position, position + col.bound);
-		Vector3f maxA = Vector3f::max(position, position + col.bound);
+		auto &colA = entity.get<CollisionComponent>();
+		Vector3f pointA = posA.position + colA.positionOffset;
+		Vector3f pointAx = pointA;
+		Vector3f pointAy = pointA;
+		Vector3f pointAz = pointA;
+
+		if (auto *movable = entity->tryGetComponent<MovableComponent>()) {
+			auto vel = movable->getVelocity();
+			pointAx.x += vel.x;
+			pointAy.y += vel.y;
+			pointAz.z += vel.z;
+		}
+
+		Vector3f minAx = Vector3f::min(pointAx, pointAx + colA.bound);
+		Vector3f maxAx = Vector3f::max(pointAx, pointAx + colA.bound);
+
+		Vector3f minAy = Vector3f::min(pointAy, pointAy + colA.bound);
+		Vector3f maxAy = Vector3f::max(pointAy, pointAy + colA.bound);
+
+		Vector3f minAz = Vector3f::min(pointAz, pointAz + colA.bound);
+		Vector3f maxAz = Vector3f::max(pointAz, pointAz + colA.bound);
+
 		for (auto &[other, posB, colB] : this->getView()) {
 			if (other.getUid() == entity->getUid())
 				continue;
-			Vector3f minB = Vector3f::min(posB.position, posB.position + colB.bound);
-			Vector3f maxB = Vector3f::max(posB.position, posB.position + colB.bound);
-			if (collide(minA, maxA, minB, maxB)) {
-				col.onCollide(entity, other);
-				colB.onCollided(entity, other);
+
+			auto pointB = posB.position + colB.positionOffset;
+			int collidedAxis = 0;
+
+			// TODO if B is also a movable we don't check with it's changing position
+			Vector3f minB = Vector3f::min(pointB, pointB + colB.bound);
+			Vector3f maxB = Vector3f::max(pointB, pointB + colB.bound);
+
+			if (boxesCollide(minAx, maxAx, minB, maxB)) {
+				collidedAxis += CollisionComponent::CollidedAxis::X;
+			}
+			if (boxesCollide(minAy, maxAy, minB, maxB)) {
+				collidedAxis += CollisionComponent::CollidedAxis::Y;
+			}
+			if (boxesCollide(minAz, maxAz, minB, maxB)) {
+				collidedAxis += CollisionComponent::CollidedAxis::Z;
+			}
+			if (collidedAxis) {
+				colA.onCollide(entity, other, static_cast<CollisionComponent::CollidedAxis>(collidedAxis));
+				colB.onCollided(entity, other, static_cast<CollisionComponent::CollidedAxis>(collidedAxis));
 			}
 		}
 	}

sources/System/Collision/CollisionSystem.hpp

@@ -31,6 +31,6 @@ namespace BBM
 		CollisionSystem &operator=(const CollisionSystem &) = delete;
 
 		//! @brief check AABB collision
-		static bool collide(Vector3f minA, Vector3f maxA, Vector3f minB, Vector3f maxB);
+		static bool boxesCollide(Vector3f minA, Vector3f maxA, Vector3f minB, Vector3f maxB);
 	};
 }

sources/System/Gamepad/GamepadSystem.cpp

@@ -31,10 +31,11 @@ namespace BBM
 
 		for (auto key : keyPressedMap)
 			key.second = gamepad.isPressed(key.first);
-		controllable.move = Vector2f();
-		controllable.move.x += gamepad.isPressed(gamepadComponent.keyRight);
-		controllable.move.x -= gamepad.isPressed(gamepadComponent.keyLeft);
-		controllable.move.y += gamepad.isPressed(gamepadComponent.keyUp);
-		controllable.move.y -= gamepad.isPressed(gamepadComponent.keyDown);
+		controllable.move.x = gamepad.getAxisValue(gamepadComponent.LeftStickX) * -1;
+		controllable.move.y = gamepad.getAxisValue(gamepadComponent.LeftStickY) * -1;
+		controllable.move.x -= gamepad.isDown(gamepadComponent.keyRight);
+		controllable.move.x += gamepad.isDown(gamepadComponent.keyLeft);
+		controllable.move.y += gamepad.isDown(gamepadComponent.keyUp);
+		controllable.move.y -= gamepad.isDown(gamepadComponent.keyDown);
 	}
 }

sources/System/Keyboard/KeyboardSystem.cpp

@@ -31,9 +31,9 @@ namespace BBM
 			key.second = Keyboard::isPressed(key.first);
 		controllable.move = Vector2f();
 		if (Keyboard::isDown(keyboard.keyRight))
-			controllable.move.x += 1;
-		if (Keyboard::isDown(keyboard.keyLeft))
 			controllable.move.x -= 1;
+		if (Keyboard::isDown(keyboard.keyLeft))
+			controllable.move.x += 1;
 		if (Keyboard::isDown(keyboard.keyUp))
 			controllable.move.y += 1;
 		if (Keyboard::isDown(keyboard.keyDown))

sources/System/Renderer/RenderSystem.cpp

@@ -10,13 +10,16 @@
 #include "Component/Renderer/Drawable2DComponent.hpp"
 #include "Drawables/ADrawable3D.hpp"
 
+
+#include "Component/Collision/CollisionComponent.hpp"
+
 namespace BBM
 {
 	RenderSystem::RenderSystem(WAL::Wal &wal, RAY::Window &window, bool debugMode)
 		: System(wal),
-		_window(window),
-		_camera(Vector3f(), Vector3f(), Vector3f(0, 1, 0), 50, CAMERA_PERSPECTIVE),
-		_debugMode(debugMode)
+		  _window(window),
+		  _camera(Vector3f(), Vector3f(), Vector3f(0, 1, 0), 50, CAMERA_PERSPECTIVE),
+		  _debugMode(debugMode)
 	{
 		this->_window.setFPS(this->FPS);
 	}
@@ -44,7 +47,8 @@ namespace BBM
 		this->_window.endDrawing();
 	}
 
-	void RenderSystem::onUpdate(WAL::ViewEntity<CameraComponent, PositionComponent> &entity, std::chrono::nanoseconds dtime)
+	void RenderSystem::onUpdate(WAL::ViewEntity<CameraComponent, PositionComponent> &entity,
+	                            std::chrono::nanoseconds dtime)
 	{
 		const auto &pos = entity.get<PositionComponent>();
 		const auto &cam = entity.get<CameraComponent>();

tests/CollisionTest.cpp

@@ -8,6 +8,7 @@
 #include "Wal.hpp"
 
 #define private public
+
 #include "System/Collision/CollisionSystem.hpp"
 #include "System/Movable/MovableSystem.hpp"
 #include "Component/Movable/MovableComponent.hpp"
@@ -24,14 +25,14 @@ TEST_CASE("Collision test", "[Component][System]")
 	wal.scene = std::make_shared<Scene>();
 	wal.scene->addEntity("player")
 		.addComponent<PositionComponent>()
-		.addComponent<CollisionComponent>([](Entity &actual, const Entity &) {
+		.addComponent<CollisionComponent>([](Entity &actual, const Entity &, int _) {
 			try {
-			auto &pos = actual.getComponent<PositionComponent>();
-			pos.position.x = 1;
-			pos.position.y = 1;
-			pos.position.z = 1;
+				auto &pos = actual.getComponent<PositionComponent>();
+				pos.position.x = 1;
+				pos.position.y = 1;
+				pos.position.z = 1;
 			} catch (std::exception &e) {};
-		}, [](Entity &, const Entity &){}, 5.0);
+		}, [](Entity &, const Entity &, int) {}, 0, 5.0);
 	Entity &entity = wal.scene->getEntities().front();
 	REQUIRE(entity.getComponent<PositionComponent>().position == Vector3f());
 
@@ -44,10 +45,10 @@ TEST_CASE("Collision test", "[Component][System]")
 	REQUIRE(entity.getComponent<PositionComponent>().position.x == 0.0);
 	REQUIRE(entity.getComponent<PositionComponent>().position.y == 0.0);
 	REQUIRE(entity.getComponent<PositionComponent>().position.z == 0.0);
-	
+
 	wal.scene->addEntity("block")
-		.addComponent<PositionComponent>(2,2,2)
-		.addComponent<CollisionComponent>(1);
+		.addComponent<PositionComponent>(2, 2, 2)
+		.addComponent<CollisionComponent>(0, 1);
 	Entity &player = wal.scene->getEntities().front();
 	collision.update(std::chrono::nanoseconds(1));
 	REQUIRE(player.hasComponent(typeid(PositionComponent)));
@@ -68,17 +69,19 @@ TEST_CASE("Collsion test with movable", "[Component][System]")
 	wal.scene = std::make_shared<Scene>();
 	wal.scene->addEntity("player")
 		.addComponent<PositionComponent>()
-		.addComponent<CollisionComponent>([](Entity &actual, const Entity &) {}, [](Entity &actual, const Entity &) {}, 5.0)
+		.addComponent<CollisionComponent>([](Entity &actual, const Entity &, int) {},
+		                                  [](Entity &actual, const Entity &, int) {}, 0, 5.0)
 		.addComponent<MovableComponent>();
-	
+
 	wal.scene->addEntity("block")
 		.addComponent<PositionComponent>(0, 0, 0)
-		.addComponent<CollisionComponent>([](Entity &actual, const Entity &){}, [](Entity &actual, const Entity &) {
-			try {
-			auto &mov = actual.getComponent<MovableComponent>();
-			mov._velocity = Vector3f();
-			} catch (std::exception &e) {};
-		}, 1);
+		.addComponent<CollisionComponent>([](Entity &actual, const Entity &, int) {},
+		                                  [](Entity &actual, const Entity &, int) {
+			                                  try {
+				                                  auto &mov = actual.getComponent<MovableComponent>();
+				                                  mov._velocity = Vector3f();
+			                                  } catch (std::exception &e) {};
+		                                  }, 0, 1);
 	Entity &entity = wal.scene->getEntities().front();
 	REQUIRE(entity.getComponent<PositionComponent>().position == Vector3f());