Add cast events

Piotr-Aueternum · Piotr-Aueternum · commit cccd644f0bdb · 2025-02-07T00:30:28.000+01:00
diff --git a/src/entities/unit.cpp b/src/entities/unit.cpp
@@ -16,7 +16,8 @@ void createUnit(entt::registry &registry, features::item::ItemsLoader &itemsLoad
 	features::item::entities::equipItem(registry, itemsLoader, entity, 3, features::item::components::SlotType::MainShoulder);
 	features::item::entities::equipItem(registry, itemsLoader, entity, 3, features::item::components::SlotType::OffShoulder);
 
-	features::ability::entities::createAbility(registry, entity, 0.2f, 0.1f, 0.1f, 0.1f);
+	features::ability::entities::createAbility(registry, entity, features::item::components::SlotType::Mainhand, 0.2f, 0.1f, 0.1f, 0.1f);
+	features::ability::entities::createAbility(registry, entity, features::item::components::SlotType::Offhand, 0.2f, 0.1f, 0.1f, 0.1f);
 
 	// features::item::entities::unequipItem(registry, itemsLoader, mainhand);
 }
diff --git a/src/entities/unit.hpp b/src/entities/unit.hpp
@@ -13,6 +13,7 @@
 #include "config.hpp"
 #include "entities/attribute.hpp"
 #include "features/ability/entities/ability.hpp"
+#include "features/item/components/equipped.hpp"
 #include "features/item/entities/item.hpp"
 #include "features/item/loader/itemsLoader.hpp"
 #include "pch.hpp"
diff --git a/src/features/ability/components/ability.hpp b/src/features/ability/components/ability.hpp
@@ -1,12 +1,14 @@
 #pragma once
 
+#include "features/item/components/equipped.hpp"
 #include "pch.hpp"
 
 namespace features::ability::components
 {
 	struct ability
 	{
 		entt::entity source;
+		features::item::components::SlotType slot;
 		float castTime;
 		float activeTime;
 		float delayTime;
diff --git a/src/features/ability/components/castEvent.hpp b/src/features/ability/components/castEvent.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "features/item/components/equipped.hpp"
+
+#include "pch.hpp"
+
+namespace features::ability::components
+{
+	struct castEvent
+	{
+		entt::entity unit;
+		features::item::components::SlotType slot;
+		enum class State
+		{
+			Press,
+			Release,
+			Hold
+		} state;
+	};
+}  // namespace features::ability::components
diff --git a/src/features/ability/entities/ability.cpp b/src/features/ability/entities/ability.cpp
@@ -2,10 +2,11 @@
 
 namespace features::ability::entities
 {
-	entt::entity createAbility(entt::registry &registry, entt::entity unit, float castTime, float activeTime, float delayTime, float cooldown)
+	entt::entity createAbility(entt::registry &registry, entt::entity unit, features::item::components::SlotType slotType, float castTime, float activeTime,
+							   float delayTime, float cooldown)
 	{
 		auto entity = registry.create();
-		registry.emplace<features::ability::components::ability>(entity, unit, castTime, activeTime, delayTime, cooldown);
+		registry.emplace<features::ability::components::ability>(entity, unit, slotType, castTime, activeTime, delayTime, cooldown);
 		registry.emplace<features::ability::components::ready>(entity);
 
 		common::entities::initAttributes(registry, entity);
diff --git a/src/features/ability/entities/ability.hpp b/src/features/ability/entities/ability.hpp
@@ -3,10 +3,12 @@
 #include "../components/ability.hpp"
 #include "../components/ready.hpp"
 #include "entities/attribute.hpp"
+#include "features/item/components/equipped.hpp"
 
 #include "pch.hpp"
 
 namespace features::ability::entities
 {
-	entt::entity createAbility(entt::registry &registry, entt::entity source, float castTime, float activeTime, float delayTime, float cooldown);
+	entt::entity createAbility(entt::registry &registry, entt::entity source, features::item::components::SlotType slotType, float castTime, float activeTime,
+							   float delayTime, float cooldown);
 }  // namespace features::ability::entities
diff --git a/src/features/ability/systems/clearEvents.cpp b/src/features/ability/systems/clearEvents.cpp
@@ -0,0 +1,10 @@
+
+#include "clearEvents.hpp"
+
+namespace features::ability::systems
+{
+	void clearEvents(entt::registry &registry)
+	{
+		registry.view<features::ability::components::castEvent>().each([&registry](auto entity, auto &castEvent) { registry.destroy(entity); });
+	}
+}  // namespace features::ability::systems
diff --git a/src/features/ability/systems/clearEvents.hpp b/src/features/ability/systems/clearEvents.hpp
@@ -0,0 +1,9 @@
+#pragma once
+
+#include "features/ability/components/castEvent.hpp"
+#include "pch.hpp"
+
+namespace features::ability::systems
+{
+	void clearEvents(entt::registry &registry);
+}
diff --git a/src/features/ability/systems/processAbility.cpp b/src/features/ability/systems/processAbility.cpp
@@ -14,13 +14,19 @@ namespace features::ability::systems
 	void processReady(entt::registry &registry)
 	{
 		auto view = registry.view<components::ready, components::ability>();
-
-		for (auto [entity, rdy, abi] : view.each())
+		auto viewEvents = registry.view<components::castEvent>();
+		for (auto [entityEvent, castEvent] : viewEvents.each())
 		{
-			if (sf::Mouse::isButtonPressed(sf::Mouse::Button::Left))
+			for (auto [entity, rdy, abi] : view.each())
 			{
-				registry.remove<components::ready>(entity);
-				registry.emplace<components::cast>(entity, 0.05f);
+				if (abi.source == castEvent.unit && abi.slot == castEvent.slot)
+				{
+					if (castEvent.state == components::castEvent::State::Press || castEvent.state == components::castEvent::State::Hold)
+					{
+						registry.remove<components::ready>(entity);
+						registry.emplace<components::cast>(entity, 0.05f);
+					}
+				}
 			}
 		}
 	}
diff --git a/src/features/ability/systems/processAbility.hpp b/src/features/ability/systems/processAbility.hpp
@@ -3,6 +3,7 @@
 #include "../components/ability.hpp"
 #include "../components/active.hpp"
 #include "../components/cast.hpp"
+#include "../components/castEvent.hpp"
 #include "../components/cooldown.hpp"
 #include "../components/delay.hpp"
 #include "../components/ready.hpp"
diff --git a/src/features/player/managers/inputManager.cpp b/src/features/player/managers/inputManager.cpp
@@ -0,0 +1,41 @@
+#include "inputManager.hpp"
+
+namespace features::player
+{
+	InputManager::InputManager() {}
+
+	bool InputManager::isKeyPressed(sf::Keyboard::Key key)
+	{
+		return (CurrentKeyState[static_cast<std::size_t>(key)] && !PreviousKeyState[static_cast<std::size_t>(key)]);
+	}
+
+	bool InputManager::isKeyReleased(sf::Keyboard::Key key)
+	{
+		return (!CurrentKeyState[static_cast<std::size_t>(key)] && PreviousKeyState[static_cast<std::size_t>(key)]);
+	}
+
+	bool InputManager::isKeyHeld(sf::Keyboard::Key key)
+	{
+		return (CurrentKeyState[static_cast<std::size_t>(key)] && PreviousKeyState[static_cast<std::size_t>(key)]);
+	}
+
+	void InputManager::processEvents(sf::RenderWindow &window)
+	{
+		// Save the state of each keyboard key (must be done before any Key* function is executed)
+		for (unsigned int i = 0; i < sf::Keyboard::KeyCount; ++i)
+		{
+			// Save the keyboard's state from the previous frame
+			PreviousKeyState[i] = CurrentKeyState[i];
+
+			// And save the keyboard's state in the current frame
+			CurrentKeyState[i] = sf::Keyboard::isKeyPressed(static_cast<sf::Keyboard::Key>(i));
+		}
+
+		// if (isKeyPressed(sf::Keyboard::Key::Q))
+		// 	printf("Key Q has been pressed\n");
+		// else if (isKeyHeld(sf::Keyboard::Key::Q))
+		// 	printf("Key Q is held\n");
+		// else if (isKeyReleased(sf::Keyboard::Key::Q))
+		// 	printf("Key Q has been released\n");
+	}
+}  // namespace features::player
diff --git a/src/features/player/managers/inputManager.hpp b/src/features/player/managers/inputManager.hpp
@@ -0,0 +1,21 @@
+#pragma once
+#include "pch.hpp"
+
+namespace features::player
+{
+	class InputManager
+	{
+	  public:
+		InputManager();
+		// See function bodies below
+		void processEvents(sf::RenderWindow &window);
+		bool isKeyPressed(sf::Keyboard::Key Key);
+		bool isKeyReleased(sf::Keyboard::Key Key);
+		bool isKeyHeld(sf::Keyboard::Key Key);
+
+	  private:
+		// The keyboard's state in the current- and the previous frame
+		std::array<bool, sf::Keyboard::KeyCount> CurrentKeyState;
+		std::array<bool, sf::Keyboard::KeyCount> PreviousKeyState;
+	};
+}  // namespace features::player
diff --git a/src/features/player/systems/playerInput.cpp b/src/features/player/systems/playerInput.cpp
@@ -12,7 +12,7 @@ namespace features::player::systems
 		return vec;
 	}
 
-	void playerInput(entt::registry &registry, sf::RenderWindow &window)
+	void playerInput(entt::registry &registry, sf::RenderWindow &window, InputManager &inputManager)
 	{
 		sf::Vector2f dir = {0.f, 0.f};
 
@@ -38,13 +38,35 @@ namespace features::player::systems
 		sf::Vector2f mousePos = (sf::Vector2f) sf::Mouse::getPosition(window);
 
 		auto view = registry.view<features::player::components::playerControlled, common::components::position>();
-		for (auto [entity, playerControlled, pos] : view.each())
+		for (auto [entityUnit, playerControlled, pos] : view.each())
 		{
 			sf::Vector2f dirVec = {mousePos.x - pos.x, mousePos.y - pos.y};
 			dirVec = normalize(dirVec);
 
-			registry.replace<common::components::direction>(entity, dir.x, dir.y);
-			registry.emplace_or_replace<common::components::lookDirection>(entity, dirVec.x, dirVec.y);
+			registry.replace<common::components::direction>(entityUnit, dir.x, dir.y);
+			registry.emplace_or_replace<common::components::lookDirection>(entityUnit, dirVec.x, dirVec.y);
+
+			for (auto [key, slotType] : keyToSlotType)
+			{
+				if (inputManager.isKeyPressed(key))
+				{
+					auto entityEvent = registry.create();
+					registry.emplace<features::ability::components::castEvent>(entityEvent, entityUnit, slotType,
+																			   features::ability::components::castEvent::State::Press);
+				}
+				else if (inputManager.isKeyHeld(key))
+				{
+					auto entityEvent = registry.create();
+					registry.emplace<features::ability::components::castEvent>(entityEvent, entityUnit, slotType,
+																			   features::ability::components::castEvent::State::Hold);
+				}
+				else if (inputManager.isKeyReleased(key))
+				{
+					auto entityEvent = registry.create();
+					registry.emplace<features::ability::components::castEvent>(entityEvent, entityUnit, slotType,
+																			   features::ability::components::castEvent::State::Release);
+				}
+			}
 		}
 	}
-}  // namespace features::player::systems
+}  // namespace features::player::systems
diff --git a/src/features/player/systems/playerInput.hpp b/src/features/player/systems/playerInput.hpp
@@ -1,11 +1,21 @@
+#pragma once
+
+#include "../managers/inputManager.hpp"
 #include "components/direction.hpp"
 #include "components/lookDirection.hpp"
 #include "components/position.hpp"
+#include "features/ability/components/castEvent.hpp"
+#include "features/item/components/equipped.hpp"
 #include "features/player/components/playerControlled.hpp"
 
 #include "pch.hpp"
 
 namespace features::player::systems
 {
-	void playerInput(entt::registry &registry, sf::RenderWindow &window);
-}
+	constexpr std::array<std::tuple<sf::Keyboard::Key, features::item::components::SlotType>, 3> keyToSlotType = {
+		std::make_tuple(sf::Keyboard::Key::Q, features::item::components::SlotType::Mainhand),
+		std::make_tuple(sf::Keyboard::Key::E, features::item::components::SlotType::Offhand),
+		std::make_tuple(sf::Keyboard::Key::R, features::item::components::SlotType::Head)};
+
+	void playerInput(entt::registry &registry, sf::RenderWindow &window, InputManager &inputManager);
+}  // namespace features::player::systems
diff --git a/src/main.cpp b/src/main.cpp
@@ -1,5 +1,6 @@
 #define SFML_DEFINE_DISCRETE_GPU_PREFERENCE
 
+#include "features/ability/systems/clearEvents.hpp"
 #include "features/ability/systems/processAbility.hpp"
 #include "features/enemy/entities/enemy.hpp"
 #include "features/enemy/systems/followPlayer.hpp"
@@ -10,6 +11,7 @@
 #include "features/item/loader/itemsLoader.hpp"
 #include "features/item/renderers/renderItems.hpp"
 #include "features/player/entities/player.hpp"
+#include "features/player/managers/inputManager.hpp"
 #include "features/player/systems/playerInput.hpp"
 #include "gui.hpp"
 #include "pch.hpp"
@@ -41,9 +43,9 @@ void processEvents(entt::registry &registry, sf::RenderWindow &window, GUI &gui)
 	}
 }
 
-void update(entt::registry &registry, float deltaTime, sf::RenderWindow &window)
+void update(entt::registry &registry, float deltaTime, sf::RenderWindow &window, features::player::InputManager &inputManager)
 {
-	features::player::systems::playerInput(registry, window);
+	features::player::systems::playerInput(registry, window, inputManager);
 	features::enemy::systems::followPlayer(registry);
 
 	// features::hitbox::systems::isOnScreen(registry,
@@ -60,7 +62,8 @@ void update(entt::registry &registry, float deltaTime, sf::RenderWindow &window)
 	features::ability::systems::processAbility(registry, deltaTime);
 	common::systems::processDeath(registry);
 
-	common::systems::cleanupRemoved(registry);	// keep last
+	features::ability::systems::clearEvents(registry);	// keep in order -2
+	common::systems::cleanupRemoved(registry);			// keep in order -1
 }
 
 void render(entt::registry &registry, sf::RenderWindow &window, features::item::ItemsLoader &itemsLoader)
@@ -93,6 +96,7 @@ int main()
 	entt::registry registry;
 
 	features::item::ItemsLoader itemsLoader;
+	features::player::InputManager inputManager;
 
 	features::player::entities::createPlayer(registry, config, itemsLoader);
 
@@ -129,11 +133,12 @@ int main()
 			gui.update(static_cast<int>(fps));
 		}
 
+		inputManager.processEvents(window);
 		processEvents(registry, window, gui);
 
 		if (stateManager.isActive(State::Game))
 		{
-			update(registry, deltaTime, window);
+			update(registry, deltaTime, window, inputManager);
 		}
 
 		crosshairSprite.setPosition(static_cast<sf::Vector2f>(sf::Mouse::getPosition(window)));

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,8 @@ void createUnit(entt::registry &registry, features::item::ItemsLoader &itemsLoad`
`16`	`16`	`features::item::entities::equipItem(registry, itemsLoader, entity, 3, features::item::components::SlotType::MainShoulder);`
`17`	`17`	`features::item::entities::equipItem(registry, itemsLoader, entity, 3, features::item::components::SlotType::OffShoulder);`
`18`	`18`
`19`		`- features::ability::entities::createAbility(registry, entity, 0.2f, 0.1f, 0.1f, 0.1f);`
	`19`	`+ features::ability::entities::createAbility(registry, entity, features::item::components::SlotType::Mainhand, 0.2f, 0.1f, 0.1f, 0.1f);`
	`20`	`+ features::ability::entities::createAbility(registry, entity, features::item::components::SlotType::Offhand, 0.2f, 0.1f, 0.1f, 0.1f);`
`20`	`21`
`21`	`22`	`// features::item::entities::unequipItem(registry, itemsLoader, mainhand);`
`22`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,14 @@`
`1`	`1`	`#pragma once`
`2`	`2`
	`3`	`+#include "features/item/components/equipped.hpp"`
`3`	`4`	`#include "pch.hpp"`
`4`	`5`
`5`	`6`	`namespace features::ability::components`
`6`	`7`	`{`
`7`	`8`	`struct ability`
`8`	`9`	`{`
`9`	`10`	`entt::entity source;`
	`11`	`+ features::item::components::SlotType slot;`
`10`	`12`	`float castTime;`
`11`	`13`	`float activeTime;`
`12`	`14`	`float delayTime;`
Original file line number	Diff line number	Diff line change
`@@ -2,10 +2,11 @@`
`2`	`2`
`3`	`3`	`namespace features::ability::entities`
`4`	`4`	`{`
`5`		`- entt::entity createAbility(entt::registry &registry, entt::entity unit, float castTime, float activeTime, float delayTime, float cooldown)`
	`5`	`+ entt::entity createAbility(entt::registry &registry, entt::entity unit, features::item::components::SlotType slotType, float castTime, float activeTime,`
	`6`	`+ float delayTime, float cooldown)`
`6`	`7`	`{`
`7`	`8`	`auto entity = registry.create();`
`8`		`- registry.emplace<features::ability::components::ability>(entity, unit, castTime, activeTime, delayTime, cooldown);`
	`9`	`+ registry.emplace<features::ability::components::ability>(entity, unit, slotType, castTime, activeTime, delayTime, cooldown);`
`9`	`10`	`registry.emplace<features::ability::components::ready>(entity);`
`10`	`11`
`11`	`12`	`common::entities::initAttributes(registry, entity);`
Original file line number	Diff line number	Diff line change
`@@ -14,13 +14,19 @@ namespace features::ability::systems`
`14`	`14`	`void processReady(entt::registry &registry)`
`15`	`15`	`{`
`16`	`16`	`auto view = registry.view<components::ready, components::ability>();`
`17`		`-`
`18`		`- for (auto [entity, rdy, abi] : view.each())`
	`17`	`+ auto viewEvents = registry.view<components::castEvent>();`
	`18`	`+ for (auto [entityEvent, castEvent] : viewEvents.each())`
`19`	`19`	`{`
`20`		`- if (sf::Mouse::isButtonPressed(sf::Mouse::Button::Left))`
	`20`	`+ for (auto [entity, rdy, abi] : view.each())`
`21`	`21`	`{`
`22`		`- registry.remove<components::ready>(entity);`
`23`		`- registry.emplace<components::cast>(entity, 0.05f);`
	`22`	`+ if (abi.source == castEvent.unit && abi.slot == castEvent.slot)`
	`23`	`+ {`
	`24`	`+ if (castEvent.state == components::castEvent::State::Press \|\| castEvent.state == components::castEvent::State::Hold)`
	`25`	`+ {`
	`26`	`+ registry.remove<components::ready>(entity);`
	`27`	`+ registry.emplace<components::cast>(entity, 0.05f);`
	`28`	`+ }`
	`29`	`+ }`
`24`	`30`	`}`
`25`	`31`	`}`
`26`	`32`	`}`