ESP32 Handheld Game Console

#include <Arduino.h>
#include <Wire.h>
#include <SPI.h>
#include <Adafruit_ADS1X15.h>
#include <Arduino_GFX_Library.h>
#include <XPT2046_Touchscreen.h>


// Hoisted type definitions
enum Direction { UP, DOWN, LEFT, RIGHT };

struct Point { int8_t x; int8_t y; };


// Forward declarations
bool snakeContains(Point point, uint8_t length);
void drawCell(Point point, uint16_t colour);
void drawFood();
void placeFood();
void drawHeader();
void drawBoard();
void drawOverlay(const __FlashStringHelper *line1, const __FlashStringHelper *line2);
void resetGame();
void readControls();
void moveSnake();

constexpr uint8_t TFT_CS = 15;
constexpr uint8_t TFT_DC = 2;
constexpr uint8_t TFT_RST = 0;
constexpr uint8_t TFT_SCK = 14;
constexpr uint8_t TFT_MOSI = 13;
constexpr uint8_t TFT_MISO = 12;
constexpr uint8_t TOUCH_CS = 16;
constexpr uint8_t I2C_SDA = 4;
constexpr uint8_t I2C_SCL = 5;

constexpr int16_t SCREEN_W = 480;
constexpr int16_t SCREEN_H = 320;
constexpr int16_t CELL = 10;
constexpr int8_t GRID_W = 46;
constexpr int8_t GRID_H = 28;
constexpr int16_t BOARD_X = 10;
constexpr int16_t BOARD_Y = 30;
constexpr uint8_t MAX_SNAKE = 180;
constexpr uint16_t MOVE_INTERVAL_MS = 130;
constexpr int16_t LOW_DIRECTION = 9000;
constexpr int16_t HIGH_DIRECTION = 24000;
constexpr int16_t BUTTON_PRESSED = 2500;

constexpr uint16_t BLACK = 0x0000;
constexpr uint16_t WHITE = 0xFFFF;
constexpr uint16_t GREEN = 0x07E0;
constexpr uint16_t RED = 0xF800;
constexpr uint16_t BLUE = 0x001F;
constexpr uint16_t YELLOW = 0xFFE0;

Arduino_DataBus *bus = new Arduino_ESP8266SPI(TFT_DC, TFT_CS, TFT_SCK, TFT_MOSI, TFT_MISO);
Arduino_GFX *display = new Arduino_ILI9488(bus, TFT_RST, 1, false);
Adafruit_ADS1115 ads;
XPT2046_Touchscreen touch(TOUCH_CS);




Point snake[MAX_SNAKE];
Point food;
uint8_t snakeLength = 0;
Direction direction = RIGHT;
Direction nextDirection = RIGHT;
bool paused = false;
bool gameOver = false;
bool previousA = false;
bool previousB = false;
bool previousTouch = false;
uint32_t lastMoveAt = 0;

bool snakeContains(Point point, uint8_t length) {
  for (uint8_t i = 0; i < length; ++i) {
    if (snake[i].x == point.x && snake[i].y == point.y) return true;
  }
  return false;
}

void drawCell(Point point, uint16_t colour) {
  display->fillRect(BOARD_X + point.x * CELL + 1, BOARD_Y + point.y * CELL + 1, CELL - 1, CELL - 1, colour);
}

void drawFood() {
  display->drawRect(BOARD_X + food.x * CELL + 1, BOARD_Y + food.y * CELL + 1, CELL - 2, CELL - 2, YELLOW);
}

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

void drawHeader() {
  display->fillRect(0, 0, SCREEN_W, 25, BLUE);
  display->setTextColor(WHITE);
  display->setTextSize(2);
  display->setCursor(10, 5);
  display->print(F("NODEMCU SNAKE"));
  display->setCursor(300, 5);
  display->print(F("Score: "));
  display->print(snakeLength - 5);
}

void drawBoard() {
  display->fillScreen(BLACK);
  drawHeader();
  display->drawRect(BOARD_X - 1, BOARD_Y - 1, GRID_W * CELL + 2, GRID_H * CELL + 2, WHITE);
  for (uint8_t i = 0; i < snakeLength; ++i) drawCell(snake[i], GREEN);
  drawFood();
}

void drawOverlay(const __FlashStringHelper *line1, const __FlashStringHelper *line2) {
  display->fillRect(95, 115, 290, 90, BLACK);
  display->drawRect(95, 115, 290, 90, WHITE);
  display->setTextColor(WHITE);
  display->setTextSize(3);
  display->setCursor(145, 132);
  display->print(line1);
  display->setTextSize(2);
  display->setCursor(115, 172);
  display->print(line2);
}

void resetGame() {
  snakeLength = 5;
  direction = RIGHT;
  nextDirection = RIGHT;
  for (uint8_t i = 0; i < snakeLength; ++i) snake[i] = { static_cast<int8_t>(12 - i), 13 };
  paused = false;
  gameOver = false;
  placeFood();
  drawBoard();
}

void readControls() {
  const int16_t horizontal = ads.readADC_SingleEnded(0);
  const int16_t vertical = ads.readADC_SingleEnded(1);
  const bool buttonA = ads.readADC_SingleEnded(2) < BUTTON_PRESSED;
  const bool buttonB = ads.readADC_SingleEnded(3) < BUTTON_PRESSED;
  const bool screenTouched = touch.touched();

  if ((buttonA && !previousA) || (screenTouched && !previousTouch && gameOver)) {
    if (gameOver) resetGame();
  }
  if ((buttonB && !previousB) || (screenTouched && !previousTouch && !gameOver)) {
    if (!gameOver) {
      paused = !paused;
      if (paused) drawOverlay(F("PAUSED"), F("Press B or touch screen"));
      else drawBoard();
    }
  }
  previousA = buttonA;
  previousB = buttonB;
  previousTouch = screenTouched;

  if (paused || gameOver) return;
  if (horizontal < LOW_DIRECTION && direction != RIGHT) nextDirection = LEFT;
  else if (horizontal > HIGH_DIRECTION && direction != LEFT) nextDirection = RIGHT;
  else if (vertical < LOW_DIRECTION && direction != DOWN) nextDirection = UP;
  else if (vertical > HIGH_DIRECTION && direction != UP) nextDirection = DOWN;
}

void moveSnake() {
  direction = nextDirection;
  Point head = snake[0];
  if (direction == UP) --head.y;
  else if (direction == DOWN) ++head.y;
  else if (direction == LEFT) --head.x;
  else ++head.x;

  if (head.x < 0 || head.x >= GRID_W || head.y < 0 || head.y >= GRID_H || snakeContains(head, snakeLength - 1)) {
    gameOver = true;
    drawOverlay(F("GAME OVER"), F("Press A or touch screen"));
    return;
  }

  const bool ate = (head.x == food.x && head.y == food.y);
  const Point oldTail = snake[snakeLength - 1];
  const uint8_t shiftEnd = ate && snakeLength < MAX_SNAKE ? snakeLength : snakeLength - 1;
  for (uint8_t i = shiftEnd; i > 0; --i) snake[i] = snake[i - 1];
  snake[0] = head;

  if (!ate) drawCell(oldTail, BLACK);
  drawCell(head, GREEN);
  if (ate) {
    if (snakeLength < MAX_SNAKE) ++snakeLength;
    placeFood();
    drawFood();
    drawHeader();
  }
}

void setup() {
  Wire.begin(I2C_SDA, I2C_SCL);
  ads.begin();
  ads.setGain(GAIN_ONE);

  SPI.begin();
  display->begin();
  display->fillScreen(BLACK);
  touch.begin();
  touch.setRotation(1);

  randomSeed(micros() ^ ads.readADC_SingleEnded(0));
  resetGame();
}

void loop() {
  readControls();
  const uint32_t now = millis();
  if (!paused && !gameOver && now - lastMoveAt >= MOVE_INTERVAL_MS) {
    lastMoveAt = now;
    moveSnake();
  }
}