Potentiometer Ping Pong

#include <Arduino.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>


// Hoisted type definitions
enum Screen { MODE_MENU, PLAYER_MENU, PLAYING, WIN_SCREEN };

struct Ball {
  int8_t x;
  int8_t y;
  int8_t dx;
  int8_t dy;
};


// Forward declarations
byte knobRow(byte pin);
void printRow(byte row, const char *text);
void drawMenu();
void resetBall(byte index);
void startGame();
void updateMenu();
void showWinner();
void scoreFor(byte player);
void moveBall(byte i);
void drawGame();
void updateGame();

const byte P1_POT_PIN = A0;
const byte P2_POT_PIN = A1;
const unsigned long MENU_HOLD_MS = 15000UL;
const unsigned long FRAME_MS = 180UL;
const unsigned long CHAOS_ADD_MS = 10000UL;
const byte WIN_SCORE = 7;
const byte MAX_CHAOS_BALLS = 20;

LiquidCrystal_I2C lcd(0x27, 16, 2);


Screen screen = MODE_MENU;
bool chaosMode = false;
bool singlePlayer = false;
byte menuChoice = 0;
byte heldChoice = 255;
unsigned long holdStarted = 0;
unsigned long lastFrame = 0;
unsigned long lastChaosBall = 0;



Ball balls[MAX_CHAOS_BALLS];
byte ballCount = 0;
byte p1Row = 0;
byte p2Row = 0;
byte p1Score = 0;
byte p2Score = 0;
byte winner = 0;

byte knobRow(byte pin) {
  return analogRead(pin) >= 512 ? 1 : 0;
}

void printRow(byte row, const char *text) {
  lcd.setCursor(0, row);
  lcd.print(text);
}

void drawMenu() {
  char line[17];
  lcd.clear();
  if (screen == MODE_MENU) {
    snprintf(line, sizeof(line), "%c Normal", menuChoice == 0 ? '>' : ' ');
    printRow(0, line);
    snprintf(line, sizeof(line), "%c Chaos", menuChoice == 1 ? '>' : ' ');
    printRow(1, line);
  } else {
    snprintf(line, sizeof(line), "%c Singleplayer", menuChoice == 0 ? '>' : ' ');
    printRow(0, line);
    snprintf(line, sizeof(line), "%c Two Player", menuChoice == 1 ? '>' : ' ');
    printRow(1, line);
  }
}

void resetBall(byte index) {
  balls[index].x = 7;
  balls[index].y = index & 1;
  balls[index].dx = (index & 1) ? 1 : -1;
  balls[index].dy = (index % 3 == 0) ? 1 : -1;
}

void startGame() {
  p1Score = 0;
  p2Score = 0;
  p1Row = 0;
  p2Row = 0;
  ballCount = 1;
  resetBall(0);
  lastChaosBall = millis();
  lastFrame = millis();
  screen = PLAYING;
  lcd.clear();
}

void updateMenu() {
  byte choice = knobRow(P1_POT_PIN);
  if (choice != menuChoice) {
    menuChoice = choice;
    heldChoice = 255;
    drawMenu();
  }
  if (heldChoice != menuChoice) {
    heldChoice = menuChoice;
    holdStarted = millis();
  }
  unsigned long elapsed = millis() - holdStarted;
  lcd.setCursor(8, 1);
  if (elapsed < MENU_HOLD_MS) {
    lcd.print("Hold ");
    lcd.print((MENU_HOLD_MS - elapsed + 999UL) / 1000UL);
    lcd.print("s ");
  }
  if (elapsed >= MENU_HOLD_MS) {
    if (screen == MODE_MENU) {
      chaosMode = (menuChoice == 1);
      screen = PLAYER_MENU;
      heldChoice = 255;
      drawMenu();
    } else {
      singlePlayer = (menuChoice == 0);
      startGame();
    }
  }
}

void showWinner() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Nice one P");
  lcd.print(winner);
  lcd.setCursor(0, 1);
  lcd.print("Turn knob restart");
}

void scoreFor(byte player) {
  if (chaosMode) return;
  if (player == 1) p1Score++; else p2Score++;
  if (p1Score >= WIN_SCORE || p2Score >= WIN_SCORE) {
    winner = (p1Score >= WIN_SCORE) ? 1 : 2;
    screen = WIN_SCREEN;
    showWinner();
  }
}

void moveBall(byte i) {
  Ball &b = balls[i];
  int8_t nextX = b.x + b.dx;
  int8_t nextY = b.y + b.dy;
  if (nextY < 0 || nextY > 1) {
    b.dy = -b.dy;
    nextY = b.y + b.dy;
  }
  if (nextX == 0 && b.dx < 0) {
    if (nextY == p1Row) {
      b.dx = 1;
      nextX = 1;
    } else {
      scoreFor(2);
      resetBall(i);
      return;
    }
  }
  if (nextX == 15 && b.dx > 0) {
    if (nextY == p2Row) {
      b.dx = -1;
      nextX = 14;
    } else {
      scoreFor(1);
      resetBall(i);
      return;
    }
  }
  b.x = nextX;
  b.y = nextY;
}

void drawGame() {
  char rows[2][17] = {"                ", "                "};
  rows[p1Row][0] = '|';
  rows[p2Row][15] = '|';
  if (!chaosMode) {
    rows[0][7] = '0' + p1Score;
    rows[0][8] = ':';
    rows[0][9] = '0' + p2Score;
  } else {
    rows[0][6] = 'C';
    rows[0][7] = ':';
    rows[0][8] = '0' + (ballCount / 10);
    rows[0][9] = '0' + (ballCount % 10);
  }
  for (byte i = 0; i < ballCount; i++) {
    if (balls[i].x > 0 && balls[i].x < 15) rows[balls[i].y][balls[i].x] = '+';
  }
  lcd.setCursor(0, 0);
  lcd.print(rows[0]);
  lcd.setCursor(0, 1);
  lcd.print(rows[1]);
}

void updateGame() {
  p1Row = knobRow(P1_POT_PIN);
  if (singlePlayer) {
    byte target = p2Row;
    for (byte i = 0; i < ballCount; i++) {
      if (balls[i].dx > 0) {
        target = balls[i].y;
        break;
      }
    }
    p2Row = target;
  } else {
    p2Row = knobRow(P2_POT_PIN);
  }
  if (chaosMode && millis() - lastChaosBall >= CHAOS_ADD_MS) {
    lastChaosBall += CHAOS_ADD_MS;
    if (ballCount < MAX_CHAOS_BALLS) {
      resetBall(ballCount);
      ballCount++;
    }
  }
  if (millis() - lastFrame >= FRAME_MS) {
    lastFrame = millis();
    for (byte i = 0; i < ballCount; i++) {
      moveBall(i);
      if (screen != PLAYING) return;
    }
    drawGame();
  }
}

void setup() {
  lcd.init();
  lcd.backlight();
  drawMenu();
}

void loop() {
  if (screen == MODE_MENU || screen == PLAYER_MENU) {
    updateMenu();
  } else if (screen == PLAYING) {
    updateGame();
  } else if (screen == WIN_SCREEN && analogRead(P1_POT_PIN) < 450) {
    screen = MODE_MENU;
    heldChoice = 255;
    drawMenu();
  }
}