OLED Snake Game

#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>


// Hoisted type definitions
struct Cell { uint8_t x; uint8_t y; };

enum Direction : uint8_t { UP, DOWN, LEFT, RIGHT };


// Forward declarations
bool sameCell(const Cell &a, const Cell &b);
bool isOpposite(Direction a, Direction b);
bool snakeContains(const Cell &cell, uint8_t count);
void placeFood();
void startGame();
bool readRequestedDirection(Direction &requested);
bool moveSnake();
void drawGame();

constexpr int OLED_SDA = 21;
constexpr int OLED_SCL = 22;
constexpr int UP_PIN = 25;
constexpr int DOWN_PIN = 26;
constexpr int LEFT_PIN = 27;
constexpr int RIGHT_PIN = 32;
constexpr uint8_t SCREEN_WIDTH = 128;
constexpr uint8_t SCREEN_HEIGHT = 64;
constexpr uint8_t CELL_SIZE = 4;
constexpr uint8_t GRID_WIDTH = SCREEN_WIDTH / CELL_SIZE;
constexpr uint8_t GRID_HEIGHT = SCREEN_HEIGHT / CELL_SIZE;
constexpr uint8_t MAX_SNAKE = 120;
constexpr unsigned long START_STEP_MS = 180;
constexpr unsigned long MIN_STEP_MS = 70;

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);



Cell snake[MAX_SNAKE];
Cell food;
uint8_t snakeLength;
uint16_t score;
Direction direction;
Direction queuedDirection;
bool gameOver;
unsigned long lastStep;

bool sameCell(const Cell &a, const Cell &b) { return a.x == b.x && a.y == b.y; }

bool isOpposite(Direction a, Direction b) {
  return (a == UP && b == DOWN) || (a == DOWN && b == UP) ||
         (a == LEFT && b == RIGHT) || (a == RIGHT && b == LEFT);
}

bool snakeContains(const Cell &cell, uint8_t count) {
  for (uint8_t i = 0; i < count; ++i) if (sameCell(snake[i], cell)) return true;
  return false;
}

void placeFood() {
  do {
    food.x = random(GRID_WIDTH);
    food.y = random(GRID_HEIGHT);
  } while (snakeContains(food, snakeLength));
}

void startGame() {
  snakeLength = 4;
  score = 0;
  direction = RIGHT;
  queuedDirection = RIGHT;
  gameOver = false;
  const uint8_t startX = GRID_WIDTH / 2;
  const uint8_t startY = GRID_HEIGHT / 2;
  for (uint8_t i = 0; i < snakeLength; ++i) snake[i] = {static_cast<uint8_t>(startX - i), startY};
  placeFood();
  lastStep = millis();
}

bool readRequestedDirection(Direction &requested) {
  if (digitalRead(UP_PIN) == LOW) { requested = UP; return true; }
  if (digitalRead(DOWN_PIN) == LOW) { requested = DOWN; return true; }
  if (digitalRead(LEFT_PIN) == LOW) { requested = LEFT; return true; }
  if (digitalRead(RIGHT_PIN) == LOW) { requested = RIGHT; return true; }
  return false;
}

bool moveSnake() {
  direction = queuedDirection;
  Cell next = snake[0];
  if (direction == UP) {
    if (next.y == 0) { gameOver = true; return true; }
    --next.y;
  } else if (direction == DOWN) {
    if (next.y == GRID_HEIGHT - 1) { gameOver = true; return true; }
    ++next.y;
  } else if (direction == LEFT) {
    if (next.x == 0) { gameOver = true; return true; }
    --next.x;
  } else {
    if (next.x == GRID_WIDTH - 1) { gameOver = true; return true; }
    ++next.x;
  }

  const bool eating = sameCell(next, food);
  const uint8_t collisionCount = eating ? snakeLength : snakeLength - 1;
  if (snakeContains(next, collisionCount)) { gameOver = true; return true; }

  if (eating && snakeLength < MAX_SNAKE) ++snakeLength;
  for (uint8_t i = snakeLength - 1; i > 0; --i) snake[i] = snake[i - 1];
  snake[0] = next;
  if (eating) { ++score; placeFood(); }
  return true;
}

void drawGame() {
  display.clearDisplay();
  for (uint8_t i = 0; i < snakeLength; ++i) {
    display.fillRect(snake[i].x * CELL_SIZE, snake[i].y * CELL_SIZE, CELL_SIZE, CELL_SIZE, SSD1306_WHITE);
  }
  display.drawRect(food.x * CELL_SIZE, food.y * CELL_SIZE, CELL_SIZE, CELL_SIZE, SSD1306_WHITE);
  if (gameOver) {
    display.fillRect(12, 20, 104, 25, SSD1306_BLACK);
    display.drawRect(12, 20, 104, 25, SSD1306_WHITE);
    display.setTextColor(SSD1306_WHITE);
    display.setTextSize(1);
    display.setCursor(22, 25);
    display.print("GAME OVER  ");
    display.print(score);
    display.setCursor(19, 35);
    display.print("Press a direction");
  }
  display.display();
}

void setup() {
  pinMode(UP_PIN, INPUT_PULLUP);
  pinMode(DOWN_PIN, INPUT_PULLUP);
  pinMode(LEFT_PIN, INPUT_PULLUP);
  pinMode(RIGHT_PIN, INPUT_PULLUP);
  Wire.begin(OLED_SDA, OLED_SCL);
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) while (true) delay(1000);
  randomSeed(micros());
  startGame();
  drawGame();
}

void loop() {
  Direction requested;
  if (readRequestedDirection(requested)) {
    if (gameOver) {
      startGame();
      drawGame();
      delay(120);
      return;
    }
    if (!isOpposite(requested, direction)) queuedDirection = requested;
  }

  const unsigned long stepMs = max(MIN_STEP_MS, START_STEP_MS - score * 4UL);
  if (!gameOver && millis() - lastStep >= stepMs) {
    lastStep = millis();
    moveSnake();
    drawGame();
  }
  delay(10);
}