Rhythm game on an Arduino Uno

// Rhythm game: notes fall down four lanes of a WS2812 panel, and you hit
// the matching lit arcade button as each one reaches the bottom.
//
//   pin 6        the panel: 16 x 8 WS2812s, through 330 ohm on the data line
//   pins 2-5     the four arcade buttons, other side to GND (internal pull-ups)
//   pins 7-10    the four button lamps
//   pin 12       the piezo, other leg to GND
//   A4, A5       the 16x2 LCD's I2C backpack (SDA, SCL)
//
// Press any button to start. The song is Ode to Joy, and every melody note
// falls in the lane of its pitch. Hit it within PERFECT_MS of the beat for a
// perfect, within GOOD_MS for a good; let it pass and the combo breaks. The
// best score is kept in EEPROM, so it survives a reset.
//
// # Why the notes fall early
//
// A note has to be on screen before it is due, or nobody could react to it.
// Each row of the panel is ROW_MS of the future, so a note appears at the top
// seven rows (840 ms) ahead of its beat and reaches the bottom row exactly
// when the piezo plays it.

#include <Wire.h>
#include <EEPROM.h>
#include <LiquidCrystal_I2C.h>
#include <Adafruit_NeoPixel.h>

const int PANEL_PIN = 6;
const int PIEZO = 12;
const int BUTTONS[4] = {2, 3, 4, 5};
const int LAMPS[4] = {7, 8, 9, 10};

const int COLS = 16;
const int ROWS = 8;
const int ROW_MS = 120;
const int PERFECT_MS = 60;
const int GOOD_MS = 140;
const int BEAT_MS = 500;      // 120 beats a minute
const int LEAD_IN_MS = 2000;  // from the start press to the first beat

// Ode to Joy, two phrases. Pitches are an index into HZ, lengths are in
// eighth notes. Each pitch has its lane: C and G on the left, then D, E, F.
const uint16_t HZ[] = {262, 294, 330, 349, 392};
const uint8_t LANE_OF[] = {0, 1, 2, 3, 0};
const uint8_t PITCH[] = {2, 2, 3, 4, 4, 3, 2, 1, 0, 0, 1, 2, 2, 1, 1,
                         2, 2, 3, 4, 4, 3, 2, 1, 0, 0, 1, 2, 1, 0, 0};
const uint8_t EIGHTHS[] = {2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1, 4,
                           2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1, 4};
const int NOTES = sizeof(PITCH);

const uint8_t LANE_RGB[4][3] = {{255, 0, 0}, {255, 180, 0}, {0, 255, 0}, {0, 80, 255}};

Adafruit_NeoPixel panel(COLS * ROWS, PANEL_PIN, NEO_GRB + NEO_KHZ800);
LiquidCrystal_I2C lcd(0x27, 16, 2);

unsigned long dueAt[NOTES]; // when each note is due, from the start of the song
uint8_t judged[NOTES];      // 0 waiting, 1 hit, 2 missed
bool playing = false;
unsigned long startAt = 0;
int nextTone = 0;
long score = 0;
int combo = 0;
long best = 0;
bool wasDown[4];
unsigned long flashUntil[4];
unsigned long frameAt = 0;
bool lcdDirty = false;
const char *verdict = "";

void showLine(int row, const char *label, long value) {
  lcd.setCursor(0, row);
  lcd.print(label);
  lcd.print(value);
  lcd.print("    ");
}

long loadBest() {
  // An erased EEPROM reads 0xFF, so a marker byte says a score was saved.
  if (EEPROM.read(0) != 0x42) return 0;
  long saved;
  EEPROM.get(1, saved);
  return saved;
}

void startSong() {
  unsigned long t = LEAD_IN_MS;
  for (int i = 0; i < NOTES; i++) {
    dueAt[i] = t;
    judged[i] = 0;
    t += (unsigned long)EIGHTHS[i] * BEAT_MS / 2;
  }
  score = 0;
  combo = 0;
  nextTone = 0;
  verdict = "";
  playing = true;
  startAt = millis();
  lcd.clear();
  showLine(0, "Score ", 0);
  Serial.println("go");
}

void endSong() {
  playing = false;
  noTone(PIEZO);
  lcd.clear();
  showLine(0, "Final ", score);
  if (score > best) {
    best = score;
    EEPROM.update(0, 0x42);
    EEPROM.put(1, best);
    showLine(1, "New best! ", best);
    Serial.println("new best");
  } else {
    showLine(1, "Best ", best);
  }
  Serial.print("game over, score ");
  Serial.print(score);
  Serial.print(", best ");
  Serial.println(best);
}

// A press in `lane` at song time `t`: find the nearest waiting note there.
void hit(int lane, long t) {
  int found = -1;
  long nearest = GOOD_MS + 1;
  for (int i = 0; i < NOTES; i++) {
    if (judged[i] || LANE_OF[PITCH[i]] != lane) continue;
    long off = t - (long)dueAt[i];
    if (off < 0) off = -off;
    if (off < nearest) {
      nearest = off;
      found = i;
    }
  }
  if (found < 0) return; // nothing close: a free press, no penalty
  judged[found] = 1;
  combo++;
  int points = nearest <= PERFECT_MS ? 100 : 50;
  verdict = nearest <= PERFECT_MS ? "PERFECT" : "GOOD";
  // The combo multiplies: every ten in a row adds another 1x.
  score += (long)points * (1 + combo / 10);
  flashUntil[lane] = millis() + 120;
  lcdDirty = true;
  Serial.print(verdict);
  Serial.print(" ");
  Serial.print(t - (long)dueAt[found]);
  Serial.print(" ms x");
  Serial.println(combo);
}

void draw(long t) {
  panel.clear();
  for (int lane = 0; lane < 4; lane++) {
    const uint8_t *c = LANE_RGB[lane];
    bool flash = millis() < flashUntil[lane];
    // The hit row along the bottom: dim, or white for a moment after a hit.
    for (int x = 0; x < 3; x++) {
      uint32_t base = flash ? panel.Color(255, 255, 255) : panel.Color(c[0] / 8, c[1] / 8, c[2] / 8);
      panel.setPixelColor((ROWS - 1) * COLS + lane * 4 + x, base);
    }
  }
  for (int i = 0; i < NOTES; i++) {
    if (judged[i]) continue;
    long ahead = (long)dueAt[i] - t;
    if (ahead < -ROW_MS / 2 || ahead > (ROWS - 1) * ROW_MS) continue;
    int row = ROWS - 1 - (int)((ahead + ROW_MS / 2) / ROW_MS);
    if (row < 0) row = 0;
    int lane = LANE_OF[PITCH[i]];
    const uint8_t *c = LANE_RGB[lane];
    for (int x = 0; x < 3; x++) panel.setPixelColor(row * COLS + lane * 4 + x, c[0], c[1], c[2]);
  }
  panel.show();
}

void setup() {
  for (int i = 0; i < 4; i++) {
    pinMode(BUTTONS[i], INPUT_PULLUP);
    pinMode(LAMPS[i], OUTPUT);
  }
  Serial.begin(115200);
  panel.begin();
  panel.setBrightness(120);
  panel.show();
  lcd.init();
  lcd.backlight();
  best = loadBest();
  lcd.setCursor(0, 0);
  lcd.print("Rhythm game");
  showLine(1, "Best ", best);
  Serial.println("Rhythm game ready. Press any button.");
}

void loop() {
  unsigned long now = millis();
  long t = (long)(now - startAt);

  for (int lane = 0; lane < 4; lane++) {
    bool down = digitalRead(BUTTONS[lane]) == LOW;
    if (down && !wasDown[lane]) {
      if (playing) {
        hit(lane, t);
      } else {
        startSong();
        t = 0;
      }
    }
    wasDown[lane] = down;
    // Each button lights while it is held, and flashes on a hit.
    digitalWrite(LAMPS[lane], down || now < flashUntil[lane] || (!playing && (now / 400) % 4 == lane));
  }

  if (!playing) return;

  // The song: each note sounds at its beat whether or not it is hit.
  if (nextTone < NOTES && t >= (long)dueAt[nextTone]) {
    tone(PIEZO, HZ[PITCH[nextTone]], EIGHTHS[nextTone] * BEAT_MS / 2 - 30);
    nextTone++;
  }

  // A note that slips past the window is a miss, and the combo breaks.
  for (int i = 0; i < NOTES; i++) {
    if (!judged[i] && t > (long)dueAt[i] + GOOD_MS) {
      judged[i] = 2;
      Serial.println("miss");
      combo = 0;
      verdict = "MISS";
      lcdDirty = true;
    }
  }

  if (lcdDirty) {
    lcdDirty = false;
    showLine(0, "Score ", score);
    lcd.setCursor(0, 1);
    lcd.print("x");
    lcd.print(combo);
    lcd.print(" ");
    lcd.print(verdict);
    lcd.print("      ");
  }

  if (now - frameAt >= ROW_MS / 2) {
    frameAt = now;
    draw(t);
  }

  if (t > (long)dueAt[NOTES - 1] + 1500) endSong();
}