chore: remove libprintf

include/constants.hpp

@@ -0,0 +1,15 @@
+#pragma once
+/*
+ * A header file to store all the constants used in the project.
+ */
+#include <Arduino.h>
+#define LCD_I2C_ADDRESS 0x27
+#define LCD_COLS 20
+#define LCD_ROWS 4
+
+#define ACTION_INTERVAL 60000 // 1 minute
+
+#define MAXIMUM_STAT 100
+#define ANIMATION_FRAME_INTERVAL 1500 // Time in milliseconds between animation frames
+
+#define DEBOUNCE_DELAY 50 // Debounce delay in milliseconds for the joystick button

include/display.hpp

@@ -1,17 +1,22 @@
 #pragma once
 #include <Arduino.h>
 #include <LiquidCrystal_I2C.h>
+#include "constants.hpp"
 #include "menu.hpp"
+#include "pet.hpp"
 
 /*
  * A helper class to facilitate drawing on a HD44780 LCD display.
  */
 class Display {
   public:
-    Display(uint8_t addr = 0x27, uint8_t cols = 20, uint8_t rows = 4);
+    Display();
 
     void begin();
     void clear();
+    void drawPetStats(Pet& pet);
+    void drawPet(Pet& pet);
+    void drawBuffer(String buffer[]);
     void drawMenu(Menu& menu);
 
     LiquidCrystal_I2C& getLCD();

include/game.hpp

@@ -0,0 +1,36 @@
+#pragma once
+#include "joystick.hpp"
+#include "display.hpp"
+#include "menu.hpp"
+#include "pet.hpp"
+
+typedef struct {
+  Pet pet;
+
+  uint64_t lastActionTime;
+
+  bool isMenuOpen;
+  bool shouldClearDisplay;
+} GameState;
+
+class Game {
+  public:
+    Game();
+    void begin();
+    void update();
+    void render();
+
+  protected:
+    void forceUpdate(String reason);
+    void feed();
+    void play();
+    void sleep();
+    void clean();
+
+  private:
+    GameState state;
+    Joystick joystick;
+    Display display;
+    String* items;
+    Menu menu;
+};

include/joystick.hpp

@@ -1,5 +1,6 @@
 #pragma once
 #include <Arduino.h>
+#include "constants.hpp"
 
 /*
  * A helper class to read values from the KY-023 joystick module.
@@ -25,15 +26,27 @@ class Joystick {
     Joystick();
     double getX() const;
     double getY() const;
-    bool isPressed() const;
+    bool isPressed();
 
     JoystickDirection getDirection() const;
   private:
+    class Switch {
+      public:
+        Switch(uint8_t pin);
+        bool isPressed();
+      private:
+        uint8_t pin;
+        bool lastKnownState;
+        bool lastStableState;
+        uint64_t lastDebounceTime;
+    };
+
     uint8_t vrx;
     uint8_t vry;
-    uint8_t sw;
+    Switch sw;
+
+    uint8_t xOffset;
+    uint8_t yOffset;
 
-    const uint8_t xOffset = 13;
-    const uint8_t yOffset = 10;
     const uint8_t deadzone = 15; // Deadzone threshold to prevent jitter around the center position
 };

include/menu.hpp

@@ -1,22 +1,17 @@
 #pragma once
-#define MENU_ITEM_COUNT 4
 #include <Arduino.h>
+#include "constants.hpp"
 #include "joystick.hpp"
 
-typedef struct {
-  String name;
-  void (*action)();
-} Item;
-
 class Menu {
   public:
-    Menu(Item* items);
+    Menu();
-    void updateCurrentItem(JoystickDirection& direction);
+    void setItems(String* items);
-    void execute();
+    bool updateCurrentItem(JoystickDirection& direction);
 
-    Item& getItemAt(size_t index);
+    String& getItemAt(size_t index);
     size_t getCurrentItemIndex() const;
   private:
-    Item items[MENU_ITEM_COUNT];
+    String items[LCD_ROWS];
     int currentItem;
 };

include/pet.hpp

@@ -0,0 +1,31 @@
+#pragma once
+#include <Arduino.h>
+#include "constants.hpp"
+
+class Pet {
+  public:
+    Pet();
+    bool isAlive;
+
+    void updateHunger(int8_t delta);
+    void updateJoy(int8_t delta);
+    void updateEnergy(int8_t delta);
+    void updateCleanliness(int8_t delta);
+
+    int8_t getHunger() const;
+    int8_t getJoy() const;
+    int8_t getEnergy() const;
+    int8_t getCleanliness() const;
+    String getReasonForDeath() const;
+
+    byte getAnimationFrame();
+  private:
+    int8_t hunger;
+    int8_t joy;
+    int8_t energy;
+    int8_t cleanliness;
+    String reasonForDeath;
+
+    byte lastAnimationFrame;
+    uint64_t lastAnimationFrameTime;
+};

platformio.ini

@@ -18,5 +18,4 @@ monitor_speed = 9600
 
 ; External libraries
 lib_deps =
-    embeddedartistry/LibPrintf@1.2.13
     marcoschwartz/LiquidCrystal_I2C@1.1.4

src/display.cpp

@@ -1,28 +1,79 @@
 #include "display.hpp"
 
 // Initialize the LCD display with the specified number of columns and rows, using the I2C address.
-Display::Display(uint8_t addr, uint8_t cols, uint8_t rows) : lcd(addr, cols, rows) {}
+Display::Display() : lcd(LCD_I2C_ADDRESS, LCD_COLS, LCD_ROWS) {}
 
 void Display::begin() {
+  byte CUSTOM_CHAR_PET1[] = {
+    B00100,
+    B01110,
+    B11111,
+    B10101,
+    B11111,
+    B11111,
+    B10001,
+    B11111
+  };
+  byte CUSTOM_CHAR_PET2[] = {
+    B00100,
+    B01110,
+    B11111,
+    B10101,
+    B11111,
+    B10001,
+    B11011,
+    B11111
+  };
+
   lcd.init();
   lcd.backlight(); 
+
+  // Create a custom character for the pet
+  lcd.createChar(0, CUSTOM_CHAR_PET1);
+  lcd.createChar(1, CUSTOM_CHAR_PET2);
 }
 
 void Display::clear() {
   lcd.clear();
 }
 
+void Display::drawBuffer(String buffer[]) {
+  clear();
+  for (size_t i = 0; i < LCD_ROWS; i++) {
+    lcd.setCursor(0, i);
+    lcd.print(buffer[i].substring(0, LCD_COLS)); // Ensure we only print up to the number of columns
+  }
+}
+
+void Display::drawPetStats(Pet &pet) {
+  clear();
+
+  lcd.setCursor(0, 0);
+  lcd.print("Hunger: " + String(pet.getHunger()));
+  lcd.setCursor(0, 1);
+  lcd.print("Joy: " + String(pet.getJoy()));
+  lcd.setCursor(0, 2);
+  lcd.print("Energy: " + String(pet.getEnergy()));
+  lcd.setCursor(0, 3);
+  lcd.print("Cleanliness: " + String(pet.getCleanliness()));
+}
+
+void Display::drawPet(Pet &pet) {
+  lcd.setCursor(LCD_COLS - 2, LCD_ROWS / 2 - 1); // Position the pet
+  lcd.write(pet.getAnimationFrame()); // Draw the custom pet character
+}
+
 void Display::drawMenu(Menu &menu) {
   clear();
   size_t currentItemIndex = menu.getCurrentItemIndex();
-  for (size_t i = 0; i < MENU_ITEM_COUNT; i++) {
+  for (size_t i = 0; i < LCD_ROWS; i++) {
     lcd.setCursor(0, i);
-    Item& item = menu.getItemAt(i);
+    String item = menu.getItemAt(i);
 
     if (i == currentItemIndex) {
-      lcd.print("> " + item.name);
+      lcd.print(("> " + item).substring(0, LCD_COLS)); // Add a ">" to indicate the current item
     } else {
-      lcd.print("  " + item.name);
+      lcd.print(("  " + item).substring(0, LCD_COLS)); // Indent non-selected items
     }
   }
 }

src/game.cpp

@@ -0,0 +1,154 @@
+#include "game.hpp"
+
+Game::Game() : joystick(), display(), menu() {
+  state = (GameState) {
+    .pet = Pet(),
+    .lastActionTime = 0,
+    .isMenuOpen = false,
+    .shouldClearDisplay = true,
+  };
+
+  String items[] = {
+    "Feed",
+    "Play",
+    "Sleep",
+    "Clean"
+  };
+
+  menu.setItems(items);
+}
+
+void Game::begin() {
+  Serial.begin(9600);
+  while (!Serial) {
+    delay(10);
+  }
+  display.begin();
+}
+
+void Game::update() {
+  // If the pet is dead, we don't need to update its state
+  if (!state.pet.isAlive) {
+    return;
+  }
+
+  bool isPressed = joystick.isPressed();
+
+  // If the menu is open, we don't need to update the pet's state
+  if (state.isMenuOpen) {
+    JoystickDirection direction = joystick.getDirection();
+    if (menu.updateCurrentItem(direction)) {
+      forceUpdate("Menu navigation");
+    }
+
+    // If the joystick is pressed, execute the current menu item
+    if (isPressed) {
+      state.isMenuOpen = false;
+      // Based on the current menu item, perform the corresponding action
+      switch (menu.getCurrentItemIndex()) {
+        case 0:
+          feed();
+          break;
+        case 1:
+          play();
+          break;
+        case 2:
+          sleep();
+          break;
+        case 3:
+          clean();
+          break;
+      }
+      forceUpdate("Menu action");
+    }
+    return;
+  }
+
+  // If the joystick is pressed and the menu is not open, open the menu
+  if (isPressed) {
+    state.isMenuOpen = true;
+    forceUpdate("Opening menu");
+    return;
+  }
+
+  // Update the pet's stats based on the time elapsed since the last action
+  uint64_t currentTime = millis();
+  if (currentTime - state.lastActionTime >= ACTION_INTERVAL) {
+    state.pet.updateHunger(10);
+    state.pet.updateJoy(-5);
+    state.pet.updateEnergy(-5);
+    state.pet.updateCleanliness(-5);
+
+    state.lastActionTime = currentTime;
+    
+    forceUpdate("Time-based stat update");
+  }
+}
+
+void Game::render() {
+  // If the display doesn't need to be cleared, we can skip rendering
+  if (!state.shouldClearDisplay) {
+    // However, we still need to draw the pet if it's alive and
+    // we're not in the menu
+    if (state.pet.isAlive && !state.isMenuOpen) {
+      display.drawPet(state.pet);
+    }
+
+    return;
+  }
+
+  state.shouldClearDisplay = false;
+
+  if (state.isMenuOpen) {
+    display.drawMenu(menu);
+    Serial.println("Rendering menu");
+    return;
+  }
+
+  // If the pet is dead, display a message and return
+  if (!state.pet.isAlive) {
+    String buffer[LCD_ROWS] = {
+      "Your pet has died of",
+      state.pet.getReasonForDeath() + ".",
+      "Reset the device",
+      "to start over."
+    };
+
+    display.drawBuffer(buffer);
+    return;
+  }
+
+  // Render the pet's stats on the display
+  display.drawPetStats(state.pet);
+}
+
+void Game::forceUpdate(String reason) {
+  if (!state.shouldClearDisplay) {
+    Serial.println("Forcing update: " + reason);
+    state.shouldClearDisplay = true;
+  }
+}
+
+void Game::feed() {
+  if (state.pet.isAlive) {
+    state.pet.updateHunger(-20);
+  }
+}
+
+void Game::play() {
+  if (state.pet.isAlive) {
+    state.pet.updateJoy(20);
+  }
+}
+
+void Game::sleep() {
+  if (state.pet.isAlive) {
+    state.pet.updateEnergy(20);
+  }
+}
+
+void Game::clean() {
+  if (state.pet.isAlive) {
+    state.pet.updateCleanliness(20);
+  }
+}

src/joystick.cpp

@@ -1,10 +1,37 @@
 #include "joystick.hpp"
 
+Joystick::Switch::Switch(uint8_t pin) : pin(pin), lastKnownState(HIGH), lastStableState(HIGH), lastDebounceTime(0) {
+  pinMode(pin, INPUT_PULLUP); // Use internal pull-up resistor
+}
+
+bool Joystick::Switch::isPressed() {
+  bool state = digitalRead(pin);
+
+  // Check for state change and debounce
+  if (state != lastKnownState) {
+    lastDebounceTime = millis(); // Reset debounce timer
+    lastKnownState = state;
+  }
+
+  // If the state has been stable for longer than the debounce delay, update the stable state
+  if ((millis() - lastDebounceTime) > DEBOUNCE_DELAY) {
+    if (lastStableState != state) {
+      lastStableState = state; // Update stable state
+      return state == LOW; // Return true if the button is pressed (active LOW)
+    }
+  }
+
+  return false; // No change in button state
+}
+
 // Initialize the joystick pins in the constructor
-Joystick::Joystick() : vrx(A0), vry(A1), sw(4) {
+Joystick::Joystick() : vrx(A0), vry(A1), sw(Switch(4)) {
   pinMode(vrx, INPUT);
   pinMode(vry, INPUT);
-  pinMode(sw, INPUT_PULLUP);
+
+  // TODO: Calibrate the joystick by reading the center position and storing it as an offset
+  xOffset = 10;
+  yOffset = 13;
 }
 
 // Map the analog readings from the joystick to a range of -100 to 100 for both X and Y axes
@@ -17,8 +44,8 @@ double Joystick::getY() const {
 }
 
 // Check if the joystick button is pressed (active LOW)
-bool Joystick::isPressed() const {
+bool Joystick::isPressed() {
-  return digitalRead(sw) == LOW;
+  return sw.isPressed();
 }
 
 // Determine the direction of the joystick based on the X and Y values, considering a deadzone to prevent jitter

src/main.cpp

@@ -1,40 +1,13 @@
-#include <Arduino.h>
+#include "game.hpp"
-#include <LibPrintf.h>
-#include "joystick.hpp"
-#include "display.hpp"
 
-Joystick joystick;
+Game game;
-Display display;
-
-Item items[MENU_ITEM_COUNT] = {
-  {"Feed", []() { Serial.println("Feeding..."); }},
-  {"Play", []() { Serial.println("Playing..."); }},
-  {"Sleep", []() { Serial.println("Sleeping..."); }},
-  {"Clean", []() { Serial.println("Cleaning..."); }}
-};
-Menu menu(items);
 
 void setup() {
-  Serial.begin(9600);
+  game.begin();
-  while (!Serial) {
-    delay(10);
-  }
-
-  display.begin();
-  pinMode(LED_BUILTIN, OUTPUT);
-  display.drawMenu(menu);
 }
 
 void loop() {
-  JoystickDirection direction = joystick.getDirection();
+  game.update();
-  if (direction != JoystickDirection::CENTER) {
+  delay(100); // Small delay to prevent overwhelming the CPU
-    menu.updateCurrentItem(direction);
+  game.render();
-    display.drawMenu(menu);
-  }
-
-  if (joystick.isPressed()) {
-    menu.execute();
-  }
-
-  delay(250);
 }

src/menu.cpp

@@ -1,31 +1,28 @@
 #include "menu.hpp"
 
-Menu::Menu(Item* items) : currentItem(0) {
+Menu::Menu() : currentItem(0) {}
-  for (int i = 0; i < MENU_ITEM_COUNT; i++) {
+
+void Menu::setItems(String* items) {
+  this->currentItem = 0;
+  for (int i = 0; i < LCD_ROWS; i++) {
     this->items[i] = items[i];
   }
 }
 
-void Menu::updateCurrentItem(JoystickDirection &direction) {
+bool Menu::updateCurrentItem(JoystickDirection &direction) {
   switch (direction) {
     case JoystickDirection::UP:
-      currentItem = (currentItem - 1 + MENU_ITEM_COUNT) % MENU_ITEM_COUNT;
+      currentItem = (currentItem - 1 + LCD_ROWS) % LCD_ROWS;
-      break;
+      return true;
     case JoystickDirection::DOWN:
-      currentItem = (currentItem + 1) % MENU_ITEM_COUNT;
+      currentItem = (currentItem + 1) % LCD_ROWS;
-      break;
+      return true;
     default:
-      break;
+      return false;
   }
 }
 
-void Menu::execute() {
+String& Menu::getItemAt(size_t index) {
-  if (items[currentItem].action) {
-    items[currentItem].action();
-  }
-}
-
-Item& Menu::getItemAt(size_t index) {
   return items[index];
 }
 

src/pet.cpp

@@ -0,0 +1,103 @@
+#include "pet.hpp"
+
+Pet::Pet() :
+  isAlive(true), 
+  hunger(0), 
+  joy(100), 
+  energy(100), 
+  cleanliness(100), 
+  reasonForDeath(""), 
+  lastAnimationFrame(0),
+  lastAnimationFrameTime(0)
+{}
+
+void Pet::updateHunger(int8_t delta) {
+  hunger += delta;
+
+  if (hunger < 0) {
+    isAlive = false;
+    reasonForDeath = "overfeeding";
+    return;
+  }
+
+  if (hunger > MAXIMUM_STAT) {
+    isAlive = false;
+    reasonForDeath = "starvation";
+  }
+}
+
+void Pet::updateJoy(int8_t delta) {
+  joy += delta;
+
+  if (joy < 0) {
+    isAlive = false;
+    reasonForDeath = "depression";
+    return;
+  }
+
+  if (joy > MAXIMUM_STAT) {
+    isAlive = false;
+    reasonForDeath = "overstimulation";
+  }
+}
+
+void Pet::updateEnergy(int8_t delta) {
+  energy += delta;
+
+  if (energy < 0) {
+    isAlive = false;
+    reasonForDeath = "exhaustion";
+    return;
+  }
+
+  if (energy > MAXIMUM_STAT) {
+    isAlive = false;
+    reasonForDeath = "overresting";
+  }
+}
+
+void Pet::updateCleanliness(int8_t delta) {
+  cleanliness += delta;
+
+  if (cleanliness < 0) {
+    isAlive = false;
+    reasonForDeath = "disease";
+    return;
+  }
+
+  if (cleanliness > MAXIMUM_STAT) {
+    isAlive = false;
+    reasonForDeath = "overcleaning";
+  }
+}
+
+int8_t Pet::getHunger() const {
+  return hunger;
+}
+
+int8_t Pet::getJoy() const {
+  return joy;
+}
+
+int8_t Pet::getEnergy() const {
+  return energy;
+}
+
+int8_t Pet::getCleanliness() const {
+  return cleanliness;
+}
+
+String Pet::getReasonForDeath() const {
+  return reasonForDeath;
+}
+
+byte Pet::getAnimationFrame() {
+  uint64_t currentTime = millis();
+
+  if (currentTime - lastAnimationFrameTime >= ANIMATION_FRAME_INTERVAL) {
+    lastAnimationFrameTime = currentTime;
+    lastAnimationFrame = (lastAnimationFrame + 1) % 2; // Alternate between frame 0 and 1
+  }
+
+  return lastAnimationFrame;
+}