feat: added player input class

player_input.cpp

@@ -0,0 +1,64 @@
+#include "player_input.hpp"
+#include "godot_macros.h"
+#include "godot_cpp/classes/input.hpp"
+#include "godot_cpp/classes/input_event.hpp"
+#include <algorithm>
+
+namespace godot {
+void PlayerInput::_bind_methods() {}
+
+PlayerInput::Listener::Listener(String positive, String negative, Node *object, String method)
+: actionNegative{negative}
+, actionPositive{positive}
+, methodName{method}
+, object{object} {}
+
+bool PlayerInput::Listener::has_changed(Ref<InputEvent> const &event) {
+    return event->is_action(this->actionNegative) || event->is_action(this->actionPositive);
+}
+float PlayerInput::Listener::evaluate(Ref<InputEvent> const &event) {
+    Input *input = Input::get_singleton();
+    float newest = static_cast<float>(input->is_action_pressed(this->actionPositive))
+                 - static_cast<float>(input->is_action_pressed(this->actionNegative));
+    if(lastCached != newest)
+        this->object->call(this->methodName, event, newest);
+    return (lastCached = newest);
+}
+
+bool PlayerInput::Listener::operator==(godot::PlayerInput::Listener const& b) {
+    return this->methodName == b.methodName
+        && this->object == b.object
+        && this->actionNegative == b.actionNegative
+        && this->actionPositive == b.actionPositive;
+}
+
+void PlayerInput::_unhandled_input(Ref<InputEvent> const &event) {
+    GDGAMEONLY();
+    for(Listener& listener: this->listeners) {
+        if(listener.has_changed(event)) {
+            listener.evaluate(event);
+        }
+    }
+}
+
+void PlayerInput::listen_to(Listener const& listener) {
+    this->listeners.push_back(listener);
+}
+
+void PlayerInput::stop_listening(Node *node) {
+    for(size_t i = 0; i < this->listeners.size(); ++i) {
+        Listener& l = this->listeners.at(i);
+        if(l.object == node) {
+            this->listeners.erase(this->listeners.begin() + i);
+            i--;
+        }
+    }
+}
+
+void PlayerInput::stop_listening(Listener const& listener) {
+    std::vector<Listener>::iterator itr = std::find(this->listeners.begin(), this->listeners.end(), listener);
+    if(itr != this->listeners.end())
+        this->listeners.erase(itr);
+}
+}
+

player_input.hpp

@@ -0,0 +1,38 @@
+#ifndef PLAYER_INPUT_HPP
+#define PLAYER_INPUT_HPP
+
+#include <vector>
+#include "godot_cpp/classes/input.hpp"
+#include "godot_cpp/classes/input_event.hpp"
+#include "godot_cpp/classes/node.hpp"
+
+namespace godot {
+class PlayerInput : public Node {
+    GDCLASS(PlayerInput, Node)
+    static void _bind_methods();
+public:
+    struct Listener {
+        String actionNegative{""};
+        String actionPositive{""};
+        float lastCached{0.f};
+        String methodName{""};
+        Node *object;
+
+        Listener(String positive, String negative, Node *object, String method);
+        bool has_changed(Ref<InputEvent> const &event);
+        float evaluate(Ref<InputEvent> const &event);
+        bool operator==(godot::PlayerInput::Listener const& b);
+    };
+private:
+    std::vector<Listener> listeners{};
+public:
+    virtual void _unhandled_input(Ref<InputEvent> const &event) override;
+
+    void listen_to(Listener const& listener);
+    void stop_listening(Node *node);
+    void stop_listening(Listener const& listener);
+};
+}
+
+
+#endif // !PLAYER_INPUT_HPP