/*Arduino BREAKOUT Game on 8x8 Matrix WS2812b
by mircemk, June 2025
*/

#include <FastLED.h>

#define LED_PIN        6
#define NUM_LEDS      64
#define MATRIX_WIDTH   8
#define MATRIX_HEIGHT  8
#define LEFT_BUTTON_PIN  9
#define RIGHT_BUTTON_PIN 10
#define BUZZER_PIN     2

// Game constants
#define MIN_X_SPEED 0.2
#define MAX_X_SPEED 0.35
#define MIN_Y_SPEED 0.25
#define MAX_Y_SPEED 0.4
#define SPEED_DECAY 0.98

// Sound settings
#define TONE_HIT    1200
#define TONE_PADDLE 800
#define TONE_WALL   1000
#define TONE_GAMEOVER 400
#define TONE_DURATION 15
#define TONE_COOLDOWN 50

CRGB leds[NUM_LEDS];

// Game elements
int paddlePos = 3;
int paddleWidth = 3;
float ballX = 4;
float ballY = 6;
float ballSpeedX = 0.2;
float ballSpeedY = -0.25;
bool bricks[3][8];
CRGB brickColors[3][8];
int score = 0;
int level = 1;
bool gameOver = false;
bool levelCompleted = false;
bool newGame = false;
bool displayScoreDone = false;

// Timing control
unsigned long lastFrameTime = 0;
unsigned long lastSoundTime = 0;
const unsigned long FRAME_TIME = 50;

const byte SMILEY[8] = {
  B00111100,
  B01000010,
  B10100101,
  B10000001,
  B10100101,
  B10011001,
  B01000010,
  B00111100
};

// Font definition for letters and numbers (5x7 font)
const byte font[37][5] = {
  {0x7C, 0x22, 0x22, 0x22, 0x7C}, // A
  {0x7E, 0x4A, 0x4A, 0x4A, 0x34}, // B
  {0x3C, 0x42, 0x42, 0x42, 0x24}, // C
  {0x7E, 0x42, 0x42, 0x42, 0x3C}, // D
  {0x7E, 0x4A, 0x4A, 0x4A, 0x42}, // E
  {0x7E, 0x0A, 0x0A, 0x0A, 0x02}, // F
  {0x3C, 0x42, 0x52, 0x52, 0x34}, // G
  {0x7E, 0x08, 0x08, 0x08, 0x7E}, // H
  {0x00, 0x42, 0x7E, 0x42, 0x00}, // I
  {0x20, 0x40, 0x42, 0x3E, 0x02}, // J
  {0x7E, 0x08, 0x14, 0x22, 0x42}, // K
  {0x7E, 0x40, 0x40, 0x40, 0x40}, // L
  {0x7E, 0x04, 0x18, 0x04, 0x7E}, // M
  {0x7E, 0x04, 0x08, 0x10, 0x7E}, // N
  {0x3C, 0x42, 0x42, 0x42, 0x3C}, // O
  {0x7E, 0x12, 0x12, 0x12, 0x0C}, // P
  {0x3C, 0x42, 0x52, 0x22, 0x5C}, // Q
  {0x7E, 0x12, 0x32, 0x52, 0x0C}, // R
  {0x24, 0x4A, 0x4A, 0x4A, 0x30}, // S
  {0x02, 0x02, 0x7E, 0x02, 0x02}, // T
  {0x3E, 0x40, 0x40, 0x40, 0x3E}, // U
  {0x1E, 0x20, 0x40, 0x20, 0x1E}, // V
  {0x3E, 0x40, 0x30, 0x40, 0x3E}, // W
  {0x66, 0x18, 0x18, 0x18, 0x66}, // X
  {0x06, 0x08, 0x70, 0x08, 0x06}, // Y
  {0x62, 0x52, 0x4A, 0x46, 0x42}, // Z
  {0x3E, 0x51, 0x49, 0x45, 0x3E}, // 0
  {0x00, 0x42, 0x7F, 0x40, 0x00}, // 1
  {0x72, 0x49, 0x49, 0x49, 0x46}, // 2
  {0x21, 0x41, 0x45, 0x4B, 0x31}, // 3
  {0x18, 0x14, 0x12, 0x7F, 0x10}, // 4
  {0x27, 0x45, 0x45, 0x45, 0x39}, // 5
  {0x3E, 0x49, 0x49, 0x49, 0x32}, // 6
  {0x01, 0x71, 0x09, 0x05, 0x03}, // 7
  {0x36, 0x49, 0x49, 0x49, 0x36}, // 8
  {0x26, 0x49, 0x49, 0x49, 0x3E}, // 9
  {0x00, 0x00, 0x00, 0x00, 0x00}  // Space
};

// Function to get the index of a character in the font array
int getCharIndex(char c) {
  if (c >= 'A' && c <= 'Z') {
    return c - 'A';
  } else if (c >= '0' && c <= '9') {
    return c - '0' + 26;
  } else {
    return 36; // Space
  }
}

// Function to scroll text on the LED matrix
void scrollText(const char* text, int delayTime) {
  int length = strlen(text);
  for (int offset = 0; offset < length * 6 + MATRIX_WIDTH; offset++) {
    fill_solid(leds, NUM_LEDS, CRGB::Black);
    for (int i = 0; i < length; i++) {
      int charIndex = getCharIndex(text[i]);
      for (int col = 0; col < 5; col++) {
        if (i * 6 + col - offset >= 0 && i * 6 + col - offset < MATRIX_WIDTH) {
          byte column = font[charIndex][col];
          for (int row = 0; row < 7; row++) {
            if (column & (1 << row)) {
              leds[getPixelIndex(i * 6 + col - offset, row)] = CRGB::White;
            }
          }
        }
      }
    }
    FastLED.show();
    delay(delayTime);
  }
}

void setup() {
  FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(255);
  
  pinMode(LEFT_BUTTON_PIN, INPUT_PULLUP);
  pinMode(RIGHT_BUTTON_PIN, INPUT_PULLUP);
  pinMode(BUZZER_PIN, OUTPUT);
  delay (1000);
  scrollText(" MINI BREAKOUT", 80);
  initializeGame();
}

void playSound(int frequency, int duration) {
  noTone(BUZZER_PIN); // Ensure the buzzer is off before playing a new sound
  tone(BUZZER_PIN, frequency, duration);
  delay(duration);
  noTone(BUZZER_PIN); // Turn off the buzzer after the duration
}

void initializeGame() {
  FastLED.setBrightness(50); // Ensure consistent brightness
  for (int row = 0; row < 3; row++) {
    for (int col = 0; col < 8; col++) {
      bricks[row][col] = true;
      brickColors[row][col] = CHSV(random(0, 255), 255, 255);  // Random color
    }
  }
  
  paddlePos = 3;
  ballX = 4.0;
  ballY = 6.0;
  ballSpeedX = 0.2;
  ballSpeedY = -0.25;
  score = 0;
  level = 1;
  paddleWidth = 3;
  gameOver = false;
  levelCompleted = false;
  newGame = false;
  displayScoreDone = false;
  lastFrameTime = millis();
  lastSoundTime = 0;
}

void initializeLevel() {
  for (int row = 0; row < 3; row++) {
    for (int col = 0; col < 8; col++) {
      bricks[row][col] = true;
      brickColors[row][col] = CHSV(random(0, 255), 255, 255);  // Random color
    }
  }
  
  paddlePos = 3;
  ballX = 4.0;
  ballY = 6.0;
  ballSpeedX = 0.2;
  ballSpeedY = -0.25;
  levelCompleted = false;
  lastFrameTime = millis();
}

void loop() {
  unsigned long currentTime = millis();
  
  if (!gameOver && !newGame) {
    if (currentTime - lastFrameTime >= FRAME_TIME) {
      handleInput();
      updateGame();
      lastFrameTime = currentTime;
    }
    drawGame();
    FastLED.show();
  } else if (gameOver && !displayScoreDone) {
    char scoreText[20];
    sprintf(scoreText, "SCORE: %d", score);
    scrollText(scoreText, 100);
    displayScoreDone = true;
    displaySmiley();
  } else if (gameOver && displayScoreDone) {
    if (digitalRead(LEFT_BUTTON_PIN) == LOW || digitalRead(RIGHT_BUTTON_PIN) == LOW) {
      delay(300);
      initializeGame();
      newGame = false; // Reset newGame for the next game cycle
      displayScoreDone = false;
    }
  }
}

void handleInput() {
  if (digitalRead(LEFT_BUTTON_PIN) == LOW && paddlePos > 0) {
    paddlePos--;
  }
  if (digitalRead(RIGHT_BUTTON_PIN) == LOW && paddlePos < MATRIX_WIDTH - paddleWidth) {
    paddlePos++;
  }
}

void updateGame() {
  ballX += ballSpeedX;
  ballY += ballSpeedY;
  
  // Brick collisions
  bool allBricksDestroyed = true;
  for (int row = 0; row < 3; row++) {
    for (int col = 0; col < 8; col++) {
      if (bricks[row][col]) {
        allBricksDestroyed = false;
        if (ballY >= row - 0.1 && ballY < row + 1.1 && 
            ballX >= col - 0.1 && ballX < col + 1.1) {
          bricks[row][col] = false;
          
          float dx = ballX - (col + 0.5);
          float dy = ballY - (row + 0.5);
          
          if (abs(dx) > abs(dy)) {
            ballSpeedX = -ballSpeedX;
          } else {
            ballSpeedY = -ballSpeedY;
          }
          
          ballSpeedX += (random(-15, 16) / 100.0);
          
          ballSpeedX = constrain(ballSpeedX, -MAX_X_SPEED, MAX_X_SPEED);
          ballSpeedY = constrain(ballSpeedY, -MAX_Y_SPEED, MAX_Y_SPEED);
          
          score += 1;
          playSound(TONE_HIT, TONE_DURATION);
          break;
        }
      }
    }
  }

  // Check for level completion
  if (allBricksDestroyed) {
    levelCompleted = true;
    level++;
    if (level > 3) {
      gameOver = true;
      playSound(TONE_GAMEOVER, TONE_DURATION * 5);
    } else {
      if (level == 2) {
        paddleWidth = 2;
      } else if (level == 3) {
        paddleWidth = 1;
      }
      initializeLevel();
    }
  }

  // Wall collisions
  if (ballX <= 0 || ballX >= MATRIX_WIDTH - 1) {
    ballSpeedX = -ballSpeedX;
    ballX = (ballX <= 0) ? 0.1 : (MATRIX_WIDTH - 1.1);
    
    if (abs(ballSpeedY) < MIN_Y_SPEED) {
      ballSpeedY += (ballSpeedY > 0 ? MIN_Y_SPEED : -MIN_Y_SPEED) * 0.5;
    }
    
    playSound(TONE_WALL, TONE_DURATION);
  }
  
  if (ballY <= 0) {
    ballSpeedY = abs(ballSpeedY);
    ballY = 0.1;
    playSound(TONE_WALL, TONE_DURATION);
  }

  // Paddle collision
  if (ballY >= MATRIX_HEIGHT - 2 && ballY < MATRIX_HEIGHT - 1) {
    if (ballX >= paddlePos && ballX < paddlePos + paddleWidth) {
      ballY = MATRIX_HEIGHT - 2;
      
      float hitPos = (ballX - paddlePos) / paddleWidth;
      float angle = (hitPos - 0.5) * PI * 0.7;
      
      float speed = sqrt(ballSpeedX * ballSpeedX + ballSpeedY * ballSpeedY);
      ballSpeedX = sin(angle) * speed;
      ballSpeedY = -abs(cos(angle) * speed);
      
      if (abs(ballSpeedY) < MIN_Y_SPEED) {
        ballSpeedY = -MIN_Y_SPEED;
      }
      
      playSound(TONE_PADDLE, TONE_DURATION);
    }
  }

  // Check if the ball collapses next to paddle on the left or right side
  if (ballY >= MATRIX_HEIGHT - 1 && (ballX < paddlePos || ballX >= paddlePos + paddleWidth)) {
    gameOver = true;
    playSound(TONE_GAMEOVER, TONE_DURATION * 5);
  }

  ballSpeedX *= SPEED_DECAY;
  ballSpeedY *= SPEED_DECAY;
  
  if (abs(ballSpeedX) < MIN_X_SPEED) {
    ballSpeedX = (ballSpeedX < 0) ? -MIN_X_SPEED : MIN_X_SPEED;
  }
  if (abs(ballSpeedY) < MIN_Y_SPEED) {
    ballSpeedY = (ballSpeedY < 0) ? -MIN_Y_SPEED : MIN_Y_SPEED;
  }
  
  ballSpeedX = constrain(ballSpeedX, -MAX_X_SPEED, MAX_X_SPEED);
  ballSpeedY = constrain(ballSpeedY, -MAX_Y_SPEED, MAX_Y_SPEED);

  if (ballY >= MATRIX_HEIGHT) {
    gameOver = true;
    playSound(TONE_GAMEOVER, TONE_DURATION * 5);
  }
}

void drawGame() {
  fill_solid(leds, NUM_LEDS, CRGB::Black);
  
  // Draw bricks
  for (int row = 0; row < 3; row++) {
    for (int col = 0; col < 8; col++) {
      if (bricks[row][col]) {
        leds[getPixelIndex(col, row)] = brickColors[row][col];
      }
    }
  }
  
  // Draw paddle
  for (int i = 0; i < paddleWidth; i++) {
    leds[getPixelIndex(paddlePos + i, MATRIX_HEIGHT - 1)] = CRGB::Blue;
  }
  
  // Draw ball
  leds[getPixelIndex(int(ballX), int(ballY))] = CRGB::White;
}

void displaySmiley() {
  fill_solid(leds, NUM_LEDS, CRGB::Black);
  for (int row = 0; row < 8; row++) {
    for (int col = 0; col < 8; col++) {
      if (SMILEY[row] & (1 << (7 - col))) {
        leds[getPixelIndex(col, row)] = CRGB::Yellow;
      }
    }
  }
  FastLED.show();
}

int getPixelIndex(int x, int y) {
  return y * MATRIX_WIDTH + x;
}