Initial commit

src/menu/care_mistake_screen.cpp

@@ -0,0 +1,42 @@
+#include "menu.h"
+#include "buttons/buttons.h"
+#include "animations/animations.h"
+#include "display/display.h"
+#include "defs/chara_data.h"
+#include "draw/draw.h"
+
+uint64_t lastBeepTime = esp_timer_get_time();
+uint8_t beepCounter = 0;
+
+void menu_careMistakeScreen(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite, struct SpriteData* spriteData, struct SpriteData* uiSpritesBig) {
+    uint64_t currentTime = esp_timer_get_time();
+    uint8_t pressedButtons = buttons_getPressedButtons();
+
+    if (currentTime - lastBeepTime > ANIMATION_THRESHOLD_TIME_US * 2 && beepCounter < 10) {
+        tone(SPK_PIN, 2500, 100);
+        tone(SPK_PIN, 5000, 100);
+
+        lastBeepTime = currentTime;
+
+        beepCounter++;
+    }
+    
+    if (currentTime - lastUpdateTime > ANIMATION_THRESHOLD_TIME_US) {
+        draw_drawBackground(composite, bg, 90, 90, 3);
+
+        tft_clearBuffer(sprite, TFT_TRANSPARENT);
+        animate_performAttentionAnimation(composite, sprite, spriteData);
+    
+        tft_clearBuffer(sprite, TFT_TRANSPARENT);
+        menu_uiOverlay(composite, sprite, uiSpritesBig);
+            
+        lastUpdateTime = currentTime;
+    }
+    
+    if (pressedButtons != 0) {
+        screenKey = IDLE_SCREEN;
+        beepCounter = 0;
+    }
+
+    tft_drawBuffer(composite);
+}

src/menu/clock_screen.cpp

@@ -0,0 +1,77 @@
+#include "menu.h"
+#include "defs/defs.h"
+#include "draw/draw.h"
+#include "display/display.h"
+#include "buttons/buttons.h"
+#include "vpet/vpet.h"
+
+void menu_drawClock(TFT_eSprite &composite, TFT_eSprite &bg, int menuOption) {
+    uint8_t pressedButtons = buttons_getPressedButtons();
+    switch (pressedButtons) {
+        case 4:
+        screenKey = IDLE_SCREEN;
+        break;
+        
+        default:
+        break;
+    }
+    
+    char hourBuffer[6];
+    
+    draw_drawBackground(composite, bg, 90, 90, 3);
+    
+    snprintf(hourBuffer, 6, "%02d:%02d", timeInfo.tm_hour, timeInfo.tm_min);
+    composite.setTextSize(4); 
+    composite.drawString(hourBuffer, 40, 90);
+
+    sniprintf(hourBuffer, 3, "%02d", timeInfo.tm_sec);
+    composite.setTextSize(2);
+    composite.drawString(hourBuffer, 170, 104);
+
+    tft_drawBuffer(composite);
+
+}
+
+void menu_drawClockEdit(TFT_eSprite &composite, TFT_eSprite &bg) {
+    char textBuffer[6];
+
+    static int clockHourCount = 0;
+    static int clockMinuteCount = 0;
+
+    uint8_t pressedButtons = buttons_getPressedButtons();
+    lastPressedButtonTime = esp_timer_get_time();
+
+    switch (pressedButtons) {
+        case 8:
+            clockHourCount = (clockHourCount + 1) % 24;
+            break;
+
+        case 4:
+            clockMinuteCount = (clockMinuteCount + 1) % 60;
+            break;
+        
+        case 2:
+            rtc.setTime(0, clockMinuteCount, clockHourCount, 1, 11, 2024);
+            getLocalTime(&timeInfo, 50);
+            dayUnixTime = mktime(&timeInfo) % 86400;
+
+            screenKey = CLOCK_SCREEN;
+            onActionTimerDelta();
+            vpet_initTimer();
+
+            break; 
+
+        default:
+            break;
+    }
+    
+    draw_drawBackground(composite, bg, 90, 90, 3);
+
+    snprintf(textBuffer, 6, "%02d:%02d", clockHourCount, clockMinuteCount);
+
+    composite.setTextSize(4);
+    composite.drawString(textBuffer, 40, 90);
+    composite.drawString("SET", 40, 122);
+
+    tft_drawBuffer(composite);
+}

src/menu/feeding_screen.cpp

@@ -0,0 +1,49 @@
+#include "menu.h"
+#include "animations/animations.h"
+#include "buttons/buttons.h"
+#include "draw/draw.h"
+#include "display/display.h"
+
+void menu_feedingScreen(
+    TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &charaSprite, 
+    struct SpriteData* uiSpriteData, struct SpriteData* charaSpriteData, uint8_t item
+) {
+    static int currentAnimationFrame = 0;
+    
+    uint64_t currentTime = esp_timer_get_time();
+    uint8_t pressedButtons = buttons_getPressedButtons();
+    switch (pressedButtons) {
+        case 8: 
+        case 4:
+            screenKey = FOOD_SCREEN;
+            currentAnimationFrame = 0;
+            lastPressedButtonTime = currentTime;
+            submenuKey = -1;
+            break;
+        
+        default:
+            break;
+    }
+
+    if (currentTime - lastUpdateTime > ANIMATION_THRESHOLD_TIME_US) {
+        draw_drawBackground(composite, bg, 90, 90, 3);
+
+        tft_clearBuffer(charaSprite, TFT_TRANSPARENT);
+        animate_performEatingAnimation(composite, charaSprite, charaSpriteData);
+
+        tft_clearBuffer(charaSprite, TFT_TRANSPARENT);
+        draw_drawSprite(composite, charaSprite, 24, 120, uiSpriteData, item, 6);
+
+        lastUpdateTime = currentTime;
+        currentAnimationFrame++;
+    }
+
+    if (currentAnimationFrame > 6) {
+        screenKey = FOOD_SCREEN;
+        lastPressedButtonTime = currentTime;
+        currentAnimationFrame = 0;
+        submenuKey = -1;
+    } 
+
+    tft_drawBuffer(composite);
+}

src/menu/food_select_screen.cpp

@@ -0,0 +1,83 @@
+#include "menu.h"
+#include "display/display.h"
+#include "draw/draw.h"
+#include "buttons/buttons.h"
+#include "defs/chara_data.h"
+#include "vpet/vpet.h"
+
+void menu_foodScreen(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &mainChara, struct SpriteData* spriteData) {
+    if (charaData.sleepy) {
+        tone(SPK_PIN, BEEP_FREQ_HZ, BEEP_LEN_MS);
+        delay(100);
+        tone(SPK_PIN, BEEP_FREQ_HZ, BEEP_LEN_MS);
+        screenKey = MENU_SCREEN;
+        
+        return;
+    }
+
+    static uint8_t arrowPosition = 0;
+    
+    uint8_t pressedButtons = buttons_getPressedButtons();
+    switch (pressedButtons) {
+        case 8:
+            arrowPosition = (arrowPosition + 1) % 2;
+            break;
+
+        case 2:
+            screenKey = MENU_SCREEN;
+            break;
+        
+        default:
+            break;
+    }
+    
+    if (pressedButtons == 4) {
+        switch(arrowPosition) {
+            case 0:
+                if (charaData.hunger < 8) {
+                    charaData.weight++;
+                    charaData.hunger++;
+                    screenKey = FEEDING_SCREEN;
+                    submenuKey = FOOD_ICON;
+                } else {
+                    screenKey = REFUSING_SCREEN;
+                }
+                break;
+
+            case 1:
+                if (charaData.strength < 8) {
+                    charaData.strength++;
+                    charaData.weight += 2;
+                    screenKey = FEEDING_SCREEN;
+                    submenuKey = PILL_ICON;
+                } else {
+                    screenKey = REFUSING_SCREEN;
+                }
+                break;
+            
+            default:
+                break;
+        }
+
+        vpet_computeCallLight();
+    }
+
+    composite.setTextSize(4);
+
+    draw_drawBackground(composite, bg, 90, 90, 3);
+    menu_foodScreen_drawEntry(composite, mainChara, spriteData, 0, FOOD_ICON, "Meat");
+    menu_foodScreen_drawEntry(composite, mainChara, spriteData, 1, PILL_ICON, "Pill");
+    
+    draw_drawSprite(composite, mainChara, 5, (arrowPosition * 34) + 5, spriteData, ARROW_ICON, 4);
+
+    tft_drawBuffer(composite);
+}
+
+void menu_foodScreen_drawEntry(
+    TFT_eSprite &composite, TFT_eSprite &mainChara, struct SpriteData* spriteData, 
+    uint8_t entryId, uint8_t spriteNumber, const char* textEntry
+) {
+    tft_clearBuffer(mainChara, TFT_TRANSPARENT);
+    draw_drawSprite(composite, mainChara, 45, (entryId * 34) + 5, spriteData, spriteNumber, 4);
+    composite.drawString(textEntry, 80, (entryId * 34) + 5);
+}

src/menu/happy_screen.cpp

@@ -0,0 +1,46 @@
+#include "menu.h"
+#include "defs/defs.h"
+#include "defs/sprite_data.h"
+#include "display/display.h"
+#include "draw/draw.h"
+#include "animations/animations.h"
+
+void menu_drawHappyScreen(
+    TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite,
+    struct SpriteData* spriteData, struct SpriteData* smallUiElements
+) {
+    uint8_t frameCounter = 0;
+    
+    while (true) {
+        uint64_t currentTime = esp_timer_get_time();
+        if (currentTime - lastUpdateTime > ANIMATION_THRESHOLD_TIME_US) {
+            if (frameCounter > 3) {
+                screenKey = IDLE_SCREEN; // TODO: Change for while battling
+                menuKey = STATUS_SCREEN;
+
+                return;
+            }
+
+            draw_drawBackground(composite, bg, 90, 90, 3);
+
+            tft_clearBuffer(sprite, TFT_TRANSPARENT);
+            animate_performHappyAnimation(composite, sprite, spriteData);
+            
+            if (frameCounter % 2 == 0) {
+                tone(SPK_PIN, 7500, 50);
+                tone(SPK_PIN, 5000, 50);
+                tone(SPK_PIN, 2500, 50);
+                tone(SPK_PIN, 1000, 50);
+
+                tft_clearBuffer(sprite, TFT_TRANSPARENT);
+                draw_drawSprite(composite, sprite, 18, 72, smallUiElements, FIREWORKS_ICON, 6);
+                draw_drawSprite(composite, sprite, 174, 72, smallUiElements, FIREWORKS_ICON, 6);
+            }
+
+            frameCounter++;            
+            lastUpdateTime = currentTime;
+        }
+        
+        tft_drawBuffer(composite);
+    }
+}

src/menu/idle_screen.cpp

@@ -0,0 +1,54 @@
+#include "menu.h"
+#include "draw/draw.h"
+#include "defs/defs.h"
+#include "display/display.h"
+#include "buttons/buttons.h"
+#include "animations/animations.h"
+#include "defs/chara_data.h"
+
+uint64_t lastUpdateTime = esp_timer_get_time();
+
+void menu_drawIdleScreen(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite, struct SpriteData* spriteData, struct SpriteData* bigUiElements, struct SpriteData* smallUiElements) {
+    if (charaData.sleepy && !charaData.asleep) {
+        screenKey = SLEEPY_SCREEN;
+        return;
+    } else if ((charaData.sleepy && charaData.asleep) || charaData.asleep) {
+        screenKey = SLEEP_SCREEN;
+        return;
+    }
+
+    uint8_t pressedButtons = buttons_getPressedButtons();
+    
+    switch (pressedButtons) {
+        case 8:
+            screenKey = MENU_SCREEN;
+            menuKey = 0;
+            break;
+        
+        case 4:
+            screenKey = CLOCK_SCREEN;
+            break;
+        
+        default:
+            break;
+    }
+
+    uint64_t currentTime = esp_timer_get_time();
+
+    if (currentTime - lastUpdateTime > ANIMATION_THRESHOLD_TIME_US) {
+        draw_drawBackground(composite, bg, 90, 90, 3);
+        
+        tft_clearBuffer(sprite, TFT_TRANSPARENT);
+        uint8_t offsetX = menu_poopOverlay(composite, sprite, smallUiElements);
+        
+        tft_clearBuffer(sprite, TFT_TRANSPARENT);
+        animate_performAnimation(composite, sprite, spriteData, offsetX);
+        
+        tft_clearBuffer(sprite, TFT_TRANSPARENT);
+        menu_uiOverlay(composite, sprite, bigUiElements);
+            
+        lastUpdateTime = currentTime;
+    }
+    
+    tft_drawBuffer(composite);
+}

src/menu/menu.h

@@ -0,0 +1,44 @@
+#ifndef MENU_H
+#define MENU_H
+
+#include <TFT_eSPI.h>
+#include "defs/defs.h"
+
+void menu_drawCurrentMenuOption(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &icon, struct SpriteData* spriteData);
+void menu_drawClock(TFT_eSprite &composite, TFT_eSprite &bg, int menuOption);
+void menu_drawClockEdit(TFT_eSprite &composite, TFT_eSprite &bg);
+void menu_drawTitle(TFT_eSprite &composite, TFT_eSprite &bg);
+void menu_drawIdleScreen(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite, struct SpriteData* spriteData, struct SpriteData* bigUiElements, struct SpriteData* smallUiElements);
+void menu_offScreen(TFT_eSprite &buffer);
+void menu_statusScreen(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite, struct SpriteData* spriteData, struct CharacterData* charaData);
+void menu_statusScreen_drawStat(TFT_eSprite &composite, TFT_eSprite &sprite, struct SpriteData* spriteData, int x, int y, const char* text, uint8_t statValue);
+void menu_timerFinishedScreen(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite, struct SpriteData* spriteData);
+void menu_uiOverlay(TFT_eSprite &composite, TFT_eSprite &charSprite, struct SpriteData* uiElements);
+void menu_foodScreen(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &mainChara, struct SpriteData* spriteData);
+void menu_foodScreen_drawEntry(
+    TFT_eSprite &composite, TFT_eSprite &mainChara, struct SpriteData* spriteData, 
+    uint8_t entryId, uint8_t spriteNumber, const char* textEntry
+);
+void menu_feedingScreen(
+    TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &charaSprite, 
+    struct SpriteData* uiSpriteData, struct SpriteData* charaSpriteData, uint8_t item
+);
+void menu_refuseScreen(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &mainChara, struct SpriteData* spriteData);
+void menu_sleepyScreen(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite, struct SpriteData* charaSprites, struct SpriteData* uiSprites);
+void menu_careMistakeScreen(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite, struct SpriteData* spriteData, struct SpriteData* uiSpritesBig);
+void menu_sleepingScreen(
+    TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite, 
+    struct SpriteData* mainCharaData, struct SpriteData* bigUiElements, struct SpriteData* smallUIElements
+);
+void menu_poopScreen(
+    TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite, 
+    struct SpriteData* spriteData, struct SpriteData* smallUiElements, struct SpriteData* bigUiElements
+);
+uint8_t menu_poopOverlay(TFT_eSprite &composite, TFT_eSprite &sprite, struct SpriteData* smallUiElements);
+void menu_clearPoopScreen(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite, struct SpriteData* spriteData, struct SpriteData* bigUiElements, struct SpriteData* smallUiElements);
+void menu_drawHappyScreen(
+    TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite,
+    struct SpriteData* spriteData, struct SpriteData* smallUiElements
+);
+
+#endif

src/menu/menu_screen.cpp

@@ -0,0 +1,109 @@
+#include "menu.h"
+#include "display/display.h"
+#include "draw/draw.h"
+#include "defs/defs.h"
+#include "defs/sprite_data.h"
+#include "defs/chara_data.h"
+#include "buttons/buttons.h"
+#include "vpet/vpet.h"
+#include <string.h>
+
+const int textXPos = 10;
+const int textYPos = 180;
+
+void menu_drawCurrentMenuOption(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &icon, struct SpriteData* spriteData) {
+    draw_drawBackground(composite, bg, 90, 90, 3);
+
+    uint8_t pressedButtons = buttons_getPressedButtons();
+
+    switch (pressedButtons) {
+        case 8:
+            menuKey++;
+            break;
+
+        case 2:
+            screenKey = IDLE_SCREEN;
+            menuKey = STATUS_SCREEN_MENU;
+            return;
+            break;
+        
+        default:
+            break;
+    }
+
+    if (pressedButtons == 4) {
+        switch (menuKey) {
+            case STATUS_SCREEN_MENU:
+                screenKey = STATUS_SCREEN;
+                break;
+                
+            case FOOD_SCREEN_MENU:
+                screenKey = FOOD_SCREEN;
+                break;
+
+            case SLEEP_SCREEN_MENU:
+                charaData.asleep = true;
+                vpet_computeCallLight();
+                menuKey = STATUS_SCREEN;
+                screenKey = SLEEP_SCREEN;
+                break;
+
+            case POOP_SCREEN_MENU:
+                menuKey = STATUS_SCREEN;
+                screenKey = CLEAR_POOP_SCREEN;
+                return;
+                break;
+
+            default:
+                break;
+        }
+        return;
+    }
+
+    composite.setTextSize(4);
+    draw_drawSpriteCentered(composite, icon, spriteData, menuKey % 8, 6);
+
+    switch(menuKey % 9) {
+        case STATUS_SCREEN_MENU:
+            tft_drawCenteredText(composite, "Status", 4, textYPos);
+            break;
+
+        case FOOD_SCREEN_MENU:
+            tft_drawCenteredText(composite, "Food", 4, textYPos);
+            break;
+
+        case TRAIN_SCREEN_MENU:
+            tft_drawCenteredText(composite, "Train", 4, textYPos);
+            break;
+            
+        case BATTLE_SCREEN_MENU:
+            tft_drawCenteredText(composite, "Battle", 4, textYPos);
+            break;
+
+        case POOP_SCREEN_MENU:
+            tft_drawCenteredText(composite, "Cleanup", 4, textYPos);
+            break;
+
+        case MEDICAL_SCREEN_MENU:
+            tft_drawCenteredText(composite, "Medical", 4, textYPos);
+            break;
+
+        case SLEEP_SCREEN_MENU:
+            tft_drawCenteredText(composite, "Sleep", 4, textYPos);
+            break;
+            
+        case SETTINGS_SCREEN_MENU:
+            tft_drawCenteredText(composite, "Settings", 4, textYPos);
+            break;
+            
+        case 8:
+            menuKey = 0;
+            screenKey = IDLE_SCREEN;
+            return;
+            break;
+    }
+
+    menu_uiOverlay(composite, icon, spriteData);
+
+    tft_drawBuffer(composite);
+}

src/menu/off_screen.cpp

@@ -0,0 +1,13 @@
+#include "menu.h"
+#include "defs/defs.h"
+#include "buttons/buttons.h"
+#include "display/display.h"
+
+void menu_offScreen(TFT_eSprite &buffer) {
+    uint8_t buttons = buttons_getPressedButtons();
+    if (buttons != 0) {
+        tft_drawBuffer(buffer);
+        digitalWrite(BL_PIN, HIGH);
+        screenKey = IDLE_SCREEN;
+    }
+}

src/menu/poop_clean.cpp

@@ -0,0 +1,28 @@
+#include "menu.h"
+#include "draw/draw.h"
+#include "display/display.h"
+#include "defs/defs.h"
+#include "defs/chara_data.h"
+#include "defs/sprite_data.h"
+
+void menu_clearPoopScreen(
+    TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite, struct SpriteData* spriteData, struct SpriteData* bigUiElements, struct SpriteData* smallUiElements
+) {
+    int cleanerXPos = 174;
+
+    menu_drawIdleScreen(composite, bg, sprite, spriteData, bigUiElements, smallUiElements);
+    
+    tft_clearBuffer(sprite, TFT_TRANSPARENT);
+    while (cleanerXPos > 18) {
+        draw_drawSprite(composite, sprite, cleanerXPos, 72, smallUiElements, CLEANER_ICON, 6);
+        draw_drawSprite(composite, sprite, cleanerXPos, 120, smallUiElements, CLEANER_ICON, 6);
+        tft_drawBuffer(composite);
+        cleanerXPos -= 6;
+        delay(50);
+    }
+
+    screenKey = HAPPY_SCREEN;
+    charaData.poopNumber = 0;
+
+    return;
+}

src/menu/poop_overlay.cpp

@@ -0,0 +1,23 @@
+#include "menu.h"
+#include "draw/draw.h"
+#include "defs/defs.h"
+#include "defs/sprite_data.h"
+#include "defs/chara_data.h"
+#include "display/display.h"
+
+uint8_t menu_poopOverlay(TFT_eSprite &composite, TFT_eSprite &sprite, struct SpriteData* smallUiElements) {
+    static bool poopFlip = false;
+    const uint8_t poopStartY = 120;
+    uint8_t poopStartX = 174;
+    bool poopTop = false;
+    
+    for (int i = 0; i < charaData.poopNumber; i++) {
+        draw_drawSprite(composite, sprite, poopStartX, poopStartY - (48 * poopTop), smallUiElements, POOP_ICON, 6, poopFlip);
+        poopStartX -= (i % 2) * 48;
+        poopTop = !poopTop;
+    }
+
+    poopFlip = !poopFlip;
+
+    return 222 - (poopStartX + ((charaData.poopNumber % 2 == 0) * 48));
+}

src/menu/poop_screen.cpp

@@ -0,0 +1,81 @@
+#include "menu.h"
+#include "draw/draw.h"
+#include "animations/animations.h"
+#include "display/display.h"
+#include "defs/defs.h"
+#include "defs/chara_data.h"
+#include "defs/sprite_data.h"
+
+void menu_poopScreen(
+    TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite, 
+    struct SpriteData* spriteData, struct SpriteData* smallUiElements, struct SpriteData* bigUiElements
+) {
+    uint8_t animationFrame = 0;
+    bool animationPosition = 0;
+
+    bool beepedAlready = false;
+
+    while (1) {
+        uint64_t currentTime = esp_timer_get_time();
+
+        if (currentTime - lastUpdateTime > ANIMATION_THRESHOLD_TIME_US && animationFrame < 4) {
+            draw_drawBackground(composite, bg, 90, 90, 3);
+    
+            tft_clearBuffer(sprite, TFT_TRANSPARENT);
+            draw_drawSprite(composite, sprite, 72 + (animationPosition * 6), 72, spriteData, 6, 6);
+
+            tft_clearBuffer(sprite, TFT_TRANSPARENT);
+            menu_uiOverlay(composite, sprite, bigUiElements);
+            
+            animationFrame++;
+            animationPosition = !animationPosition;
+
+            lastUpdateTime = currentTime;
+
+        } else if (currentTime - lastUpdateTime > ANIMATION_THRESHOLD_TIME_US && animationFrame < 6) {
+            if (!beepedAlready) {
+                tone(SPK_PIN, 2500, 50);
+                tone(SPK_PIN, 5000, 50);
+                tone(SPK_PIN, 2500, 50);
+                tone(SPK_PIN, 5000, 50);
+
+                beepedAlready = true;
+            }
+
+            draw_drawBackground(composite, bg, 90, 90, 3);
+    
+            tft_clearBuffer(sprite, TFT_TRANSPARENT);
+            draw_drawSprite(composite, sprite, 174, 120, smallUiElements, POOP_ICON, 6);
+            
+            tft_clearBuffer(sprite, TFT_TRANSPARENT);
+            menu_uiOverlay(composite, sprite, bigUiElements);
+
+            tft_clearBuffer(sprite, TFT_TRANSPARENT);
+            draw_drawSprite(composite, sprite, 72, 72, spriteData, 7, 6);
+    
+            animationFrame++;
+            animationPosition = !animationPosition;
+
+            lastUpdateTime = currentTime;
+
+        } else if (animationFrame >= 6) {
+            if (        
+                (charaData.hunger == 0 && !charaData.hungerCareMistakeObtained) || 
+                (charaData.strength == 0 && !charaData.strengthCareMistakeObtained) || 
+                (charaData.sleepy && !charaData.asleep && !charaData.sleepCareMistakeObtained)
+            ) { 
+                screenKey = CARE_MISTAKE_SCREEN;
+            } else  {
+                screenKey = IDLE_SCREEN;
+            }
+            
+            menuKey = 0;
+            animationFrame = 0;
+            animationPosition = 0;
+
+            break;
+        }
+
+        tft_drawBuffer(composite);
+    }
+}

src/menu/refuse_screen.cpp

@@ -0,0 +1,50 @@
+#include "menu.h"
+#include "buttons/buttons.h"
+#include "draw/draw.h"
+#include "display/display.h"
+#include "defs/defs.h"
+#include "defs/sprite_data.h"
+#include "animations/animations.h"
+
+void menu_refuseScreen(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &mainChara, struct SpriteData* spriteData) {
+    static uint8_t currentAnimationFrame = 0;
+    static bool soundPlayed = false;
+
+    uint64_t currentTime = esp_timer_get_time();
+    uint8_t pressedButtons = buttons_getPressedButtons();
+    switch (pressedButtons) {
+        case 8:
+        case 4:
+            currentAnimationFrame = 0;
+            screenKey = FOOD_SCREEN;
+            soundPlayed = false;
+            return;
+            break;
+    
+        default:
+            break;
+    }
+
+    if (currentTime - lastUpdateTime > ANIMATION_THRESHOLD_TIME_US) {
+        draw_drawBackground(composite, bg, 90, 90, 3);
+        animate_performRefuseAnimation(composite, mainChara, spriteData);
+
+        lastUpdateTime = currentTime;
+        currentAnimationFrame++;
+    }
+
+    if (!soundPlayed) {
+        tone(SPK_PIN, 3000, 100);
+        tone(SPK_PIN, 1000, 100);
+
+        soundPlayed = true;
+    }
+
+    if (currentAnimationFrame > 4) {
+        currentAnimationFrame = 0;
+        soundPlayed = false;
+        screenKey = IDLE_SCREEN;
+    }
+
+    tft_drawBuffer(composite);
+}

src/menu/sleep_screen.cpp

@@ -0,0 +1,57 @@
+#include "menu.h"
+#include "draw/draw.h"
+#include "display/display.h"
+#include "defs/defs.h"
+#include "buttons/buttons.h"
+#include "animations/animations.h"
+#include "defs/chara_data.h"
+
+void menu_sleepyScreen(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite, struct SpriteData* charaSprites, struct SpriteData* uiSprites) {
+    if (!charaData.asleep && !charaData.sleepy) {
+        screenKey = IDLE_SCREEN;
+        return;
+    } else if (charaData.asleep && charaData.sleepy) {
+        screenKey = SLEEP_SCREEN;
+        return;
+    }
+    
+    uint64_t currentTime = esp_timer_get_time();
+    uint8_t pressedButtons = buttons_getPressedButtons();
+    switch (pressedButtons) {
+        case 8: 
+            screenKey = MENU_SCREEN;
+            break;
+        case 4:
+            screenKey = CLOCK_SCREEN;
+            break;
+        
+        default:
+            break;
+    }
+
+    if (currentTime - lastUpdateTime > ANIMATION_SLEEPY_THRESHOLD_TIME_US) {
+        draw_drawBackground(composite, bg, 90, 90, 3);
+
+        tft_clearBuffer(sprite, TFT_TRANSPARENT);
+        animate_performSleepyAnimation(composite, sprite, charaSprites);
+        
+        tft_clearBuffer(sprite, TFT_TRANSPARENT);
+        menu_uiOverlay(composite, sprite, uiSprites);
+
+        tft_clearBuffer(sprite, TFT_TRANSPARENT);
+        menu_uiOverlay(composite, sprite, uiSprites);
+
+        lastUpdateTime = currentTime;
+    }
+
+    if (currentTime - lastBeepTime > ANIMATION_THRESHOLD_TIME_US * 2 && beepCounter < 10) {
+        tone(SPK_PIN, 2500, 100);
+        tone(SPK_PIN, 5000, 100);
+
+        lastBeepTime = currentTime;
+
+        beepCounter++;
+    }
+
+    tft_drawBuffer(composite);
+}

src/menu/sleeping_screen.cpp

@@ -0,0 +1,57 @@
+#include "menu.h"
+#include "defs/defs.h"
+#include "draw/draw.h"
+#include "display/display.h"
+#include "buttons/buttons.h"
+#include "animations/animations.h"
+#include "defs/chara_data.h"
+
+void menu_sleepingScreen(
+    TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite, 
+    struct SpriteData* mainCharaData, struct SpriteData* bigUiElements, struct SpriteData* smallUIElements
+) {
+    if (charaData.sleepy && !charaData.asleep) {
+        screenKey = SLEEPY_SCREEN;
+        return;
+    } else if (!charaData.sleepy && !charaData.asleep) {
+        screenKey = IDLE_SCREEN;
+        return;
+    }
+
+    uint64_t currentTime = esp_timer_get_time();
+    static uint8_t frameCounter = 0;
+
+    uint8_t buttonsPressed = buttons_getPressedButtons();
+    switch (buttonsPressed) {
+        case 8:
+            screenKey = MENU_SCREEN;
+            break;
+
+        case 4:
+            screenKey = CLOCK_SCREEN;
+            break;
+
+        default:
+            break;
+    }
+
+    if (currentTime - lastUpdateTime > ANIMATION_SLEEPY_THRESHOLD_TIME_US) {
+        draw_drawBackground(composite, bg, 90, 90, 3);
+        
+        tft_clearBuffer(sprite, TFT_TRANSPARENT);
+        animate_performSleepyAnimation(composite, sprite, mainCharaData);
+
+        tft_clearBuffer(sprite, TFT_TRANSPARENT);
+        draw_drawSprite(composite, sprite, 72, 72, bigUiElements, BED_SPRITE, 6);
+            
+        tft_clearBuffer(sprite, TFT_TRANSPARENT);
+        draw_drawSprite(composite, sprite, 172, 72, smallUIElements, ZZZ_ICON, 6);
+
+        tft_clearBuffer(sprite, TFT_TRANSPARENT);
+        menu_uiOverlay(composite, sprite, bigUiElements);
+
+        lastUpdateTime = currentTime;
+    }
+    
+    tft_drawBuffer(composite);
+}

src/menu/status_screen.cpp

@@ -0,0 +1,52 @@
+#include "menu.h"
+#include "defs/defs.h"
+#include "defs/sprite_data.h"
+#include "defs/chara_data.h"
+#include "buttons/buttons.h"
+#include "display/display.h"
+#include "draw/draw.h"
+
+void menu_statusScreen(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite, struct SpriteData* spriteData, struct CharacterData* charaData) {
+    tft_clearBuffer(sprite, TFT_TRANSPARENT);
+
+    uint8_t pressedButtons = buttons_getPressedButtons();
+    switch (pressedButtons) {
+        case 2:
+            screenKey = MENU_SCREEN;
+            break;
+
+        default:
+            break;
+    }
+
+    draw_drawBackground(composite, bg, 90, 90, 3);
+    composite.setTextSize(4);
+
+    menu_statusScreen_drawStat(composite, sprite, spriteData, 10, 10, "Hunger", charaData->hunger);
+    menu_statusScreen_drawStat(composite, sprite, spriteData, 10, 80, "Strength", charaData->strength);
+    menu_statusScreen_drawStat(composite, sprite, spriteData, 10, 150, "Effort", charaData->effort);
+
+    tft_drawBuffer(composite);
+}
+
+void menu_statusScreen_drawStat(TFT_eSprite &composite, TFT_eSprite &sprite, struct SpriteData* spriteData, int x, int y, const char* text, uint8_t statValue) {
+    uint8_t icon;
+    
+    composite.drawString(text, x, y);
+    
+    for (int i = 0; i < 4; i++) {
+        if (i < statValue) { icon = FULL_HEART_ICON; } 
+        else { icon = EMPTY_HEART_ICON; }
+
+        draw_drawSprite(
+            composite, 
+            sprite, 
+            15 + (i * 32),
+            y + 30, 
+            spriteData, 
+            icon, 
+            4, 
+            false
+        );
+    }
+}

src/menu/timer_finished.cpp

@@ -0,0 +1,15 @@
+#include "menu.h"
+
+int interruptKey = -1;
+
+void menu_timerFinishedScreen(TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite, struct SpriteData* spriteData) {
+    lastPressedButtonTime = esp_timer_get_time();
+    digitalWrite(BL_PIN, HIGH);
+    
+    screenOff = false;
+    inactive = false;
+    
+    beepCounter = 0;
+    
+    screenKey = interruptKey;
+}

src/menu/title_screen.cpp

@@ -0,0 +1,24 @@
+#include "menu.h"
+#include "display/display.h"
+#include "draw/draw.h"
+#include "defs/defs.h"
+#include "buttons/buttons.h"
+
+void menu_drawTitle(TFT_eSprite &composite, TFT_eSprite &bg) {
+    uint8_t pressedButtons = buttons_getPressedButtons();
+    lastPressedButtonTime = esp_timer_get_time();
+
+    if (pressedButtons == 8 || pressedButtons == 4) {
+        screenKey = CLOCK_EDIT_SCREEN;
+    }
+
+    draw_drawBackground(composite, bg, 90, 90, 3);
+
+    composite.setTextSize(4);
+    tft_drawCenteredText(composite, "NacaPet", 4, 40);
+
+    composite.setTextSize(2);
+    tft_drawCenteredText(composite, VERSION, 2, 80);
+
+    tft_drawBuffer(composite);
+}

src/menu/ui_overlay.cpp

@@ -0,0 +1,28 @@
+#include "menu.h"
+#include "draw/draw.h"
+#include "display/display.h"
+#include "defs/chara_data.h"
+
+void menu_uiOverlay(TFT_eSprite &composite, TFT_eSprite &charSprite, struct SpriteData* uiElements) {
+    struct tm timeInfo;
+    char hourBuffer[6];
+
+    composite.setTextSize(2);
+    composite.setTextColor(TFT_WHITE);
+    composite.fillRect(0, 0, 240, 24, TFT_BLACK);
+    
+    getLocalTime(&timeInfo, RTC_TIMEOUT_THRESHOLD_TIME_MS);
+    snprintf(hourBuffer, 6, "%02d:%02d", timeInfo.tm_hour, timeInfo.tm_min); 
+
+    composite.drawString(hourBuffer, 4, 4);
+    
+    snprintf(hourBuffer, 6, "%05d", stepCounter);
+
+    composite.drawString(hourBuffer, 176, 4);
+    
+    composite.setTextColor(TFT_BLACK);
+    if (charaData.careMistakeCallLight) {
+        tft_clearBuffer(charSprite, TFT_TRANSPARENT);
+        draw_drawSprite(composite, charSprite, 192, 192, uiElements, CARE_MISTAKE_CALL_LIGHT, 2);
+    }
+}