Published January 13, 2025

Simulate Online-Recreating 'Flappy Bird' with Arduino Nano

Learn to recreate the classic mobile game 'Flappy Bird' using Arduino Nano! Dive into coding and electronics for fun and creativity.

BeginnerProtip132

Things used in this project

Hardware components

Arduino Nano R3

Microchip ATmega328

Seeed Studio Grove - OLED Display 0.66" (SSD1306)- IIC - 3.3V/5V

C&K Switches PTS 645 Series Switch

Jumper wires (generic)

Software apps and online services

PCBX Online Simulation

Story

We will guide you through the process of replicating the once-dominant mobile game Flappy Bird using an Arduino Nano and an OLED display. For this project, we will utilize the PCBX online simulation platform, which allows you to design, prototype, and simulate your Arduino projects without needing physical hardware. This means you can play the game directly in your web browser!

Libraries Needed

To work with the OLED display in PCBX, you will need the following libraries implemented in the simulation:

Adafruit GFX
Adafruit SSD1306

These libraries will be part of the online simulation environment.

Explanation of the Code

1. Libraries and Constants

We start by including the necessary libraries and defining constants for screen dimensions, bird properties, pipe properties, and game mechanics.

2. Setup Function

In the setup() function, we initialize the display and configure the input button. We also call initializePipes() to set the initial positions of the pipes.

3. Main Loop

The loop() function contains the game logic:

Input Detection: When the button is pressed, the bird flaps.
Bird Movement: The bird's position is updated based on its velocity, which is influenced by gravity.
Pipe Movement: The pipes move left across the screen, and new pipes are generated as they exit the screen.
Collision Detection: If the bird collides with a pipe, the game ends.
Display Update: The screen is cleared, and the current game state (bird, pipes, score) is drawn.

4. Game Over Handling

When the game ends, a "Game Over" message is displayed along with the score. After a brief pause, the game resets.

5. Pipe Initialization and Gap Generation

The initializePipes() function sets the initial positions and gaps of the pipes, while generateUniqueGapHeight() ensures that the gaps between pipes are unique.

Playing the Game Online

Using PCBX, you can easily simulate the game and play it directly in your web browser. Simply create a new project, use the code provided above, and run the simulation to experience your very own Flappy Bird game!

Simulate the project online:

https://www.pcbx.com/community-detail/3396a078080e4512a4a9d900cae6b198

If you need further assistance or have any questions, feel free to ask!

Join the PCBX community to create your first project and get a surprise bag.

Code

Untitled file

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1 // Reset pin not needed
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// Bird parameters
#define BIRD_X 20
#define BIRD_WIDTH 8
#define BIRD_HEIGHT 8
#define FLAP_FORCE -2
#define GRAVITY 1

int birdY = SCREEN_HEIGHT / 2;
int birdVelocity = 0;

// Pipe parameters
#define PIPE_WIDTH 5
#define GAP_HEIGHT 20
#define PIPE_COUNT 3 // Display three pipes at once
int pipeX[PIPE_COUNT] = {SCREEN_WIDTH, SCREEN_WIDTH + SCREEN_WIDTH/PIPE_COUNT, SCREEN_WIDTH + 2*(SCREEN_WIDTH/PIPE_COUNT)};
int pipeGapY[PIPE_COUNT];

// Game and input parameters
#define BUTTON_PIN 2
bool game_over = false;
int score = 0;

// Bird bitmap
const uint8_t PROGMEM birdBitmap[] = {
0x00, 0x28, 0x1C, 0x1B, 0x1C, 0x28, 0x00, 0x00
};

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay();
  display.display();

  // Initialize random heights for pipe gaps
  initializePipes();
}

void loop() {
  if (!game_over) {
    // Button input detection
    if (digitalRead(BUTTON_PIN) == LOW) {
      birdVelocity = FLAP_FORCE;
    }

    // Update bird position
    birdY += birdVelocity;
    birdVelocity += GRAVITY;

    // Update position of each pipe
    for (int i = 0; i < PIPE_COUNT; i++) {
      pipeX[i] -= 2;
      if (pipeX[i] < -PIPE_WIDTH) {
        pipeX[i] = SCREEN_WIDTH;
        // Set different gap height for new pipe
        pipeGapY[i] = generateUniqueGapHeight(i);
        score++;
      }

      // Collision detection
      if (pipeX[i] < BIRD_X + BIRD_WIDTH && pipeX[i] + PIPE_WIDTH > BIRD_X &&
          (birdY < pipeGapY[i] || birdY + BIRD_HEIGHT > pipeGapY[i] + GAP_HEIGHT)) {
        game_over = true;
      }
    }

    // Clear display and draw the next frame
    display.clearDisplay();
    display.drawBitmap(BIRD_X, birdY, birdBitmap, BIRD_WIDTH, BIRD_HEIGHT, SSD1306_WHITE);
    for (int i = 0; i < PIPE_COUNT; i++) {
      display.fillRect(pipeX[i], 0, PIPE_WIDTH, pipeGapY[i], SSD1306_WHITE);
      display.fillRect(pipeX[i], pipeGapY[i] + GAP_HEIGHT, PIPE_WIDTH, SCREEN_HEIGHT - pipeGapY[i] - GAP_HEIGHT, SSD1306_WHITE);
    }
    display.setCursor(0, 0);
    display.setTextSize(1);
    display.setTextColor(SSD1306_WHITE);
    display.print("Score: ");
    display.print(score);
    display.display();

    // Control update rate
    delay(30);
  } else {
    // Game over display
    display.clearDisplay();
    display.setCursor(10, 20);
    display.setTextSize(2);
    display.setTextColor(SSD1306_WHITE);
    display.print("Game Over");
    display.setCursor(20, 45);
    display.setTextSize(1);
    display.print("Score: ");
    display.print(score);
    display.display();
    delay(2000);
    // Reset game
    resetGame();
  }
}

void resetGame() {
  birdY = SCREEN_HEIGHT / 2;
  birdVelocity = 0;
  initializePipes();
  score = 0;
  game_over = false;
}

void initializePipes() {
  for (int i = 0; i < PIPE_COUNT; i++) {
    pipeX[i] = SCREEN_WIDTH + i * (SCREEN_WIDTH / PIPE_COUNT);
    pipeGapY[i] = generateUniqueGapHeight(i);
  }
}

int generateUniqueGapHeight(int currentPipe) {
  int gapHeight;
  bool isUnique;
  do {
    gapHeight = random(GAP_HEIGHT + 10, SCREEN_HEIGHT - GAP_HEIGHT - 10);
    isUnique = true;
    for (int j = 0; j < currentPipe; j++) {
      if (pipeGapY[j] == gapHeight) {
        isUnique = false;
        break;
      }
    }
  } while (!isUnique);
  return gapHeight;
}