Merge pull request #129 from AnonymusRaccoon/menuControllable

First Menus

CMakeLists.txt

@@ -77,6 +77,9 @@ set(SOURCES
 	sources/Component/Collision/CollisionComponent.hpp
 	sources/System/Collision/CollisionSystem.hpp
 	sources/System/Collision/CollisionSystem.cpp
+	sources/Component/Button/ButtonComponent.hpp
+	sources/System/MenuControllable/MenuControllableSystem.cpp
+	sources/System/MenuControllable/MenuControllableSystem.hpp
 	sources/Component/Animator/AnimatorComponent.cpp
 	sources/Component/Animator/AnimatorComponent.hpp
 	sources/System/Animator/AnimatorSystem.cpp
@@ -88,6 +91,8 @@ set(SOURCES
 	sources/Component/Music/MusicComponent.hpp
 	sources/Component/Sound/SoundComponent.hpp
 	sources/Component/Sound/SoundComponent.cpp
+	sources/System/Sound/MenuSoundManagerSystem.cpp
+	sources/System/Sound/MenuSoundManagerSystem.hpp
 	sources/System/Sound/PlayerSoundManagerSystem.cpp
 	sources/System/Sound/PlayerSoundManagerSystem.hpp
 	sources/System/Music/MusicSystem.hpp

lib/Ray/sources/Drawables/Image.cpp

@@ -8,13 +8,15 @@
 #include "Drawables/Image.hpp"
 #include "Drawables/ADrawable2D.hpp"
 #include "Drawables/2D/Rectangle.hpp"
+#include "Exceptions/RayError.hpp"
 
 namespace RAY {
 	Cache<::Image> Image::_imagesCache(LoadImage, UnloadImage);
 
 	Image::Image(const std::string &filename, bool lonely):
 		Rectangle(Vector2(0, 0), Vector2(0, 0), WHITE),
-		_image(_imagesCache.fetch(filename, lonely))
+		_image(_imagesCache.fetch(filename, lonely)),
+		_ressourcePath(filename)
 	{
 		this->_dimensions = Vector2(this->_image->width, this->_image->height);
 	}
@@ -30,6 +32,15 @@ namespace RAY {
 		return *this->_image;
 	}
 
+	Image &Image::use(const std::string &filename)
+	{
+		if (this->_ressourcePath == filename)
+			return *this;
+		this->_image = this->_imagesCache.fetch(filename);
+		this->_ressourcePath = filename;
+		return *this;
+	}
+
 	Image::operator ::Image *()
 	{
 		return this->_image.get();
@@ -40,16 +51,15 @@ namespace RAY {
 		drawable.drawOn(*this);
 	}
 
-	void Image::drawOn(RAY::Window &)
+	void Image::resize(const RAY::Vector2 &dimensions)
 	{
-		//Since the image is a shared object, when it is resized, it mush be resized after to its previous dimensions
-		Vector2 oldDims = Vector2(this->_image->width, this->_image->height);
-
-		ImageResize(*this, this->_dimensions.x, this->_dimensions.y);
-		Texture texture(*this);
+		ImageResize(*this, dimensions.x, dimensions.y);
+		this->setDimensions(dimensions);
+	}
 
-		DrawTexture(texture, this->_position.x, this->_position.y, this->_color); 
-		ImageResize(*this, oldDims.x, oldDims.y);
+	void Image::drawOn(RAY::Window &)
+	{
+		throw RAY::Exception::NotSupportedError("An image cannot be drawn onto a window");
 	}
 
 	void Image::drawOn(RAY::Image &image)

lib/Ray/sources/Drawables/Image.hpp

@@ -45,14 +45,21 @@ namespace RAY
 
 			//! @brief Draw image on another image
 			void drawOn(RAY::Image &image) override;
+
+			//! @brief Resize image;
+			void resize(const RAY::Vector2 &dimensions);
 
+			//! @brief Load image from file, lets one use one entity for multiple files
+			Image &use(const std::string &filename);
 
 		private:
 			//! @brief Image, really, that's just it...
 			std::shared_ptr<::Image> _image;
 
 			static Cache<::Image> _imagesCache;
 
+			std::string _ressourcePath;
+
 
 		INTERNAL:
 			//! @brief get image

lib/Ray/sources/Drawables/Texture.cpp

@@ -6,25 +6,46 @@
 */
 
 #include "Drawables/Texture.hpp"
+#include "Drawables/2D/Rectangle.hpp"
+#include "Drawables/Image.hpp"
 
 namespace RAY {
 
 	Cache<::Texture> Texture::_texturesCache(LoadTexture, UnloadTexture); 
 
 	Texture::Texture(const std::string &filename, bool lonely):
+		Rectangle(Vector2(0, 0), Vector2(0, 0), WHITE),
 		_texture(_texturesCache.fetch(filename, lonely)),
 		_resourcePath(filename)
 	{
+		this->_dimensions = Vector2(this->_texture->width, this->_texture->height);
 	}
 
 	Texture::Texture(const Image &image):
+		Rectangle(Vector2(0, 0), Vector2(0, 0), WHITE),
 		_texture(std::make_shared<::Texture>(LoadTextureFromImage(image))),
 		_resourcePath()
 	{
 	}
 
+	Texture &Texture::use(const std::string &filename)
+	{
+		if (this->_resourcePath == filename)
+			return *this;
+		this->_texture = this->_texturesCache.fetch(filename);
+		this->_resourcePath = filename;
+		return *this;
+	}
+
 	Texture::operator ::Texture() const
 	{
 		return *this->_texture;
 	}
+
+	void Texture::drawOn(RAY::Window &)
+	{
+		float scale = this->_dimensions.x / this->_texture->width;
+
+		DrawTextureEx(*this, this->_position, 0, scale, this->_color);
+	}
 }

lib/Ray/sources/Drawables/Texture.hpp

@@ -11,11 +11,12 @@
 #include <raylib.h>
 #include <string>
 #include "Utils/Cache.hpp"
+#include "Drawables/2D/Rectangle.hpp"
 
 namespace RAY
 {
 	//! @brief Object representation of a texture
-	class Texture {
+	class Texture: public Drawables::Drawables2D::Rectangle {
 		public:
 			//! @brief Create an texture, loading a file
 			//! @param filename: path to file to load
@@ -34,6 +35,12 @@ namespace RAY
 			//! @brief Texture destructor, will not unload ressources
 			~Texture() = default;
 
+			//! @brief draw texture on a window
+			void drawOn(RAY::Window &) override;
+
+			//! @brief Load texture from file, lets one use one entity for multiple files
+			Texture &use(const std::string &filename);
+
 		protected:
 		private:
 			//! @brief Texture, really, that's just it...

lib/Ray/sources/Window.cpp

@@ -49,6 +49,7 @@ bool RAY::Window::open(void)
 	}
 	InitWindow(this->_dimensions.x, this->_dimensions.y, this->_title.c_str());
 	this->_isOpen = true;
+	this->setExitKey(Controller::Keyboard::Key::KEY_DELETE);
 	InitAudioDevice();
 	return true;
 }
@@ -160,11 +161,6 @@ void RAY::Window::draw(RAY::Drawables::IDrawable &drawable)
 	drawable.drawOn(*this);
 }
 
-void RAY::Window::draw(const RAY::Texture &texture, const Vector2 &position, const Color &tint)
-{
-	DrawTexture(texture, position.x, position.y, tint);
-}
-
 void RAY::Window::draw(const Mesh &mesh, const Material &material, const Matrix &transform)
 {
 	DrawMesh(mesh, material, transform);
@@ -183,4 +179,9 @@ void RAY::Window::drawFPS(const RAY::Vector2 &position)
 bool RAY::Window::isReady() const
 {
 	return IsWindowReady();
+}
+
+void RAY::Window::setExitKey(RAY::Controller::Keyboard::Key key)
+{
+	SetExitKey(key);
 }

lib/Ray/sources/Window.hpp

@@ -17,7 +17,6 @@
 #include "Camera/Camera2D.hpp"
 #include "Camera/Camera3D.hpp"
 #include "Color.hpp"
-#include "Drawables/Texture.hpp"
 
 namespace RAY {
 	//! @brief Window manager
@@ -124,12 +123,6 @@ namespace RAY {
 			//! @param drawable The drawable to render on screen
 			void draw(RAY::Drawables::IDrawable &drawable);
 
-			//! @brief draw texture at position
-			//! @param texture The object to render
-			//! @param position The position of the texture relative to the top left window corner
-			//! @param tint
-			void draw(const Texture &texture, const Vector2 &position, const Color &tint);
-
 			//! @brief Draw a 3d mesh with material and transform
 			void draw(const Mesh &mesh, const Material &material, const Matrix &transform);
 
@@ -138,6 +131,11 @@ namespace RAY {
 			//! @return true if the window's context has been correctly initialized
 			bool isReady() const;
 
+			//! @param key if this key is pressed, the window will close
+			//! @info Default is ESC key
+			//! @info Calling this function override the previous closing key
+			void setExitKey(Controller::Keyboard::Key key);
+
 
 		private:
 			//! @brief Creates window, and opens it if openNow is set to true

lib/wal/sources/Entity/Entity.cpp

@@ -85,6 +85,11 @@ namespace WAL
 		this->_scene._componentRemoved(*this, type);
 	}
 
+	bool Entity::operator==(const Entity &other) const
+	{
+		return other.getUid() == this->_uid;
+	}
+
 	bool Entity::shouldDelete() const
 	{
 		return this->_shouldDelete;

lib/wal/sources/Entity/Entity.hpp

@@ -46,9 +46,9 @@ namespace WAL
 		friend Scene;
 		friend class Wal;
 	protected:
+	public:
 		//! @brief A reference to the ECS.
 		Scene &_scene;
-	public:
 		//! @brief Get the ID of the entity.
 		unsigned getUid() const;
 		//! @brief Get the name fo the entity
@@ -181,5 +181,8 @@ namespace WAL
 		~Entity() = default;
 		//! @brief An entity is not assignable
 		Entity &operator=(const Entity &) = delete;
+
+		//! @return true if the two entities hold the same uid
+		bool operator==(const Entity &) const;
 	};
 } // namespace WAL

lib/wal/sources/Scene/Scene.cpp

@@ -51,6 +51,11 @@ namespace WAL
 		}
 	}
 
+	int Scene::getID() const
+	{
+		return this->_id;
+	}
+
 	void Scene::_entityRemoved(const Entity &entity)
 	{
 		for (auto &view : this->_views)
@@ -81,9 +86,4 @@ namespace WAL
 		}
 		this->_entities.splice(this->_entities.end(), this->_newEntities);
 	}
-
-	int Scene::getID() const
-	{
-		return this->_id;
-	}
 } // namespace WAL

sources/Component/Button/ButtonComponent.hpp

@@ -0,0 +1,74 @@
+//
+// Created by Louis Auzuret on 06/03/21
+//
+
+#pragma once
+
+#include "Models/Callback.hpp"
+#include "Component/Component.hpp"
+#include "Entity/Entity.hpp"
+#include <optional>
+#include "Wal.hpp"
+
+namespace BBM
+{
+	enum ButtonComponentType { IDLE, CLICK, HOVER };
+
+	template<enum ButtonComponentType T>
+	class ButtonComponent: public WAL::Component
+	{	
+		public:
+			//! @brief onEvent callback
+			WAL::Callback<WAL::Entity &, WAL::Wal &> onEvent;
+
+			//! @brief button which is at the top of this button
+			WAL::Entity *_up;
+			//! @brief button which is below of this button
+			WAL::Entity *_down;
+			//! @brief button which is on the right of this button
+			WAL::Entity *_right;
+			//! @brief button which is on the left of this button
+			WAL::Entity *_left;
+
+			//! @inherit
+			WAL::Component *clone(WAL::Entity &entity) const override
+			{
+				return new ButtonComponent(entity, onEvent);
+			}
+
+			//! @brief Initialize a new Button component.
+			explicit ButtonComponent(WAL::Entity &entity)
+				: WAL::Component(entity), onEvent()
+			{ }
+
+			//! @brief Constructor with the 3 callback
+			ButtonComponent(WAL::Entity &entity, WAL::Callback<WAL::Entity &, WAL::Wal &> callback)
+				:	WAL::Component(entity),
+					onEvent(callback), _up(nullptr), _down(nullptr), _left(nullptr), _right(nullptr)
+			{ }
+
+			ButtonComponent &setButtonLinks(WAL::Entity *up = nullptr, WAL::Entity *down = nullptr,
+							WAL::Entity *left = nullptr, WAL::Entity *right = nullptr)
+			{
+				this->_up = up;
+				this->_down = down;
+				this->_left = left;
+				this->_right = right;
+				return *this;
+			}	
+
+			//! @brief A Controllable component is copy constructable.
+			ButtonComponent(const ButtonComponent<T> &) = default;
+			//! @brief default destructor
+			~ButtonComponent() override = default;
+			//! @brief A Button component default assign operator
+			ButtonComponent<T> &operator=(const ButtonComponent<T> &) = default;
+
+			//! @brief Empty button callback
+			static void emptyButtonCallback(WAL::Entity &)
+			{ }
+	};
+	typedef ButtonComponent<IDLE> OnIdleComponent;
+	typedef ButtonComponent<CLICK> OnClickComponent;
+	typedef ButtonComponent<HOVER> OnHoverComponent;
+}

sources/Component/Keyboard/KeyboardComponent.hpp

@@ -21,7 +21,7 @@ namespace BBM
 			//! @brief bomb key
 			Key keyBomb = KEY_E;
 			//! @brief pause key
-			Key keyPause = KEY_ESCAPE;
+			Key keyPause = RAY::Controller::Keyboard::Key::KEY_ESCAPE;
 			//! @brief move right key
 			Key keyRight = KEY_D;
 			//! @brief move left key