Arduino Reaction-Time Game

#include <Arduino.h>


// Hoisted type definitions
enum GameState {
  WAIT_FOR_RELEASE,
  WAITING_FOR_CUE,
  TIMING_REACTION,
  BLINKING_RESULT
};


// Forward declarations
bool buttonPressedEvent();
void startWaitingRound();
void startResultBlink();

constexpr uint8_t LED_PIN = 13;
constexpr uint8_t BUTTON_PIN = 2;
constexpr uint32_t DEBOUNCE_MS = 30;
constexpr uint32_t MIN_WAIT_MS = 2000;
constexpr uint32_t MAX_WAIT_MS = 5000;
constexpr uint32_t BLINK_INTERVAL_MS = 200;



GameState gameState = WAIT_FOR_RELEASE;
bool rawButtonState = HIGH;
bool stableButtonState = HIGH;
uint32_t lastRawChangeMs = 0;
uint32_t waitStartedMs = 0;
uint32_t randomDelayMs = 0;
uint32_t cueStartedMs = 0;
uint32_t blinkChangedMs = 0;
uint8_t blinkTransitions = 0;

bool buttonPressedEvent() {
  const bool reading = digitalRead(BUTTON_PIN);
  const uint32_t now = millis();

  if (reading != rawButtonState) {
    rawButtonState = reading;
    lastRawChangeMs = now;
  }

  if ((now - lastRawChangeMs) >= DEBOUNCE_MS && stableButtonState != rawButtonState) {
    stableButtonState = rawButtonState;
    return stableButtonState == LOW;
  }
  return false;
}

void startWaitingRound() {
  digitalWrite(LED_PIN, LOW);
  randomDelayMs = random(MIN_WAIT_MS, MAX_WAIT_MS + 1);
  waitStartedMs = millis();
  gameState = WAITING_FOR_CUE;
  Serial.println(F("Round started: wait for the LED."));
}

void startResultBlink() {
  digitalWrite(LED_PIN, LOW);
  blinkTransitions = 0;
  blinkChangedMs = millis();
  gameState = BLINKING_RESULT;
}

void setup() {
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);
  pinMode(BUTTON_PIN, INPUT_PULLUP);

  Serial.begin(115200);
  randomSeed(micros());
  Serial.println(F("Reaction-time game ready. Release the button to begin."));
}

void loop() {
  const uint32_t now = millis();
  const bool pressed = buttonPressedEvent();

  switch (gameState) {
    case WAIT_FOR_RELEASE:
      digitalWrite(LED_PIN, LOW);
      if (stableButtonState == HIGH) {
        startWaitingRound();
      }
      break;

    case WAITING_FOR_CUE:
      if (pressed) {
        Serial.println(F("False start! You pressed before the LED."));
        startResultBlink();
      } else if ((now - waitStartedMs) >= randomDelayMs) {
        digitalWrite(LED_PIN, HIGH);
        cueStartedMs = now;
        gameState = TIMING_REACTION;
        Serial.println(F("GO!"));
      }
      break;

    case TIMING_REACTION:
      if (pressed) {
        Serial.print(F("Reaction time: "));
        Serial.print(now - cueStartedMs);
        Serial.println(F(" ms"));
        startResultBlink();
      }
      break;

    case BLINKING_RESULT:
      if ((now - blinkChangedMs) >= BLINK_INTERVAL_MS) {
        blinkChangedMs = now;
        digitalWrite(LED_PIN, !digitalRead(LED_PIN));
        if (++blinkTransitions >= 6) {
          digitalWrite(LED_PIN, LOW);
          gameState = WAIT_FOR_RELEASE;
          Serial.println(F("Release the button for the next round."));
        }
      }
      break;
  }
}