snake.c

#include "snake.h"
#include "context.h"
#include "display.h"
#include "input.h"
#include "audio.h"
#include "storage.h"
#include "launcher.h"
#include "system.h"

#define GRID_SIZE 8
#define GRID_W 16
#define GRID_H 16
#define SCORE_BAR_H 32
#define MAX_SNAKE 100

static uint8_t s_snakeX[MAX_SNAKE];
static uint8_t s_snakeY[MAX_SNAKE];
static uint8_t s_snakeLen;

static uint8_t s_appleX;
static uint8_t s_appleY;

static int8_t s_dirX;
static int8_t s_dirY;
static int8_t s_nextDirX;
static int8_t s_nextDirY;

static uint16_t s_score;
static uint16_t s_applesEaten;
static uint32_t s_lastMoveMs;
typedef enum {
    STATE_PLAYING = 0,
    STATE_GAME_OVER,
    STATE_NEW_HIGHSCORE
} SnakeState;

static SnakeState s_state;
static uint16_t s_moveIntervalMs;
static bool s_isNewHighScore;
static bool s_firstDraw;
static bool s_dirtyApple;
static bool s_dirtyScore;
static bool s_moved;
static bool s_eraseTail;
static bool s_gameOverDrawn;
static uint32_t s_gameOverMs;
static bool s_isNewHighScoreChecked;
static uint8_t s_tailX, s_tailY;



// Very simple PRNG (xorshift) seeded by systemGetTimeMs() initially
static uint32_t s_rngState = 1;
static uint32_t xorshift32(void) {
    uint32_t x = s_rngState;
    x ^= x << 13;
    x ^= x >> 17;
    x ^= x << 5;
    s_rngState = x;
    return x;
}

static void SpawnApple(void) {
    bool valid = false;
    while (!valid) {
        s_appleX = xorshift32() % GRID_W;
        s_appleY = xorshift32() % GRID_H;
        valid = true;
        for (uint8_t i = 0; i < s_snakeLen; i++) {
            if (s_snakeX[i] == s_appleX && s_snakeY[i] == s_appleY) {
                valid = false;
                break;
            }
        }
    }
    s_dirtyApple = true;
}

static void ResetGame(void) {
    s_snakeLen = 3;
    s_snakeX[0] = 5; s_snakeY[0] = 10;
    s_snakeX[1] = 4; s_snakeY[1] = 10;
    s_snakeX[2] = 3; s_snakeY[2] = 10;
    
    s_dirX = 1;
    s_dirY = 0;
    s_nextDirX = 1;
    s_nextDirY = 0;
    
    s_state = STATE_PLAYING;
    s_isNewHighScore = false;
    s_score = 0;
    s_applesEaten = 0;
    s_moveIntervalMs = 400;
    s_gameOverDrawn = false;
    s_isNewHighScoreChecked = false;
    
    s_firstDraw = true;
    s_dirtyScore = true;
    s_moved = false;
    s_eraseTail = true;
    
    SpawnApple();
    g_context.hasState[GAME_ID_SNAKE] = true;
}

void snakeEnter(void) {
    s_rngState = g_context.lastTickMs; // Seed PRNG
    if (s_rngState == 0) s_rngState = 1;
    extern bool g_isContinuing;
    if (!g_isContinuing) {
        ResetGame();
    } else {
        s_firstDraw = true;
        s_dirtyScore = true;
        s_dirtyApple = true;
        s_moved = true;
    }
}



void snakeUpdate(uint32_t nowMs, uint16_t deltaMs) {
    (void)deltaMs;

    if (inputWasPressed(BUTTON_HOME)) {
        contextRequestScreen(SCREEN_MENU);
        return;
    }

    if (s_state == STATE_GAME_OVER) {
        if (!s_isNewHighScoreChecked && (nowMs - s_gameOverMs >= 2000)) {
            extern char g_playerName[4];
            s_isNewHighScoreChecked = true;
            s_isNewHighScore = storageCheckAndSaveScore(GAME_ID_SNAKE, s_score, g_playerName);
            g_context.hasState[GAME_ID_SNAKE] = false;
            if (s_isNewHighScore) {
                s_state = STATE_NEW_HIGHSCORE;
                audioPlaySfxHighScore();
                return;
            }
        }
        
        if (s_isNewHighScoreChecked) {
            if (inputWasPressed(BUTTON_START) || inputWasPressed(BUTTON_SELECT)) {
                ResetGame();
            }
        }
        return;
    } else if (s_state == STATE_NEW_HIGHSCORE) {
        if (inputWasPressed(BUTTON_START) || inputWasPressed(BUTTON_SELECT)) {
            ResetGame();
        }
        return;
    }

    bool up = inputWasPressed(BUTTON_UP);
    bool down = inputWasPressed(BUTTON_DOWN);
    bool left = inputWasPressed(BUTTON_LEFT);
    bool right = inputWasPressed(BUTTON_RIGHT);

    if (up && s_dirY == 0) {
        s_nextDirX = 0; s_nextDirY = -1;
    } else if (down && s_dirY == 0) {
        s_nextDirX = 0; s_nextDirY = 1;
    } else if (left && s_dirX == 0) {
        s_nextDirX = -1; s_nextDirY = 0;
    } else if (right && s_dirX == 0) {
        s_nextDirX = 1; s_nextDirY = 0;
    }

    if (nowMs - s_lastMoveMs >= s_moveIntervalMs) {
        s_lastMoveMs = nowMs;
        
        s_dirX = s_nextDirX;
        s_dirY = s_nextDirY;

        int8_t headX = (int8_t)s_snakeX[0] + s_dirX;
        int8_t headY = (int8_t)s_snakeY[0] + s_dirY;

        // Wrap around boundary
        if (headX < 0) headX = GRID_W - 1;
        else if (headX >= GRID_W) headX = 0;
        
        if (headY < 0) headY = GRID_H - 1;
        else if (headY >= GRID_H) headY = 0;

        // Self collision
        for (uint8_t i = 0; i < s_snakeLen - 1; i++) {
            if (s_snakeX[i] == headX && s_snakeY[i] == headY) {
                s_state = STATE_GAME_OVER;
                g_context.hasState[GAME_ID_SNAKE] = false;
                s_gameOverMs = nowMs;
                s_isNewHighScoreChecked = false;
                audioPlaySfxGameOver();
                return;
            }
        }

        // Store tail for erasing
        s_tailX = s_snakeX[s_snakeLen - 1];
        s_tailY = s_snakeY[s_snakeLen - 1];

        // Move body
        for (uint8_t i = s_snakeLen - 1; i > 0; i--) {
            s_snakeX[i] = s_snakeX[i - 1];
            s_snakeY[i] = s_snakeY[i - 1];
        }
        s_snakeX[0] = (uint8_t)headX;
        s_snakeY[0] = (uint8_t)headY;

        s_moved = true;
        s_eraseTail = true;

        // Apple collision
        if (headX == s_appleX && headY == s_appleY) {
            if (s_snakeLen < MAX_SNAKE) {
                s_snakeLen++;
                // New segment stays at old tail position until next move
                s_snakeX[s_snakeLen - 1] = s_tailX;
                s_snakeY[s_snakeLen - 1] = s_tailY;
                s_eraseTail = false; // Don't erase tail this frame because we just grew into it!
            }
            s_score += 10;
            s_applesEaten++;
            s_dirtyScore = true;
            if (s_applesEaten % 10 == 0) {
                if (s_moveIntervalMs > 70) {
                    s_moveIntervalMs -= 30; // Speed up heavily every 10 apples (100 points)
                }
            }
            audioPlayTone(1200, 50);
            SpawnApple();
        }
    }
}

void snakeDraw(void) {
    if (s_firstDraw) {
        displayFillScreen(COLOR_BLACK);
        
        static const uint16_t theme_snake[] = {
            COLOR_GREEN, RGB565(0, 200, 0), RGB565(0, 160, 0), RGB565(0, 120, 0), RGB565(0, 80, 0)
        };
        // 5 chars * 6px * scale 2 = 60px width. (128 - 60)/2 = 34
        displayDrawThemedText(34, 4, "SNAKE", theme_snake, 5, COLOR_BLACK, 2);
        
        // Removed score bar background
        
        // Draw initial snake
        for (uint8_t i = 0; i < s_snakeLen; i++) {
            displayFillRect(s_snakeX[i] * GRID_SIZE + 1, SCORE_BAR_H + s_snakeY[i] * GRID_SIZE + 1, GRID_SIZE - 2, GRID_SIZE - 2, COLOR_GREEN);
        }
        s_firstDraw = false;
        s_dirtyApple = true;
        s_dirtyScore = true;
    }

    if (s_dirtyScore) {
        char buf[6];
        uint16_t val = s_score;
        buf[5] = '\0';
        buf[4] = (val % 10) + '0'; val /= 10;
        buf[3] = (val % 10) + '0'; val /= 10;
        buf[2] = (val % 10) + '0'; val /= 10;
        buf[1] = (val % 10) + '0'; val /= 10;
        buf[0] = (val % 10) + '0';
        
        displayDrawText(31, 24, "SCORE:", COLOR_WHITE, COLOR_BLACK);
        displayDrawText(67, 24, buf, COLOR_WHITE, COLOR_BLACK);
        s_dirtyScore = false;
    }

    if (s_dirtyApple) {
        // Clear full cell
        displayFillRect(s_appleX * GRID_SIZE, SCORE_BAR_H + s_appleY * GRID_SIZE, GRID_SIZE, GRID_SIZE, COLOR_BLACK);
        // Draw centered apple
        displayFillRect(s_appleX * GRID_SIZE + 1, SCORE_BAR_H + s_appleY * GRID_SIZE + 1, GRID_SIZE - 2, GRID_SIZE - 2, COLOR_RED);
        s_dirtyApple = false;
    }

    if (s_moved) {
        if (s_eraseTail) {
            // Erase old tail
            displayFillRect(s_tailX * GRID_SIZE, SCORE_BAR_H + s_tailY * GRID_SIZE, GRID_SIZE, GRID_SIZE, COLOR_BLACK);
        }
        
        // Draw new head. Erase background cell first to clear any red apple bleed-through
        displayFillRect(s_snakeX[0] * GRID_SIZE, SCORE_BAR_H + s_snakeY[0] * GRID_SIZE, GRID_SIZE, GRID_SIZE, COLOR_BLACK);
        displayFillRect(s_snakeX[0] * GRID_SIZE + 1, SCORE_BAR_H + s_snakeY[0] * GRID_SIZE + 1, GRID_SIZE - 2, GRID_SIZE - 2, COLOR_GREEN);
        
        s_moved = false;
    }

    if (s_state == STATE_GAME_OVER) {
        if (!s_gameOverDrawn) {
            displayFillRect(8, 53, 112, 74, COLOR_BLACK); // bounding box with padding
            displayDrawTextScaled(10, 60, "GAME OVER", COLOR_RED, COLOR_BLACK, 2);
            if (s_isNewHighScore) {
                // Initial draw of high score text (it will flash later)
                displayDrawTextScaled(16, 90, "NEW HIGH", COLOR_WHITE, COLOR_BLACK, 2);
                displayDrawTextScaled(28, 110, "SCORE!", COLOR_WHITE, COLOR_BLACK, 2);
            } else {
                displayDrawTextScaled(4, 90, "PRESS START", COLOR_WHITE, COLOR_BLACK, 1);
            }
            s_gameOverDrawn = true;
        }
        if (s_isNewHighScore) {
            static uint16_t lastColor = 0;
            uint16_t color = (systemGetTimeMs() % 500 < 250) ? RGB565(255, 255, 0) : COLOR_WHITE;
            if (color != lastColor) {
                lastColor = color;
                displayFillRect(12, 86, 104, 44, COLOR_BLACK);
                displayDrawTextScaled(16, 90, "NEW HIGH", color, COLOR_BLACK, 2);
                displayDrawTextScaled(28, 110, "SCORE!", color, COLOR_BLACK, 2);
            }
        }
    }
}