Game/phase evasion gameplay

include/common.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <cstddef>
+#include <cstdint>
 
 template <typename T, uint16_t N>
 constexpr uint16_t arraySize(const T (&)[N]) { return N; }

include/engine/system-config.h → include/core/configuration.h

@@ -2,9 +2,9 @@
 
 #include <cstdint>
 
-namespace Engine
+namespace SystemCore
 {
-  struct SystemConfig
+  struct Configuration
   {
     // REQUIRED: modify this address to match the mac address of your PS3 controller
     static constexpr char macAddress[] = "00:1b:fb:8e:87:ac";

include/core/context-manager.h

@@ -2,12 +2,12 @@
 
 #include "engine/layer.h"
 #include "engine/state-manager.h"
-#include "engine/system-config.h"
+#include "core/configuration.h"
 #include "player/controller.h"
 #include "lights/led-strip.h"
 #include "display/display.h"
 
-namespace Core
+namespace SystemCore
 {
   class ContextManager
   {
@@ -19,7 +19,7 @@ namespace Core
 
     Engine::Layer *application = nullptr;
     Engine::StateManager stateManager;
-    Engine::SystemConfig config;
+    SystemCore::Configuration config;
     Player::Controller controller;
     Lights::LedStrip leds;
     Display::OledDisplay display;

include/display/display-images.h

@@ -11,7 +11,7 @@ namespace Display
 {
   struct ImageInitLogo
   {
-    inline static const unsigned char rawValues[] PROGMEM = {
+    static constexpr unsigned char rawValues[] PROGMEM = {
         0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x07, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x3f, 0x80, 0x00, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00,

include/display/display.h

@@ -11,9 +11,9 @@
 
 #include "display/display-images.h"
 
-// forward declaration because of ContextManager/OledDisplay circular dependency
-namespace Core
+namespace SystemCore
 {
+  // forward declaration because of ContextManager/OledDisplay circular dependency
   class ContextManager;
 }
 
@@ -23,7 +23,7 @@ namespace Display
   class OledDisplay
   {
   public:
-    OledDisplay(Core::ContextManager *contextManager);
+    OledDisplay(SystemCore::ContextManager *contextManager);
     void updateDisplay();
 
   private:
@@ -32,7 +32,7 @@ namespace Display
     static constexpr int DISPLAY_ADDRESS = 0x3c;
     Adafruit_SSD1306 display;
 
-    Core::ContextManager *contextManager;
+    SystemCore::ContextManager *contextManager;
     ImageInitLogo initLogo;
 
     char selectedOption(uint8_t index, uint8_t selectedOptionIndex) { return index == selectedOptionIndex ? '>' : ' '; };

include/engine/engine.h

@@ -16,7 +16,7 @@ namespace Engine
     void standbyControllerConnection();
 
   private:
-    Core::ContextManager contextManager;
+    SystemCore::ContextManager contextManager;
     uint32_t lastRender = 0;
     void initializeEngine();
     void renderLedStrip();

include/engine/state-manager.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include "games/recall/recall-state.h"
-#include "games/phase-evasion/phase-evasion-state.h"
-#include "games/demo/demo-state.h"
-#include "scenes/canvas/canvas-state.h"
+#include "games/recall/state.h"
+#include "games/phase-evasion/state.h"
+#include "games/demo/state.h"
+#include "scenes/canvas/state.h"
 
 namespace Engine
 {
@@ -76,11 +76,11 @@ namespace Engine
     const char *printGameName(uint8_t index);
     const char *printSceneName(uint8_t index);
 
-    Games::RecallGameState &getRecallGameState() { return recallGameState; }
-    Games::PhaseEvasionGameState &getPhaseEvasionGameState() { return phaseEvasionGameState; }
-    Games::DemoGameState &getDemoGameState() { return demoGameState; }
+    Games::Recall::GameState &getRecallGameState() { return recallGameState; }
+    Games::PhaseEvasion::GameState &getPhaseEvasionGameState() { return phaseEvasionGameState; }
+    Games::Demo::GameState &getDemoGameState() { return demoGameState; }
 
-    Scenes::CanvasSceneState &getCanvasSceneState() { return canvasSceneState; }
+    Scenes::Canvas::SceneState &getCanvasSceneState() { return canvasSceneState; }
 
   private:
     SystemState systemState = SystemState::MenuHome;
@@ -89,10 +89,10 @@ namespace Engine
     GameSelection userGameChoice = GameSelection::Demo;
     SceneSelection userSceneChoice = SceneSelection::Canvas;
 
-    Games::RecallGameState recallGameState;
-    Games::PhaseEvasionGameState phaseEvasionGameState;
-    Games::DemoGameState demoGameState;
+    Games::Recall::GameState recallGameState;
+    Games::PhaseEvasion::GameState phaseEvasionGameState;
+    Games::Demo::GameState demoGameState;
 
-    Scenes::CanvasSceneState canvasSceneState;
+    Scenes::Canvas::SceneState canvasSceneState;
   };
 }

include/games/demo/demo-core.h → include/games/demo/controller.h

@@ -2,14 +2,14 @@
 
 #include "core/context-manager.h"
 #include "engine/layer.h"
-#include "games/demo/demo-player.h"
+#include "games/demo/player.h"
 
-namespace Games
+namespace Games::Demo
 {
-  class DemoCore : public Engine::Layer
+  class Controller : public Engine::Layer
   {
   public:
-    DemoCore(Core::ContextManager *ctx) : Engine::Layer{}, contextManager{ctx}, player1{DemoPlayer{ctx}}, player2{DemoPlayer{ctx}}
+    Controller(SystemCore::ContextManager *ctx) : Engine::Layer{}, contextManager{ctx}, player1{Player{ctx}}, player2{Player{ctx}}
     {
       contextManager->stateManager.getDemoGameState().reset();
     }
@@ -21,9 +21,9 @@ namespace Games
     void incrementHighScore();
 
   private:
-    Core::ContextManager *contextManager;
-    DemoPlayer player1;
-    DemoPlayer player2;
+    SystemCore::ContextManager *contextManager;
+    Player player1;
+    Player player2;
     static constexpr float speed = 4.0f;
   };
 }

include/games/demo/demo-player.h → include/games/demo/player.h

@@ -3,17 +3,17 @@
 #include "core/context-manager.h"
 #include "player/player.h"
 
-namespace Games
+namespace Games::Demo
 {
-  class DemoPlayer : public Player::Player
+  class Player : public ::Player::Player
   {
   public:
-    DemoPlayer(Core::ContextManager *ctx) : contextManager{ctx}, Player::Player{ctx} {};
+    Player(SystemCore::ContextManager *ctx) : contextManager{ctx}, ::Player::Player{ctx} {};
     void updatePlayer1LedBuffer();
     void updatePlayer2LedBuffer();
 
   private:
-    Core::ContextManager *contextManager;
+    SystemCore::ContextManager *contextManager;
     static constexpr uint16_t width = 7;
   };
 }

include/games/demo/demo-state.h → include/games/demo/state.h

@@ -2,12 +2,12 @@
 
 #include <cstdint>
 
-namespace Games
+namespace Games::Demo
 {
-  class DemoGameState
+  class GameState
   {
   public:
-    DemoGameState() : highScore{0}, currentScore{0} {}
+    GameState() : highScore{0}, currentScore{0} {}
     void reset() { highScore = currentScore = 0; }
     uint16_t highScore;
     uint16_t currentScore;

include/games/phase-evasion/controller.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "engine/layer.h"
+#include "engine/timer.h"
+#include "core/context-manager.h"
+#include "games/phase-evasion/player.h"
+#include "games/phase-evasion/flare.h"
+#include "games/phase-evasion/flare-manager.h"
+
+namespace Games::PhaseEvasion
+{
+  class Controller : public Engine::Layer, private Engine::Timer
+  {
+  public:
+    Controller(SystemCore::ContextManager *ctx);
+    void nextEvent() override;
+    static constexpr uint16_t playerClearance = 20;
+
+  private:
+    SystemCore::ContextManager *contextManager;
+    GameState &state = contextManager->stateManager.getPhaseEvasionGameState();
+    Player player;
+    FlareManager flareManager;
+
+    void getUpdates();
+    void renderUserColor();
+    void renderFlare();
+    void checkCollision();
+    void checkGrowth();
+  };
+}

include/games/phase-evasion/flare-manager.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "games/phase-evasion/flare.h"
+
+namespace Games::PhaseEvasion
+{
+  class FlareManager : public Engine::Timer
+  {
+  public:
+    FlareManager() = default;
+    FlareManager(const FlareManager &) = delete;
+    FlareManager &operator=(const FlareManager &) = delete;
+
+    Flare &operator[](uint16_t index) { return flarePool[index]; }
+    const Flare &operator[](uint16_t index) const { return flarePool[index]; }
+
+    auto begin() { return flarePool.begin(); }
+    auto end() { return flarePool.end(); }
+    const auto begin() const { return flarePool.begin(); }
+    const auto end() const { return flarePool.end(); }
+
+    const size_t size() const;
+
+    void updatePositions();
+    void dispatch();
+
+  private:
+    std::array<Flare, 10> flarePool;
+  };
+}

include/games/phase-evasion/flare.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "esp_system.h"
+
+#include "common.h"
+
+#include "engine/timer.h"
+#include "core/configuration.h"
+#include "lights/color.h"
+
+namespace Games::PhaseEvasion
+{
+  class Flare : public Engine::Timer
+  {
+  public:
+    Flare() : active{false},
+              color{Lights::Color::WhiteSmoke},
+              speed{0.0f},
+              positionFloat{SystemCore::Configuration::numLeds + width} {};
+
+    static constexpr uint16_t width = 10;
+    void updatePosition();
+    uint16_t getPosition() const { return static_cast<uint16_t>(positionFloat); }
+
+    const Lights::Color getColor() const { return color; }
+    bool isActive() const { return active; }
+    void activate(Lights::Color color, float speed);
+    void deactivate();
+
+  private:
+    bool active;
+    Lights::Color color;
+    float speed;
+    float positionFloat;
+  };
+}