bricks.c

#include "bricks.h"
#include "context.h"
#include "display.h"
#include "input.h"
#include "audio.h"
#include "storage.h"
#include "system.h"
#include <stdlib.h>

#define COLOR_CYAN RGB565(0, 255, 255)

#define BRICK_ROWS 19
#define START_BRICK_ROWS 5
#define BRICK_COLS 8
#define BRICK_W 16
#define BRICK_H 6
#define BRICKS_START_Y 32

typedef enum {
    STATE_PLAYING = 0,
    STATE_GAME_OVER,
    STATE_NEW_HIGHSCORE
} BricksState;

static BricksState s_state;
static uint16_t s_score;
static bool s_bricks[BRICK_ROWS][BRICK_COLS];
static bool s_dirtyBricks[BRICK_ROWS][BRICK_COLS];
static uint8_t s_bricksLeft;

// Paddle
static float s_paddleX;
#define PADDLE_Y 145
#define PADDLE_W 24
#define PADDLE_H 4
#define PADDLE_SPEED 60.0f

// Ball
static float s_ballX;
static float s_ballY;
static float s_ballVX;
static float s_ballVY;
static float s_oldPaddleX;
static float s_oldBallX, s_oldBallY;
#define BALL_RADIUS 2

static bool s_firstDraw;
static bool s_isNewHighScore;
static bool s_dirtyScore;
static bool s_gameOverDrawn;
static uint32_t s_gameOverMs;
static bool s_isNewHighScoreChecked;
static uint32_t s_lastUpdate;
static uint32_t s_lastDropMs;

extern bool g_isContinuing;
extern char g_playerName[4];

static void ResetGame(void) {
    s_score = 0;
    s_paddleX = (DISPLAY_WIDTH - PADDLE_W) / 2.0f;
    s_ballX = DISPLAY_WIDTH / 2.0f;
    s_ballY = PADDLE_Y - BALL_RADIUS - 1;
    s_ballVX = 30.0f;
    s_ballVY = -40.0f;
    
    s_bricksLeft = 0;
    for (uint8_t r = 0; r < BRICK_ROWS; r++) {
        for (uint8_t c = 0; c < BRICK_COLS; c++) {
            if (r < START_BRICK_ROWS) {
                s_bricks[r][c] = true;
                s_bricksLeft++;
            } else {
                s_bricks[r][c] = false;
            }
            s_dirtyBricks[r][c] = true;
        }
    }
    
    s_state = STATE_PLAYING;
    s_isNewHighScore = false;
    s_isNewHighScoreChecked = false;
    s_gameOverDrawn = false;
    s_dirtyScore = true;
    s_firstDraw = true;
    s_lastDropMs = systemGetTimeMs();
    
    g_context.hasState[GAME_ID_BRICKS] = true;
}

void bricksEnter(void) {
    if (!g_isContinuing) {
        ResetGame();
    } else {
        s_firstDraw = true;
        s_gameOverDrawn = false;
    }
}

void bricksUpdate(uint32_t nowMs, uint16_t deltaMs) {
    s_lastUpdate = nowMs;
    
    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_BRICKS, s_score, g_playerName);
            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;
    }

    float dt = deltaMs / 1000.0f;
    
    // Paddle movement
    float paddleVelocity = 0.0f;
    int16_t joyX = (int16_t)inputGetJoystickX();
    int16_t joyDiff = joyX - 512;
    
    if (joyDiff > 50 || joyDiff < -50) {
        paddleVelocity = (joyDiff / 512.0f) * 150.0f;
    } else {
        if (inputIsHeld(BUTTON_LEFT)) paddleVelocity = -PADDLE_SPEED;
        if (inputIsHeld(BUTTON_RIGHT)) paddleVelocity = PADDLE_SPEED;
    }
    
    s_paddleX += paddleVelocity * dt;
    
    if (s_paddleX < 0) s_paddleX = 0;
    if (s_paddleX > DISPLAY_WIDTH - PADDLE_W) s_paddleX = DISPLAY_WIDTH - PADDLE_W;

    // Ball movement
    s_ballX += s_ballVX * dt;
    s_ballY += s_ballVY * dt;
    
    // Dropping bricks mechanic
    uint32_t dropIntervalMs = 30000;
    if (s_score > 0) {
        uint32_t decrease = (s_score / 500) * 5000;
        if (decrease > 25000) dropIntervalMs = 5000;
        else dropIntervalMs -= decrease;
    }
    
    if (nowMs - s_lastDropMs >= dropIntervalMs) {
        s_lastDropMs = nowMs;
        for (int8_t r = BRICK_ROWS - 1; r > 0; r--) {
            for (uint8_t c = 0; c < BRICK_COLS; c++) {
                s_bricks[r][c] = s_bricks[r-1][c];
                s_dirtyBricks[r][c] = true;
            }
        }
        for (uint8_t c = 0; c < BRICK_COLS; c++) {
            s_bricks[0][c] = true;
            s_dirtyBricks[0][c] = true;
            s_bricksLeft++;
        }
        bool lost = false;
        for (uint8_t c = 0; c < BRICK_COLS; c++) {
            if (s_bricks[BRICK_ROWS-1][c]) lost = true;
        }
        if (lost) {
            g_context.hasState[GAME_ID_BRICKS] = false;
            s_state = STATE_GAME_OVER;
            s_gameOverMs = nowMs;
            s_isNewHighScoreChecked = false;
            audioPlaySfxGameOver();
            return;
        }
    }
    
    // Wall collisions
    if (s_ballX - BALL_RADIUS < 0) {
        s_ballX = BALL_RADIUS;
        s_ballVX = -s_ballVX;
        audioPlayTone(600, 20);
    } else if (s_ballX + BALL_RADIUS > DISPLAY_WIDTH) {
        s_ballX = DISPLAY_WIDTH - BALL_RADIUS;
        s_ballVX = -s_ballVX;
        audioPlayTone(600, 20);
    }
    
    if (s_ballY - BALL_RADIUS < 0) {
        s_ballY = BALL_RADIUS;
        s_ballVY = -s_ballVY;
        audioPlayTone(600, 20);
    }
    
    // Paddle collision
    if (s_ballVY > 0 && 
        s_ballY + BALL_RADIUS >= PADDLE_Y && 
        s_ballY - BALL_RADIUS <= PADDLE_Y + PADDLE_H &&
        s_ballX + BALL_RADIUS >= s_paddleX && 
        s_ballX - BALL_RADIUS <= s_paddleX + PADDLE_W) {
        
        s_ballY = PADDLE_Y - BALL_RADIUS;
        s_ballVY = -s_ballVY;
        
        // Add spin based on where it hit the paddle
        float hitFactor = (s_ballX - (s_paddleX + PADDLE_W/2.0f)) / (PADDLE_W/2.0f);
        
        float paddleSpeedInfluence = paddleVelocity / 150.0f * 0.6f;
        
        s_ballVX = (hitFactor + paddleSpeedInfluence) * 65.0f;
        
        audioPlayTone(800, 30);
    }
    
    // Brick collision
    if (s_ballY < BRICKS_START_Y + BRICK_ROWS * BRICK_H) {
        int8_t c = (int8_t)(s_ballX / BRICK_W);
        int8_t r = (int8_t)((s_ballY - BRICKS_START_Y) / BRICK_H);
        
        if (r >= 0 && r < BRICK_ROWS && c >= 0 && c < BRICK_COLS) {
            if (s_bricks[r][c]) {
                s_bricks[r][c] = false;
                s_dirtyBricks[r][c] = true;
                s_ballVY = -s_ballVY;
                s_score += 10;
                s_dirtyScore = true;
                s_bricksLeft--;
                audioPlayTone(1200, 40);
                
                if (s_bricksLeft == 0) {
                    // Won level
                    s_score += 100;
                    for (uint8_t r = 0; r < BRICK_ROWS; r++) {
                        for (uint8_t c = 0; c < BRICK_COLS; c++) {
                            if (r < START_BRICK_ROWS) {
                                s_bricks[r][c] = true;
                                s_bricksLeft++;
                            } else {
                                s_bricks[r][c] = false;
                            }
                            s_dirtyBricks[r][c] = true;
                        }
                    }
                    s_ballX = DISPLAY_WIDTH / 2.0f;
                    s_ballY = PADDLE_Y - BALL_RADIUS - 1;
                    s_ballVY = -40.0f;
                }
            }
        }
    }
    
    // Bottom edge (lose)
    if (s_ballY + BALL_RADIUS > DISPLAY_HEIGHT) {
        g_context.hasState[GAME_ID_BRICKS] = false;
        s_state = STATE_GAME_OVER;
        s_gameOverMs = nowMs;
        s_isNewHighScoreChecked = false;
        audioPlaySfxGameOver();
    }
}

void bricksDraw(void) {
    if (s_firstDraw) {
        displayFillScreen(COLOR_BLACK);
        // Banner
        static const uint16_t theme_flame[] = {
            COLOR_RED, RGB565(255, 30, 0), RGB565(255, 60, 0), RGB565(255, 90, 0), 
            RGB565(255, 120, 0), RGB565(255, 150, 0), RGB565(255, 180, 0), COLOR_YELLOW
        };
        // 8 chars * 6px * scale 2 = 96. (128-96)/2 = 16. Padding at Y=4.
        displayDrawThemedText(16, 4, "BREAKOUT", theme_flame, 8, COLOR_BLACK, 2);
        displayDrawText(34, 24, "SCORE:", COLOR_WHITE, COLOR_BLACK);
        
        // Force full redraw
        s_dirtyScore = true;
        s_oldPaddleX = s_paddleX;
        s_oldBallX = s_ballX;
        s_oldBallY = s_ballY;
        
        displayFillRect((int16_t)s_paddleX, PADDLE_Y, PADDLE_W, PADDLE_H, COLOR_BLUE);
        displayFillRect((int16_t)s_ballX - 1, (int16_t)s_ballY - 2, 2, 4, COLOR_WHITE);
        displayFillRect((int16_t)s_ballX - 2, (int16_t)s_ballY - 1, 4, 2, COLOR_WHITE);
        
        for (uint8_t r = 0; r < BRICK_ROWS; r++) {
            for (uint8_t c = 0; c < BRICK_COLS; c++) {
                s_dirtyBricks[r][c] = true;
            }
        }
        
        s_firstDraw = false;
    } else {
        if (s_ballX != s_oldBallX || s_ballY != s_oldBallY) {
            displayFillRect((int16_t)s_oldBallX - 2, (int16_t)s_oldBallY - 2, 4, 4, COLOR_BLACK);
            
            int8_t startC = (int8_t)(((int16_t)s_oldBallX - 2) / BRICK_W);
            int8_t endC = (int8_t)(((int16_t)s_oldBallX + 1) / BRICK_W);
            int8_t startR = (int8_t)((((int16_t)s_oldBallY - 2) - BRICKS_START_Y) / BRICK_H);
            int8_t endR = (int8_t)((((int16_t)s_oldBallY + 1) - BRICKS_START_Y) / BRICK_H);
            
            for (int8_t r = startR; r <= endR; r++) {
                for (int8_t c = startC; c <= endC; c++) {
                    if (r >= 0 && r < BRICK_ROWS && c >= 0 && c < BRICK_COLS) {
                        if (s_bricks[r][c]) s_dirtyBricks[r][c] = true;
                    }
                }
            }
        }
    }

    if (s_dirtyScore) {
        char buf[6];
        buf[0] = (s_score / 1000) % 10 + '0';
        buf[1] = (s_score / 100) % 10 + '0';
        buf[2] = (s_score / 10) % 10 + '0';
        buf[3] = s_score % 10 + '0';
        buf[4] = '\0';
        displayDrawText(70, 24, buf, COLOR_WHITE, COLOR_BLACK);
        s_dirtyScore = false;
    }

    for (uint8_t r = 0; r < BRICK_ROWS; r++) {
        // Compute Red to Yellow gradient (Red is fixed 255, Green scales 0 to 255)
        uint8_t green = (r * 255) / (BRICK_ROWS - 1);
        uint16_t row_color = RGB565(255, green, 0);
        
        for (uint8_t c = 0; c < BRICK_COLS; c++) {
            if (s_dirtyBricks[r][c]) {
                if (s_bricks[r][c]) {
                    displayFillRect(c * BRICK_W, BRICKS_START_Y + r * BRICK_H, BRICK_W - 1, BRICK_H - 1, row_color);
                } else {
                    displayFillRect(c * BRICK_W, BRICKS_START_Y + r * BRICK_H, BRICK_W - 1, BRICK_H - 1, COLOR_BLACK);
                }
                s_dirtyBricks[r][c] = false;
            }
        }
    }

    if (s_paddleX != s_oldPaddleX) {
        displayFillRect((int16_t)s_oldPaddleX, PADDLE_Y, PADDLE_W, PADDLE_H, COLOR_BLACK);
        displayFillRect((int16_t)s_paddleX, PADDLE_Y, PADDLE_W, PADDLE_H, COLOR_BLUE);
        s_oldPaddleX = s_paddleX;
    }
    
    if (s_ballX != s_oldBallX || s_ballY != s_oldBallY) {
        displayFillRect((int16_t)s_ballX - 1, (int16_t)s_ballY - 2, 2, 4, COLOR_WHITE);
        displayFillRect((int16_t)s_ballX - 2, (int16_t)s_ballY - 1, 4, 2, COLOR_WHITE);
        s_oldBallX = s_ballX;
        s_oldBallY = s_ballY;
    }

    if (s_state == STATE_GAME_OVER) {
        if (!s_gameOverDrawn) {
            displayFillRect(8, 58, 112, 18, COLOR_BLACK);
            displayDrawTextScaled(10, 60, "GAME OVER", COLOR_RED, COLOR_BLACK, 2);
            s_gameOverDrawn = true;
        }
    } else if (s_state == STATE_NEW_HIGHSCORE) {
        if (!s_gameOverDrawn) {
            displayFillRect(8, 58, 112, 18, COLOR_BLACK);
            displayDrawTextScaled(10, 60, "GAME OVER", COLOR_RED, COLOR_BLACK, 2);
            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);
            }
        }
    }
}