From 47dc1f61b9afd6bbc6651012077e8b1937a8aecf Mon Sep 17 00:00:00 2001
From: Joshua Joseph <joshjoseph97@gmail.com>
Date: Thu, 7 Nov 2024 19:17:07 -0500
Subject: [PATCH 1/5] :pencil2: experimenting with an input chord class

---
 src/engine/Chord.cpp                | 103 ++++++++++++++++++++++++++++
 src/engine/EventManager.cpp         |   2 +-
 src/engine/Input.cpp                |  82 +++++-----------------
 src/engine/includes/Chord.hpp       |  29 ++++++++
 src/engine/includes/Input.hpp       |   9 +--
 src/games/hw4_joshua/hw4_joshua.cpp |   6 +-
 6 files changed, 157 insertions(+), 74 deletions(-)
 create mode 100644 src/engine/Chord.cpp
 create mode 100644 src/engine/includes/Chord.hpp

diff --git a/src/engine/Chord.cpp b/src/engine/Chord.cpp
new file mode 100644
index 0000000..0100854
--- /dev/null
+++ b/src/engine/Chord.cpp
@@ -0,0 +1,103 @@
+#include "Chord.hpp"
+#include "EventManager.hpp"
+#include "Types.hpp"
+#include "Utils.hpp"
+
+Chord::Chord(int chord_id, std::unordered_set<SDL_Scancode> keys) {
+    if (chord_id == 0) {
+        Log(LogLevel::Error, "The chord_id should be greater than 0!");
+        app->quit.store(true);
+        return;
+    }
+
+    this->chord_id = chord_id;
+    this->keys = keys;
+    this->buffer = std::vector<std::pair<SDL_Scancode, bool>>();
+    this->start = std::chrono::steady_clock::now();
+    this->timeout = 50;
+}
+
+void Chord::Process() {
+    auto now = std::chrono::steady_clock::now();
+    this->elapsed =
+        std::chrono::duration_cast<std::chrono::milliseconds>(now - this->start).count();
+
+    if (this->elapsed >= this->timeout) {
+        this->Reset();
+    }
+}
+
+void Chord::ProcessKeyPress(SDL_Scancode key, bool pressed) {
+    if (!this->IsKeyInChord(key)) {
+        return;
+    }
+
+    this->buffer.push_back({key, pressed});
+    this->LogBuffer();
+
+    if (this->BufferContainsChord()) {
+        this->Trigger();
+    }
+}
+
+bool Chord::BufferContainsChord() {
+    std::vector<std::pair<SDL_Scancode, bool>> matched_entries;
+
+    for (const auto &key : this->keys) {
+        auto buffer_iterator = std::find_if(this->buffer.begin(), this->buffer.end(),
+                                            [&key](const std::pair<SDL_Scancode, bool> &entry) {
+                                                return entry.first == key && entry.second;
+                                            });
+
+        if (buffer_iterator == this->buffer.end()) {
+            return false;
+        }
+
+        matched_entries.push_back(*buffer_iterator);
+    }
+
+    for (const auto &entry : matched_entries) {
+        auto iterator = std::find(this->buffer.begin(), this->buffer.end(), entry);
+        if (iterator != this->buffer.end()) {
+            this->buffer.erase(iterator);
+        }
+    }
+
+    return true;
+}
+
+void Chord::FlushBuffer() {
+    for (const auto &entry : this->buffer) {
+        SDL_Scancode key = entry.first;
+        bool pressed = entry.second;
+
+        EventManager::GetInstance().RaiseInputEvent(
+            InputEvent{InputEventType::Single, key, 0, pressed});
+    }
+    this->buffer.clear();
+}
+
+void Chord::LogBuffer() {
+    std::string log_buffer = "";
+    for (const auto &entry : this->buffer) {
+        SDL_Scancode key = entry.first;
+        bool pressed = entry.second;
+
+        log_buffer += std::to_string(key) + "_" + std::to_string(pressed) + " , ";
+    }
+    Log(LogLevel::Info, "buffer: %s", log_buffer.c_str());
+}
+
+void Chord::Reset() {
+    this->start = std::chrono::steady_clock::now();
+    this->FlushBuffer();
+}
+
+void Chord::Trigger() {
+    this->Reset();
+
+    EventManager::GetInstance().RaiseInputEvent(
+        InputEvent{InputEventType::Chord, SDL_SCANCODE_UNKNOWN, this->chord_id, true});
+}
+
+bool Chord::IsKeyInChord(SDL_Scancode key) { return this->keys.count(key) > 0; }
\ No newline at end of file
diff --git a/src/engine/EventManager.cpp b/src/engine/EventManager.cpp
index b273fd0..84b7459 100644
--- a/src/engine/EventManager.cpp
+++ b/src/engine/EventManager.cpp
@@ -154,7 +154,7 @@ void EventManager::ProfileEventQueue() {
 
 void EventManager::RaiseInputEvent(InputEvent event) {
     Event input_event = Event(EventType::Input, event);
-    input_event.SetDelay(0);
+    input_event.SetDelay(-1);
     input_event.SetPriority(Priority::High);
 
     if (event.type == InputEventType::Single) {
diff --git a/src/engine/Input.cpp b/src/engine/Input.cpp
index e7f01ae..723b2f3 100644
--- a/src/engine/Input.cpp
+++ b/src/engine/Input.cpp
@@ -1,29 +1,19 @@
 #include "Input.hpp"
-
-#include "Engine.hpp"
+#include "Chord.hpp"
 #include "EventManager.hpp"
 #include "SDL_keyboard.h"
 #include "SDL_scancode.h"
 #include "Types.hpp"
-#include "Utils.hpp"
 #include <cstddef>
 
 Input::Input() {
     this->keyboard_state = nullptr;
-    this->chords = std::unordered_map<int, std::unordered_set<SDL_Scancode>>();
-    this->key_press_times = std::unordered_map<SDL_Scancode, int64_t>();
-    this->chord_delay = 100;
-}
-
-// Event handler function to be called on key state change
-void Input::RaiseEvent(SDL_Scancode key, bool is_pressed) {
-    EventManager::GetInstance().RaiseInputEvent(
-        InputEvent{InputEventType::Single, key, 0, is_pressed});
+    this->chords = std::vector<Chord>();
 }
 
 bool Input::IsKeyInChords(SDL_Scancode key) {
-    for (const auto &[chord_id, chord_keys] : this->chords) {
-        if (chord_keys.count(key) > 0) {
+    for (Chord &chord : this->chords) {
+        if (chord.IsKeyInChord(key)) {
             return true;
         }
     }
@@ -35,77 +25,37 @@ void Input::Process() {
 
     // If first call, initialize prevState to match the current state
     if (!this->keyboard_state) {
-        int num_keys;
         this->keyboard_state = new Uint8[SDL_NUM_SCANCODES];
         memcpy((void *)this->keyboard_state, new_state, SDL_NUM_SCANCODES);
     }
 
-    // To ensure only changes to chords are raised
-    static std::unordered_map<int, bool> active_chords;
-
-    int64_t current_time = Engine::GetInstance().EngineTimelineGetTime();
-
-    for (const auto &[chord_id, chord_keys] : this->chords) {
-        bool chord_detected = true;
-
-        for (SDL_Scancode key : chord_keys) {
-            if (!new_state[key]) {
-                chord_detected = false;
-                break;
-            }
-        }
-
-        if (chord_detected) {
-            if (!active_chords[chord_id]) {
-                EventManager::GetInstance().RaiseInputEvent(
-                    InputEvent{InputEventType::Chord, SDL_SCANCODE_UNKNOWN, chord_id, true});
-                active_chords[chord_id] = true;
-            }
-        } else {
-            if (active_chords[chord_id]) {
-                EventManager::GetInstance().RaiseInputEvent(
-                    InputEvent{InputEventType::Chord, SDL_SCANCODE_UNKNOWN, chord_id, false});
-                active_chords[chord_id] = false;
-            }
-        }
-    }
-
     // Iterate over all scancodes and check for changes
     for (int i = 0; i < SDL_NUM_SCANCODES; ++i) {
         if (new_state[i] == this->keyboard_state[i]) {
             continue;
         }
 
-        bool is_pressed = new_state[i];
+        bool pressed = new_state[i];
         SDL_Scancode key = static_cast<SDL_Scancode>(i);
 
-        if (is_pressed) {
-            key_press_times[key] = current_time;
-        } else {
-            key_press_times.erase(key);
+        for (Chord &chord : this->chords) {
+            chord.ProcessKeyPress(key, pressed);
         }
 
-        if (this->IsKeyInChords(key)) {
-            int64_t delay = Engine::GetInstance().EngineTimelineGetTime() - key_press_times[key];
-
-            if (delay >= (this->chord_delay * 1'000'000)) {
-                this->RaiseEvent(key, is_pressed);
-            }
-        } else {
-            this->RaiseEvent(key, is_pressed);
+        if (!this->IsKeyInChords(key)) {
+            EventManager::GetInstance().RaiseInputEvent(
+                InputEvent{InputEventType::Single, key, 0, pressed});
         }
     }
 
+    for (Chord &chord : this->chords) {
+        chord.Process();
+    }
+
     // Update the previous state
     memcpy((void *)this->keyboard_state, new_state, SDL_NUM_SCANCODES);
 }
 
-void Input::RegisterInputChord(int chord_id, std::unordered_set<SDL_Scancode> chord) {
-    if (chord_id == 0) {
-        Log(LogLevel::Error, "The chord_id should be greater than 0!");
-        app->quit.store(true);
-        return;
-    }
-
-    this->chords[chord_id] = chord;
+void Input::RegisterInputChord(int chord_id, std::unordered_set<SDL_Scancode> keys) {
+    this->chords.push_back(Chord(chord_id, keys));
 }
\ No newline at end of file
diff --git a/src/engine/includes/Chord.hpp b/src/engine/includes/Chord.hpp
new file mode 100644
index 0000000..e037f2d
--- /dev/null
+++ b/src/engine/includes/Chord.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "SDL_scancode.h"
+#include <chrono>
+#include <unordered_set>
+
+class Chord {
+  private:
+    int chord_id;
+    std::unordered_set<SDL_Scancode> keys;
+
+    std::vector<std::pair<SDL_Scancode, bool>> buffer;
+    std::chrono::steady_clock::time_point start;
+    int64_t elapsed;
+    int timeout;
+
+    void Reset();
+    void Trigger();
+    bool BufferContainsChord();
+    void FlushBuffer();
+    void LogBuffer();
+
+  public:
+    Chord(int chord_id, std::unordered_set<SDL_Scancode> keys);
+
+    void Process();
+    void ProcessKeyPress(SDL_Scancode key, bool pressed);
+    bool IsKeyInChord(SDL_Scancode key);
+};
\ No newline at end of file
diff --git a/src/engine/includes/Input.hpp b/src/engine/includes/Input.hpp
index 4dd1191..d904988 100644
--- a/src/engine/includes/Input.hpp
+++ b/src/engine/includes/Input.hpp
@@ -1,22 +1,19 @@
 #pragma once
 
+#include "Chord.hpp"
 #include "SDL_scancode.h"
 #include "SDL_stdinc.h"
-#include <unordered_map>
 #include <unordered_set>
 
 class Input {
   private:
     Uint8 *keyboard_state;
-    std::unordered_map<int, std::unordered_set<SDL_Scancode>> chords;
-    std::unordered_map<SDL_Scancode, int64_t> key_press_times;
-    int64_t chord_delay;
+    std::vector<Chord> chords;
 
-    void RaiseEvent(SDL_Scancode key, bool is_pressed);
     bool IsKeyInChords(SDL_Scancode key);
 
   public:
     Input();
     void Process();
-    void RegisterInputChord(int chord_id, std::unordered_set<SDL_Scancode> chord);
+    void RegisterInputChord(int chord_id, std::unordered_set<SDL_Scancode> keys);
 };
\ No newline at end of file
diff --git a/src/games/hw4_joshua/hw4_joshua.cpp b/src/games/hw4_joshua/hw4_joshua.cpp
index 75aa9da..15e4a31 100644
--- a/src/games/hw4_joshua/hw4_joshua.cpp
+++ b/src/games/hw4_joshua/hw4_joshua.cpp
@@ -64,6 +64,9 @@ void HandleAlienSingleInput(InputEvent *event) {
 void HandleAlienChordInput(Entity &alien, InputEvent *event) {
     bool pressed = event->pressed;
 
+    if (!pressed) {
+        return;
+    }
     switch (event->chord_id) {
     case 1:
     case 5:
@@ -390,7 +393,8 @@ std::vector<Entity *> CreateEnemies() {
         enemy_index += 1;
         pos_x += 660;
     }
-    return enemies;
+    // return enemies;
+    return std::vector<Entity *>();
 }
 
 std::vector<Entity *> CreateEntities() {

From c2fee70c50b7d7a76c04ef81081db72ff5fc7cc2 Mon Sep 17 00:00:00 2001
From: Joshua Joseph <joshjoseph97@gmail.com>
Date: Thu, 7 Nov 2024 22:12:17 -0500
Subject: [PATCH 2/5] :pencil2: move chord buffers and timers to the input
 class

---
 src/engine/Chord.cpp                | 87 +-------------------------
 src/engine/Input.cpp                | 94 +++++++++++++++++++++++++++--
 src/engine/includes/Chord.hpp       | 16 +----
 src/engine/includes/Input.hpp       | 12 ++++
 src/games/hw4_joshua/hw4_joshua.cpp | 36 ++++-------
 5 files changed, 115 insertions(+), 130 deletions(-)

diff --git a/src/engine/Chord.cpp b/src/engine/Chord.cpp
index 0100854..0a3bbb1 100644
--- a/src/engine/Chord.cpp
+++ b/src/engine/Chord.cpp
@@ -1,5 +1,4 @@
 #include "Chord.hpp"
-#include "EventManager.hpp"
 #include "Types.hpp"
 #include "Utils.hpp"
 
@@ -12,92 +11,10 @@ Chord::Chord(int chord_id, std::unordered_set<SDL_Scancode> keys) {
 
     this->chord_id = chord_id;
     this->keys = keys;
-    this->buffer = std::vector<std::pair<SDL_Scancode, bool>>();
-    this->start = std::chrono::steady_clock::now();
-    this->timeout = 50;
 }
 
-void Chord::Process() {
-    auto now = std::chrono::steady_clock::now();
-    this->elapsed =
-        std::chrono::duration_cast<std::chrono::milliseconds>(now - this->start).count();
+int Chord::GetChordID() { return this->chord_id; }
 
-    if (this->elapsed >= this->timeout) {
-        this->Reset();
-    }
-}
-
-void Chord::ProcessKeyPress(SDL_Scancode key, bool pressed) {
-    if (!this->IsKeyInChord(key)) {
-        return;
-    }
-
-    this->buffer.push_back({key, pressed});
-    this->LogBuffer();
-
-    if (this->BufferContainsChord()) {
-        this->Trigger();
-    }
-}
-
-bool Chord::BufferContainsChord() {
-    std::vector<std::pair<SDL_Scancode, bool>> matched_entries;
-
-    for (const auto &key : this->keys) {
-        auto buffer_iterator = std::find_if(this->buffer.begin(), this->buffer.end(),
-                                            [&key](const std::pair<SDL_Scancode, bool> &entry) {
-                                                return entry.first == key && entry.second;
-                                            });
-
-        if (buffer_iterator == this->buffer.end()) {
-            return false;
-        }
-
-        matched_entries.push_back(*buffer_iterator);
-    }
-
-    for (const auto &entry : matched_entries) {
-        auto iterator = std::find(this->buffer.begin(), this->buffer.end(), entry);
-        if (iterator != this->buffer.end()) {
-            this->buffer.erase(iterator);
-        }
-    }
-
-    return true;
-}
-
-void Chord::FlushBuffer() {
-    for (const auto &entry : this->buffer) {
-        SDL_Scancode key = entry.first;
-        bool pressed = entry.second;
-
-        EventManager::GetInstance().RaiseInputEvent(
-            InputEvent{InputEventType::Single, key, 0, pressed});
-    }
-    this->buffer.clear();
-}
-
-void Chord::LogBuffer() {
-    std::string log_buffer = "";
-    for (const auto &entry : this->buffer) {
-        SDL_Scancode key = entry.first;
-        bool pressed = entry.second;
-
-        log_buffer += std::to_string(key) + "_" + std::to_string(pressed) + " , ";
-    }
-    Log(LogLevel::Info, "buffer: %s", log_buffer.c_str());
-}
-
-void Chord::Reset() {
-    this->start = std::chrono::steady_clock::now();
-    this->FlushBuffer();
-}
-
-void Chord::Trigger() {
-    this->Reset();
-
-    EventManager::GetInstance().RaiseInputEvent(
-        InputEvent{InputEventType::Chord, SDL_SCANCODE_UNKNOWN, this->chord_id, true});
-}
+std::unordered_set<SDL_Scancode> Chord::GetKeys() { return this->keys; }
 
 bool Chord::IsKeyInChord(SDL_Scancode key) { return this->keys.count(key) > 0; }
\ No newline at end of file
diff --git a/src/engine/Input.cpp b/src/engine/Input.cpp
index 723b2f3..dd47f55 100644
--- a/src/engine/Input.cpp
+++ b/src/engine/Input.cpp
@@ -4,11 +4,18 @@
 #include "SDL_keyboard.h"
 #include "SDL_scancode.h"
 #include "Types.hpp"
+#include "Utils.hpp"
+#include <algorithm>
 #include <cstddef>
 
 Input::Input() {
     this->keyboard_state = nullptr;
     this->chords = std::vector<Chord>();
+
+    this->buffer = std::vector<std::pair<SDL_Scancode, bool>>();
+    this->start = std::chrono::steady_clock::now();
+    this->elapsed = 0;
+    this->timeout = 100;
 }
 
 bool Input::IsKeyInChords(SDL_Scancode key) {
@@ -20,6 +27,28 @@ bool Input::IsKeyInChords(SDL_Scancode key) {
     return false;
 }
 
+void Input::LogBuffer() {
+    std::string log_buffer = "";
+    for (const auto &entry : this->buffer) {
+        SDL_Scancode key = entry.first;
+        bool pressed = entry.second;
+
+        log_buffer += std::to_string(key) + "_" + std::to_string(pressed) + " , ";
+    }
+    Log(LogLevel::Info, "buffer: %s", log_buffer.c_str());
+}
+
+void Input::FlushBuffer() {
+    for (const auto &entry : this->buffer) {
+        SDL_Scancode key = entry.first;
+        bool pressed = entry.second;
+
+        EventManager::GetInstance().RaiseInputEvent(
+            InputEvent{InputEventType::Single, key, 0, pressed});
+    }
+    this->buffer.clear();
+}
+
 void Input::Process() {
     const Uint8 *new_state = SDL_GetKeyboardState(NULL);
 
@@ -38,24 +67,77 @@ void Input::Process() {
         bool pressed = new_state[i];
         SDL_Scancode key = static_cast<SDL_Scancode>(i);
 
-        for (Chord &chord : this->chords) {
-            chord.ProcessKeyPress(key, pressed);
-        }
-
         if (!this->IsKeyInChords(key)) {
             EventManager::GetInstance().RaiseInputEvent(
                 InputEvent{InputEventType::Single, key, 0, pressed});
+            continue;
+        }
+
+        this->buffer.push_back({key, pressed});
+        // this->LogBuffer();
+
+        int chord_id = this->BufferContainsChord();
+        if (chord_id != 0) {
+            this->TriggerChord(chord_id);
         }
     }
 
-    for (Chord &chord : this->chords) {
-        chord.Process();
+    auto now = std::chrono::steady_clock::now();
+    this->elapsed =
+        std::chrono::duration_cast<std::chrono::milliseconds>(now - this->start).count();
+
+    if (this->elapsed >= this->timeout) {
+        this->ResetChords();
     }
 
     // Update the previous state
     memcpy((void *)this->keyboard_state, new_state, SDL_NUM_SCANCODES);
 }
 
+int Input::BufferContainsChord() {
+    for (auto &chord : this->chords) {
+        bool chord_found = true;
+
+        for (const auto &key : chord.GetKeys()) {
+            auto buffer_iterator =
+                std::find_if(this->buffer.begin(), this->buffer.end(),
+                             [key](const std::pair<SDL_Scancode, bool> &entry) {
+                                 return entry.first == key && entry.second == true;
+                             });
+            if (buffer_iterator == buffer.end()) {
+                chord_found = false;
+                break;
+            }
+        }
+
+        if (chord_found) {
+            for (const auto &key : chord.GetKeys()) {
+                auto buffer_iterator =
+                    std::remove_if(buffer.begin(), buffer.end(),
+                                   [key](const std::pair<SDL_Scancode, bool> &entry) {
+                                       return entry.first == key && entry.second == true;
+                                   });
+                buffer.erase(buffer_iterator, buffer.end());
+            }
+            return chord.GetChordID();
+        }
+    }
+
+    return 0;
+}
+
+void Input::TriggerChord(int chord_id) {
+    this->ResetChords();
+
+    EventManager::GetInstance().RaiseInputEvent(
+        InputEvent{InputEventType::Chord, SDL_SCANCODE_UNKNOWN, chord_id, true});
+}
+
+void Input::ResetChords() {
+    this->start = std::chrono::steady_clock::now();
+    this->FlushBuffer();
+}
+
 void Input::RegisterInputChord(int chord_id, std::unordered_set<SDL_Scancode> keys) {
     this->chords.push_back(Chord(chord_id, keys));
 }
\ No newline at end of file
diff --git a/src/engine/includes/Chord.hpp b/src/engine/includes/Chord.hpp
index e037f2d..7da9888 100644
--- a/src/engine/includes/Chord.hpp
+++ b/src/engine/includes/Chord.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "SDL_scancode.h"
-#include <chrono>
 #include <unordered_set>
 
 class Chord {
@@ -9,21 +8,10 @@ class Chord {
     int chord_id;
     std::unordered_set<SDL_Scancode> keys;
 
-    std::vector<std::pair<SDL_Scancode, bool>> buffer;
-    std::chrono::steady_clock::time_point start;
-    int64_t elapsed;
-    int timeout;
-
-    void Reset();
-    void Trigger();
-    bool BufferContainsChord();
-    void FlushBuffer();
-    void LogBuffer();
-
   public:
     Chord(int chord_id, std::unordered_set<SDL_Scancode> keys);
 
-    void Process();
-    void ProcessKeyPress(SDL_Scancode key, bool pressed);
+    int GetChordID();
+    std::unordered_set<SDL_Scancode> GetKeys();
     bool IsKeyInChord(SDL_Scancode key);
 };
\ No newline at end of file
diff --git a/src/engine/includes/Input.hpp b/src/engine/includes/Input.hpp
index d904988..371bf17 100644
--- a/src/engine/includes/Input.hpp
+++ b/src/engine/includes/Input.hpp
@@ -3,14 +3,26 @@
 #include "Chord.hpp"
 #include "SDL_scancode.h"
 #include "SDL_stdinc.h"
+#include <chrono>
 #include <unordered_set>
+#include <vector>
 
 class Input {
   private:
     Uint8 *keyboard_state;
     std::vector<Chord> chords;
 
+    std::vector<std::pair<SDL_Scancode, bool>> buffer;
+    std::chrono::steady_clock::time_point start;
+    int64_t elapsed;
+    int timeout;
+
     bool IsKeyInChords(SDL_Scancode key);
+    int BufferContainsChord();
+    void LogBuffer();
+    void FlushBuffer();
+    void TriggerChord(int chord_id);
+    void ResetChords();
 
   public:
     Input();
diff --git a/src/games/hw4_joshua/hw4_joshua.cpp b/src/games/hw4_joshua/hw4_joshua.cpp
index 15e4a31..adac064 100644
--- a/src/games/hw4_joshua/hw4_joshua.cpp
+++ b/src/games/hw4_joshua/hw4_joshua.cpp
@@ -37,22 +37,18 @@ void HandleAlienSingleInput(InputEvent *event) {
     SDL_Scancode key = event->key;
     switch (key) {
     case SDL_SCANCODE_W:
-    case SDL_SCANCODE_UP:
         key_state.up = pressed;
         break;
 
     case SDL_SCANCODE_S:
-    case SDL_SCANCODE_DOWN:
         key_state.down = pressed;
         break;
 
     case SDL_SCANCODE_A:
-    case SDL_SCANCODE_LEFT:
         key_state.left = pressed;
         break;
 
     case SDL_SCANCODE_D:
-    case SDL_SCANCODE_RIGHT:
         key_state.right = pressed;
         break;
 
@@ -69,28 +65,24 @@ void HandleAlienChordInput(Entity &alien, InputEvent *event) {
     }
     switch (event->chord_id) {
     case 1:
-    case 5:
         key_state.power_up = pressed;
         alien.GetComponent<Physics>()->SetVelocity(
-            {alien.GetComponent<Physics>()->GetVelocity().x, -150});
+            {alien.GetComponent<Physics>()->GetVelocity().x, -200});
         break;
     case 2:
-    case 6:
         key_state.power_down = pressed;
         alien.GetComponent<Physics>()->SetVelocity(
-            {alien.GetComponent<Physics>()->GetVelocity().x, 150});
+            {alien.GetComponent<Physics>()->GetVelocity().x, 200});
         break;
     case 3:
-    case 7:
         key_state.power_left = pressed;
         alien.GetComponent<Physics>()->SetVelocity(
-            {-150, alien.GetComponent<Physics>()->GetVelocity().y});
+            {-200, alien.GetComponent<Physics>()->GetVelocity().y});
         break;
     case 4:
-    case 8:
         key_state.power_right = pressed;
         alien.GetComponent<Physics>()->SetVelocity(
-            {150, alien.GetComponent<Physics>()->GetVelocity().y});
+            {200, alien.GetComponent<Physics>()->GetVelocity().y});
         break;
     default:
         break;
@@ -177,7 +169,8 @@ void UpdateAlien(Entity &alien) {
     }
     if (!key_state.left && !key_state.right) {
         alien.GetComponent<Physics>()->SetVelocity(
-            {0, alien.GetComponent<Physics>()->GetVelocity().y});
+            {float(alien.GetComponent<Physics>()->GetVelocity().x * 0.99),
+             alien.GetComponent<Physics>()->GetVelocity().y});
     }
 }
 
@@ -393,8 +386,7 @@ std::vector<Entity *> CreateEnemies() {
         enemy_index += 1;
         pos_x += 660;
     }
-    // return enemies;
-    return std::vector<Entity *>();
+    return enemies;
 }
 
 std::vector<Entity *> CreateEntities() {
@@ -478,16 +470,10 @@ void BindEngineInputs() {
 }
 
 void RegisterInputChords() {
-    Engine::GetInstance().RegisterInputChord(1, {SDL_SCANCODE_A, SDL_SCANCODE_D});
-
-    // Engine::GetInstance().RegisterInputChord(1, {SDL_SCANCODE_W, SDL_SCANCODE_SPACE});
-    // Engine::GetInstance().RegisterInputChord(2, {SDL_SCANCODE_S, SDL_SCANCODE_SPACE});
-    // Engine::GetInstance().RegisterInputChord(3, {SDL_SCANCODE_A, SDL_SCANCODE_SPACE});
-    // Engine::GetInstance().RegisterInputChord(4, {SDL_SCANCODE_D, SDL_SCANCODE_SPACE});
-    // Engine::GetInstance().RegisterInputChord(5, {SDL_SCANCODE_UP, SDL_SCANCODE_SPACE});
-    // Engine::GetInstance().RegisterInputChord(6, {SDL_SCANCODE_DOWN, SDL_SCANCODE_SPACE});
-    // Engine::GetInstance().RegisterInputChord(7, {SDL_SCANCODE_LEFT, SDL_SCANCODE_SPACE});
-    // Engine::GetInstance().RegisterInputChord(8, {SDL_SCANCODE_RIGHT, SDL_SCANCODE_SPACE});
+    Engine::GetInstance().RegisterInputChord(1, {SDL_SCANCODE_W, SDL_SCANCODE_P});
+    Engine::GetInstance().RegisterInputChord(2, {SDL_SCANCODE_S, SDL_SCANCODE_P});
+    Engine::GetInstance().RegisterInputChord(3, {SDL_SCANCODE_A, SDL_SCANCODE_P});
+    Engine::GetInstance().RegisterInputChord(4, {SDL_SCANCODE_D, SDL_SCANCODE_P});
 }
 
 int main(int argc, char *args[]) {

From d014f9f2e010e14442a87a42b564df2293293890 Mon Sep 17 00:00:00 2001
From: Joshua Joseph <joshjoseph97@gmail.com>
Date: Thu, 7 Nov 2024 23:41:47 -0500
Subject: [PATCH 3/5] :pencil2: make enemies death-zones and merge ground tiles

---
 src/engine/EventManager.cpp            |   9 +---
 src/engine/Input.cpp                   |   1 -
 src/games/hw4_joshua/assets/ground.png | Bin 3788 -> 32104 bytes
 src/games/hw4_joshua/hw4_joshua.cpp    |  58 ++++++++-----------------
 4 files changed, 20 insertions(+), 48 deletions(-)

diff --git a/src/engine/EventManager.cpp b/src/engine/EventManager.cpp
index 84b7459..e43e8b8 100644
--- a/src/engine/EventManager.cpp
+++ b/src/engine/EventManager.cpp
@@ -154,16 +154,9 @@ void EventManager::ProfileEventQueue() {
 
 void EventManager::RaiseInputEvent(InputEvent event) {
     Event input_event = Event(EventType::Input, event);
-    input_event.SetDelay(-1);
+    input_event.SetDelay(0);
     input_event.SetPriority(Priority::High);
 
-    if (event.type == InputEventType::Single) {
-        Log(LogLevel::Info, "Raising single input: [%d] [%d]", event.pressed, event.key);
-    }
-    if (event.type == InputEventType::Chord) {
-        Log(LogLevel::Info, "Raising chord  input: [%d], [%d]", event.pressed, event.chord_id);
-    }
-
     this->Raise(input_event);
 }
 
diff --git a/src/engine/Input.cpp b/src/engine/Input.cpp
index dd47f55..2d62294 100644
--- a/src/engine/Input.cpp
+++ b/src/engine/Input.cpp
@@ -74,7 +74,6 @@ void Input::Process() {
         }
 
         this->buffer.push_back({key, pressed});
-        // this->LogBuffer();
 
         int chord_id = this->BufferContainsChord();
         if (chord_id != 0) {
diff --git a/src/games/hw4_joshua/assets/ground.png b/src/games/hw4_joshua/assets/ground.png
index acd03cd860c829c6179ef12a01e01f5671b54138..323ec060cb82e59bb0ca9dd53ac693789d0cbbad 100644
GIT binary patch
literal 32104
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
SaKD|ta{1b?QonTl?*9Xs6wdMh

literal 3788
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

diff --git a/src/games/hw4_joshua/hw4_joshua.cpp b/src/games/hw4_joshua/hw4_joshua.cpp
index adac064..bf53dd6 100644
--- a/src/games/hw4_joshua/hw4_joshua.cpp
+++ b/src/games/hw4_joshua/hw4_joshua.cpp
@@ -23,10 +23,6 @@ struct KeyState {
     bool down;
     bool left;
     bool right;
-    bool power_up;
-    bool power_down;
-    bool power_left;
-    bool power_right;
 } key_state;
 
 void Update(std::vector<Entity *> &entities) {}
@@ -65,22 +61,18 @@ void HandleAlienChordInput(Entity &alien, InputEvent *event) {
     }
     switch (event->chord_id) {
     case 1:
-        key_state.power_up = pressed;
         alien.GetComponent<Physics>()->SetVelocity(
             {alien.GetComponent<Physics>()->GetVelocity().x, -200});
         break;
     case 2:
-        key_state.power_down = pressed;
         alien.GetComponent<Physics>()->SetVelocity(
             {alien.GetComponent<Physics>()->GetVelocity().x, 200});
         break;
     case 3:
-        key_state.power_left = pressed;
         alien.GetComponent<Physics>()->SetVelocity(
             {-200, alien.GetComponent<Physics>()->GetVelocity().y});
         break;
     case 4:
-        key_state.power_right = pressed;
         alien.GetComponent<Physics>()->SetVelocity(
             {200, alien.GetComponent<Physics>()->GetVelocity().y});
         break;
@@ -123,12 +115,6 @@ void HandleAlienCollision(Entity &alien, Event &event) {
         return;
     }
 
-    if (collider->GetName().find("enemy") == 0) {
-        Log(LogLevel::Info, "");
-        Log(LogLevel::Info, "You lost :(");
-        Log(LogLevel::Info, "");
-        app->quit.store(true);
-    }
     if (collider->GetName().find("house") == 0) {
         Log(LogLevel::Info, "");
         Log(LogLevel::Info, "You made it home!");
@@ -288,23 +274,19 @@ Entity *CreateSun() {
     return sun;
 }
 
-std::vector<Entity *> CreateGround() {
-    std::vector<Entity *> ground;
-    for (int i = 0; i < (window_size.width / TILE_SIZE) * 2; i++) {
-        Entity *ground_tile = new Entity("ground_" + std::to_string(i), EntityCategory::Stationary);
-        ground_tile->AddComponent<Render>();
-        ground_tile->AddComponent<Transform>();
-        ground_tile->AddComponent<Network>();
-        ground_tile->AddComponent<Handler>();
-
-        ground_tile->GetComponent<Render>()->SetColor(Color{0, 0, 0, 0});
-        ground_tile->GetComponent<Transform>()->SetPosition(
-            Position{float(i * TILE_SIZE), float(window_size.height - TILE_SIZE)});
-        ground_tile->GetComponent<Transform>()->SetSize(Size{TILE_SIZE, TILE_SIZE});
-        ground_tile->GetComponent<Render>()->SetTexture("assets/ground.png");
-        ground_tile->GetComponent<Network>()->SetOwner(NetworkRole::Client);
-        ground.push_back(ground_tile);
-    }
+Entity *CreateGround() {
+    Entity *ground = new Entity("ground", EntityCategory::Stationary);
+    ground->AddComponent<Render>();
+    ground->AddComponent<Transform>();
+    ground->AddComponent<Network>();
+    ground->AddComponent<Handler>();
+
+    ground->GetComponent<Render>()->SetColor(Color{0, 0, 0, 0});
+    ground->GetComponent<Transform>()->SetPosition(
+        Position{0, float(window_size.height - TILE_SIZE)});
+    ground->GetComponent<Transform>()->SetSize(Size{TILE_SIZE * 38, TILE_SIZE});
+    ground->GetComponent<Render>()->SetTexture("assets/ground.png");
+    ground->GetComponent<Network>()->SetOwner(NetworkRole::Client);
     return ground;
 }
 
@@ -359,11 +341,12 @@ std::vector<Entity *> CreateClouds() {
 std::vector<Entity *> CreateEnemies() {
     std::vector<Entity *> enemies;
     int enemy_index = 0;
-    float pos_x = 220.0f;
+    float pos_x = 1540.0f;
     float pos_y = float(window_size.height - (TILE_SIZE * 2));
 
     while (pos_x < 3000) {
-        Entity *enemy = new Entity("enemy_" + std::to_string(enemy_index), EntityCategory::Moving);
+        Entity *enemy =
+            new Entity("enemy_" + std::to_string(enemy_index), EntityCategory::DeathZone);
         enemy->AddComponent<Transform>();
         enemy->AddComponent<Physics>();
         enemy->AddComponent<Handler>();
@@ -371,7 +354,7 @@ std::vector<Entity *> CreateEnemies() {
         enemy->AddComponent<Network>();
 
         float pos_y_offset = enemy_index % 2 == 0 ? -(TILE_SIZE * 3) : 0;
-        float vel_y = enemy_index % 2 == 0 ? 30 : -30;
+        float vel_y = enemy_index % 2 == 0 ? 20 : -20;
 
         enemy->GetComponent<Transform>()->SetPosition(Position{pos_x, pos_y + pos_y_offset});
         enemy->GetComponent<Transform>()->SetSize(Size{TILE_SIZE, TILE_SIZE});
@@ -394,14 +377,11 @@ std::vector<Entity *> CreateEntities() {
     Entity *platform = CreatePlatform();
     Entity *house = CreateHouse();
     Entity *sun = CreateSun();
-    std::vector<Entity *> ground = CreateGround();
+    Entity *ground = CreateGround();
     std::vector<Entity *> clouds = CreateClouds();
     std::vector<Entity *> enemies = CreateEnemies();
 
-    std::vector<Entity *> entities = std::vector({alien, platform, house, sun});
-    for (Entity *ground_tile : ground) {
-        entities.push_back(ground_tile);
-    }
+    std::vector<Entity *> entities = std::vector({alien, platform, house, sun, ground});
     for (Entity *cloud : clouds) {
         entities.push_back(cloud);
     }

From 3fff4dac3ebb1ac6f8c18f5d7176c7e6d100d068 Mon Sep 17 00:00:00 2001
From: Joshua Joseph <joshjoseph97@gmail.com>
Date: Thu, 7 Nov 2024 23:46:07 -0500
Subject: [PATCH 4/5] :pencil2: reduce velocity of vertical power ups

---
 src/games/hw4_joshua/hw4_joshua.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/games/hw4_joshua/hw4_joshua.cpp b/src/games/hw4_joshua/hw4_joshua.cpp
index bf53dd6..1f6a3ad 100644
--- a/src/games/hw4_joshua/hw4_joshua.cpp
+++ b/src/games/hw4_joshua/hw4_joshua.cpp
@@ -62,11 +62,11 @@ void HandleAlienChordInput(Entity &alien, InputEvent *event) {
     switch (event->chord_id) {
     case 1:
         alien.GetComponent<Physics>()->SetVelocity(
-            {alien.GetComponent<Physics>()->GetVelocity().x, -200});
+            {alien.GetComponent<Physics>()->GetVelocity().x, -150});
         break;
     case 2:
         alien.GetComponent<Physics>()->SetVelocity(
-            {alien.GetComponent<Physics>()->GetVelocity().x, 200});
+            {alien.GetComponent<Physics>()->GetVelocity().x, 150});
         break;
     case 3:
         alien.GetComponent<Physics>()->SetVelocity(

From 5ae3bef2a25673e8bee3c669562399f129c61978 Mon Sep 17 00:00:00 2001
From: ron-matt163 <rohanjm01@gmail.com>
Date: Thu, 7 Nov 2024 23:56:15 -0500
Subject: [PATCH 5/5] Null check for the physics component in
 HandlePairwiseCollisions and Chord support in HW4 Rohan game

---
 src/engine/Collision.cpp          | 24 +++++----
 src/games/hw4_rohan/hw4_rohan.cpp | 84 +++++++++++++++++++------------
 2 files changed, 65 insertions(+), 43 deletions(-)

diff --git a/src/engine/Collision.cpp b/src/engine/Collision.cpp
index ae3ca61..57862ee 100644
--- a/src/engine/Collision.cpp
+++ b/src/engine/Collision.cpp
@@ -72,8 +72,6 @@ void Collision::HandlePairwiseCollision(Entity *collider) {
     Overlap overlap = GetOverlap(rect_1, rect_2);
 
     int pos_x = 0, pos_y = 0;
-    float vel_x = this->entity->GetComponent<Physics>()->GetVelocity().x;
-    float vel_y = this->entity->GetComponent<Physics>()->GetVelocity().y;
 
     if (overlap == Overlap::Left) {
         pos_x = col_x - obj_width;
@@ -89,18 +87,22 @@ void Collision::HandlePairwiseCollision(Entity *collider) {
         pos_y = col_y + col_height;
     }
 
-    this->entity->GetComponent<Transform>()->SetPosition(Position{float(pos_x), float(pos_y)});
+    if (this->entity->GetComponent<Physics>()) {
+        this->entity->GetComponent<Transform>()->SetPosition(Position{float(pos_x), float(pos_y)});
+        float vel_x = this->entity->GetComponent<Physics>()->GetVelocity().x;
+        float vel_y = this->entity->GetComponent<Physics>()->GetVelocity().y;
 
-    if (collider->GetCategory() != EntityCategory::SideBoundary) {
-        if (overlap == Overlap::Left || overlap == Overlap::Right) {
-            vel_x *= -this->GetRestitution();
-        }
-        if (overlap == Overlap::Top || overlap == Overlap::Bottom) {
-            vel_y *= -this->GetRestitution();
+        if (collider->GetCategory() != EntityCategory::SideBoundary) {
+            if (overlap == Overlap::Left || overlap == Overlap::Right) {
+                vel_x *= -this->GetRestitution();
+            }
+            if (overlap == Overlap::Top || overlap == Overlap::Bottom) {
+                vel_y *= -this->GetRestitution();
+            }
         }
-    }
 
-    this->entity->GetComponent<Physics>()->SetVelocity(Velocity{vel_x, vel_y});
+        this->entity->GetComponent<Physics>()->SetVelocity(Velocity{vel_x, vel_y});
+    }
 }
 
 void Collision::Update() {}
diff --git a/src/games/hw4_rohan/hw4_rohan.cpp b/src/games/hw4_rohan/hw4_rohan.cpp
index f7ca54c..7ba7eb9 100644
--- a/src/games/hw4_rohan/hw4_rohan.cpp
+++ b/src/games/hw4_rohan/hw4_rohan.cpp
@@ -39,9 +39,34 @@ void AssignOperationsToKeys() {
     Engine::GetInstance().RegisterInputChord(3, {SDL_SCANCODE_UP, SDL_SCANCODE_SPACE});
 }
 
-void HandlePlayerSingleInput(InputEvent event) {
-    bool pressed = event.pressed;
-    SDL_Scancode key = event.key;
+// Pass a nullptr if the input event was not a chord event so that the chord actions are disabled.
+void HandlePlayerChordInput(InputEvent *event) {
+    if (event) {
+        bool pressed = event->pressed;
+
+        switch (event->chord_id) {
+        case 1:
+            player_event.dash_left = pressed;
+            break;
+        case 2:
+            player_event.dash_right = pressed;
+            break;
+        case 3:
+            player_event.power_jump = pressed;
+            break;
+        default:
+            break;
+        }
+    } else {
+        // Chord release events are not raised
+        player_event.dash_left = player_event.dash_right = player_event.power_jump = false;
+    }
+}
+
+void HandlePlayerSingleInput(InputEvent *event) {
+    HandlePlayerChordInput(nullptr);
+    bool pressed = event->pressed;
+    SDL_Scancode key = event->key;
 
     switch (key) {
     case SDL_SCANCODE_LEFT:
@@ -60,39 +85,16 @@ void HandlePlayerSingleInput(InputEvent event) {
     }
 }
 
-void HandlePlayerChordInput(Entity &player, InputEvent &event) {
-    bool pressed = event.pressed;
-
-    switch (event.chord_id) {
-    case 1:
-        player_event.dash_left = pressed;
-        player.GetComponent<Physics>()->SetVelocity(
-            {-90, player.GetComponent<Physics>()->GetVelocity().y});
-        break;
-    case 2:
-        player_event.dash_right = pressed;
-        player.GetComponent<Physics>()->SetVelocity(
-            {90, player.GetComponent<Physics>()->GetVelocity().y});
-        break;
-    case 3:
-        player_event.power_jump = pressed;
-        player.GetComponent<Physics>()->SetVelocity(
-            {player.GetComponent<Physics>()->GetVelocity().x, -100});
-        break;
-    default:
-        break;
-    }
-}
-
 void HandlePlayerEvent(Entity &player, Event &event) {
     InputEvent *input_event = std::get_if<InputEvent>(&(event.data));
+
     if (input_event) {
         switch (input_event->type) {
         case InputEventType::Single:
-            HandlePlayerSingleInput(*input_event);
+            HandlePlayerSingleInput(input_event);
             break;
         case InputEventType::Chord:
-            HandlePlayerChordInput(player, *input_event);
+            HandlePlayerChordInput(input_event);
             break;
         default:
             break;
@@ -107,17 +109,36 @@ void UpdatePlayer(Entity &player) {
         player_moved = true;
         player.GetComponent<Physics>()->SetVelocity(
             {30, player.GetComponent<Physics>()->GetVelocity().y});
-    } else if (player_event.move_left) {
+    }
+    if (player_event.move_left) {
         player_moved = true;
         player.GetComponent<Physics>()->SetVelocity(
             {-30, player.GetComponent<Physics>()->GetVelocity().y});
     }
-
     if (player_event.jump) {
+        // Log(LogLevel::Info, "Regular jump");
         player_moved = true;
         player.GetComponent<Physics>()->SetVelocity(
             {player.GetComponent<Physics>()->GetVelocity().x, -30});
     }
+    if (player_event.dash_left) {
+        // Log(LogLevel::Info, "Left dash!");
+        player.GetComponent<Physics>()->SetVelocity(
+            {-90, player.GetComponent<Physics>()->GetVelocity().y});
+        player_moved = true;
+    }
+    if (player_event.dash_right) {
+        // Log(LogLevel::Info, "Right dash!");
+        player.GetComponent<Physics>()->SetVelocity(
+            {90, player.GetComponent<Physics>()->GetVelocity().y});
+        player_moved = true;
+    }
+    if (player_event.power_jump) {
+        // Log(LogLevel::Info, "Power jump!");
+        player.GetComponent<Physics>()->SetVelocity(
+            {player.GetComponent<Physics>()->GetVelocity().x, -100});
+        player_moved = true;
+    }
 
     if (!player_moved) {
         player.GetComponent<Physics>()->SetVelocity(
@@ -330,7 +351,6 @@ Entity *CreatePlayer() {
     player->AddComponent<Network>();
     player->AddComponent<Handler>();
 
-    // player->GetComponent<Transform>()->SetPosition({300, 300});
     player->GetComponent<Transform>()->SetSize({50, 100});
 
     player->GetComponent<Physics>()->SetAcceleration({0, 10});