Refactor PlayerController.

DogTales/dog/dogtales.cpp

@@ -18,11 +18,9 @@ void DogTales::tick() {
 				if (ImGui::BeginTabItem("Player")) {
 					bave::im_text("Controller States");
 					ImGui::Separator();
-					bave::im_text("move_x (Press A/D or Left/Right): {:.2f}",
-								  m_player.get_controller_state("move_x").value());
-					bave::im_text("move_y (Press W/S or Up/Down): {:.2f}",
-								  m_player.get_controller_state("move_y").value());
-					bave::im_text("Jump (Press 'E'): {:.2f}", m_player.get_controller_state("jump").value());
+					bave::im_text("move_x (Press A/D or Left/Right): {:.2f}", m_player.get_controller_state("move_x"));
+					bave::im_text("move_y (Press W/S or Up/Down): {:.2f}", m_player.get_controller_state("move_y"));
+					bave::im_text("Jump (Press Space): {:.2f}", m_player.get_controller_state("jump"));
 					ImGui::EndTabItem();
 				}
 				ImGui::EndTabBar();

DogTales/dog/dogtales.hpp

@@ -1,6 +1,6 @@
 #pragma once
 #include <bave/driver.hpp>
-#include <dog/player.hpp>
+#include <dog/player/player.hpp>
 
 namespace dog {
 class DogTales : public bave::Driver {

DogTales/dog/player.cpp → DogTales/dog/player/player.cpp

@@ -1,19 +1,24 @@
-#include <dog/player.hpp>
+#include <dog/player/player.hpp>
 
 namespace dog {
 Player::Player(bave::App& app, glm::vec2 const world_space) : m_app(app), m_world_space(world_space) {
 	m_sprite.set_size(size_v);
+
+	m_player_controller.bind_throttle("move_x", {.lo = bave::Key::eLeft, .hi = bave::Key::eRight});
+	m_player_controller.bind_throttle("move_x", {.lo = bave::Key::eA, .hi = bave::Key::eD});
+	m_player_controller.bind_throttle("move_y", {.lo = bave::Key::eDown, .hi = bave::Key::eUp});
+	m_player_controller.bind_throttle("move_y", {.lo = bave::Key::eS, .hi = bave::Key::eW});
+	m_player_controller.bind_key("jump", bave::Key::eSpace);
 }
 
 void Player::tick(bave::Seconds const dt) {
 
 	if (physics_enabled) { m_physics.tick(dt); }
-	m_player_controller.tick(dt, m_app);
 
 	auto direction = glm::vec2{};
 
-	direction.x += m_player_controller.get_controller_state("move_x").value();
-	direction.y += m_player_controller.get_controller_state("move_y").value();
+	direction.x += m_player_controller.get_state("move_x");
+	direction.y += m_player_controller.get_state("move_y");
 
 	if (direction.x != 0.0f || direction.y != 0.0f) {
 		direction = glm::normalize(direction);
@@ -26,9 +31,7 @@ void Player::tick(bave::Seconds const dt) {
 
 void Player::draw(bave::Shader& shader) const { m_sprite.draw(shader); }
 
-std::optional<float> Player::get_controller_state(std::string_view key) const {
-	return m_player_controller.get_controller_state(key);
-}
+float Player::get_controller_state(std::string_view key) const { return m_player_controller.get_state(key); }
 
 void Player::handle_wall_collision() {
 	auto& position = m_physics.position;

DogTales/dog/player.hpp → DogTales/dog/player/player.hpp

@@ -1,8 +1,8 @@
 #pragma once
 #include <bave/app.hpp>
 #include <bave/graphics/sprite.hpp>
-#include "components/physics.hpp"
-#include "player/PlayerController.hpp"
+#include <dog/components/physics.hpp>
+#include <dog/player/player_controller.hpp>
 
 namespace dog {
 class Player {
@@ -16,7 +16,7 @@ class Player {
 	bave::Sprite m_sprite{};
 
 	component::Physics m_physics{};
-	PlayerController m_player_controller{};
+	PlayerController m_player_controller{&m_app};
 
 	void handle_wall_collision();
 
@@ -26,7 +26,7 @@ class Player {
 	void tick(bave::Seconds dt);
 	void draw(bave::Shader& shader) const;
 
-	std::optional<float> get_controller_state(std::string_view key) const;
+	float get_controller_state(std::string_view key) const;
 
 	bool physics_enabled{}; // for debugging
 };

DogTales/dog/player/player_controller.cpp

@@ -0,0 +1,45 @@
+#include <dog/player/player_controller.hpp>
+#include <algorithm>
+#include <cassert>
+
+namespace dog {
+
+PlayerController::PlayerController(bave::NotNull<bave::App const*> app) : m_app(app) {}
+
+void PlayerController::bind_throttle(std::string_view const id, Throttle const throttle) {
+	if (throttle.hi == bave::Key::eUnknown) { return; }
+	auto it = m_mappings.find(id);
+	if (it == m_mappings.end()) {
+		auto [i, _] = m_mappings.insert_or_assign(std::string{id}, std::vector<Mapping>{});
+		it = i;
+	}
+	assert(it != m_mappings.end());
+	it->second.push_back(throttle);
+}
+
+void PlayerController::bind_key(std::string_view id, bave::Key key) {
+	// if Throttle::lo is Key::eUnknown it will be ignored in get_state(), so we exploit that here.
+	bind_throttle(id, Throttle{.hi = key});
+}
+
+float PlayerController::get_state(std::string_view const id) const {
+	auto const search = m_mappings.find(id);
+	if (search == m_mappings.end()) { return 0.0f; }
+
+	auto const& mappings = search->second;
+	auto const get_throttle_state = [&](Throttle const throttle) {
+		auto const is_pressed = [this](bave::Key const key) { return m_app->get_key_state().is_pressed(key); };
+		if (throttle.lo != bave::Key::eUnknown && is_pressed(throttle.lo)) { return -1.0f; }
+		if (is_pressed(throttle.hi)) { return 1.0f; }
+		return 0.0f;
+	};
+
+	auto ret = 0.0f;
+	for (auto const& mapping : mappings) {
+		// later a visitor will be required here, to handle Throttle vs GamepadAxis vs GamepadButton.
+		ret += get_throttle_state(mapping);
+	}
+	return std::clamp(ret, -1.0f, 1.0f);
+}
+
+} // namespace dog

DogTales/dog/player/player_controller.hpp

@@ -0,0 +1,30 @@
+#pragma once
+#include <bave/app.hpp>
+#include <bave/core/string_hash.hpp>
+#include <unordered_map>
+#include <vector>
+
+namespace dog {
+class PlayerController {
+
+  public:
+	struct Throttle {
+		bave::Key lo{}; // -1
+		bave::Key hi{}; // +1
+	};
+
+	explicit PlayerController(bave::NotNull<bave::App const*> app);
+
+	void bind_throttle(std::string_view id, Throttle throttle);
+	void bind_key(std::string_view id, bave::Key key);
+
+	float get_state(std::string_view id) const;
+
+  private:
+	bave::NotNull<bave::App const*> m_app;
+
+	using Mapping = Throttle; // later to be a variant of Throttle / GamepadAxis / GamepadButton.
+
+	std::unordered_map<std::string, std::vector<Mapping>, bave::StringHash, std::equal_to<>> m_mappings{};
+};
+} // namespace dog