Whack-a-mole on an Arduino Uno

// Whack-a-mole: four lamps, four buttons, a piezo and a score display.
//
// Wiring:
//   moles      pins 2, 3, 4, 5 -> 220 ohm -> LED -> GND
//   buttons    pins 6, 7, 8, 9 -> pushbutton -> GND (button 1 under mole 1)
//   piezo      pin 10 -> piezo -> GND
//   TM1637     CLK -> A0   DIO -> A1   VCC -> 5 V   GND -> GND
//
// Press any button to start a thirty-second round. A mole lights up: hit the
// button under it before it goes out. Every hit scores a point and makes the
// next mole a little quicker. Hit the wrong button and you lose a point. The
// display shows the seconds left on the left and the score on the right, and
// the best score of the session when the round is over.
//
// The moles are random, so the sketch seeds the generator from micros() at the
// first press: that is a person's reaction time, which nothing can predict.

#include <TM1637Display.h>

const uint8_t MOLES = 4;
const uint8_t LAMP[MOLES] = {2, 3, 4, 5};
const uint8_t BUTTON[MOLES] = {6, 7, 8, 9};
const uint8_t PIEZO_PIN = 10;
const uint32_t ROUND_MS = 30000;

TM1637Display display(A0, A1);

int8_t mole = -1;          // the lit mole, or -1
uint32_t moleUntil = 0;    // when it goes back down
uint32_t nextMoleAt = 0;   // when the next one pops up
uint16_t upMs = 900;       // how long a mole stays up
int score = 0;
int best = 0;
bool playing = false;
uint32_t roundStart = 0;
bool wasDown[MOLES];
bool seeded = false;

static void lampsOff()
{
  for (uint8_t i = 0; i < MOLES; i++) {
    digitalWrite(LAMP[i], LOW);
  }
}

/** Seconds left on the left two digits, the score on the right two, colon on. */
static void showRound(uint8_t secondsLeft)
{
  int both = secondsLeft * 100 + (score < 0 ? 0 : score % 100);
  display.showNumberDecEx(both, 0b01000000, true);
}

static void showBest()
{
  const uint8_t dashes[2] = {SEG_G, SEG_G};
  display.setSegments(dashes, 2, 0);
  display.showNumberDec(best % 100, false, 2, 2);
}

static void startRound()
{
  if (!seeded) {
    randomSeed(micros());
    seeded = true;
  }
  score = 0;
  upMs = 900;
  playing = true;
  roundStart = millis();
  nextMoleAt = roundStart + 600;
  mole = -1;
  lampsOff();
  tone(PIEZO_PIN, 1047, 120);
  Serial.println("Go! Thirty seconds.");
}

static void endRound()
{
  playing = false;
  lampsOff();
  mole = -1;
  if (score > best) {
    best = score;
  }
  Serial.print("Time! Score ");
  Serial.print(score);
  Serial.print(", best ");
  Serial.println(best);
  tone(PIEZO_PIN, 392, 400);
  showBest();
}

void setup()
{
  Serial.begin(9600);
  for (uint8_t i = 0; i < MOLES; i++) {
    pinMode(LAMP[i], OUTPUT);
    pinMode(BUTTON[i], INPUT_PULLUP);
  }
  noTone(PIEZO_PIN);
  display.setBrightness(5);
  showBest();
  delay(20);
  Serial.println("Whack-a-mole: press any button to start");
}

void loop()
{
  uint32_t now = millis();

  // Read the buttons: a new press is down now and was up last time.
  int8_t hit = -1;
  for (uint8_t i = 0; i < MOLES; i++) {
    bool down = digitalRead(BUTTON[i]) == LOW;
    if (down && !wasDown[i]) {
      hit = (int8_t)i;
    }
    wasDown[i] = down;
  }

  if (!playing) {
    // Between rounds the moles take turns peeking, and any press starts.
    uint8_t peek = (uint8_t)((now / 250) % MOLES);
    for (uint8_t i = 0; i < MOLES; i++) {
      digitalWrite(LAMP[i], i == peek ? HIGH : LOW);
    }
    if (hit >= 0) {
      startRound();
    }
    delay(5);
    return;
  }

  uint32_t elapsed = now - roundStart;
  if (elapsed >= ROUND_MS) {
    endRound();
    return;
  }

  if (hit >= 0) {
    if (hit == mole) {
      score++;
      digitalWrite(LAMP[mole], LOW);
      mole = -1;
      nextMoleAt = now + (uint32_t)random(150, 500);
      if (upMs > 380) {
        upMs -= 30;
      }
      tone(PIEZO_PIN, 1568, 60);
      Serial.print("Hit! ");
      Serial.println(score);
    } else {
      score--;
      tone(PIEZO_PIN, 147, 120);
      Serial.println("Missed");
    }
  }

  if (mole >= 0 && (int32_t)(now - moleUntil) >= 0) {
    // too slow: it ducks back down
    digitalWrite(LAMP[mole], LOW);
    mole = -1;
    nextMoleAt = now + (uint32_t)random(150, 500);
  }
  if (mole < 0 && (int32_t)(now - nextMoleAt) >= 0) {
    int8_t pick;
    do {
      pick = (int8_t)random(MOLES);
    } while (pick == hit);
    mole = pick;
    moleUntil = now + upMs;
    digitalWrite(LAMP[mole], HIGH);
  }

  showRound((uint8_t)((ROUND_MS - elapsed + 999) / 1000));
  delay(5);
}