Flappy Bird Game with Arduino Uno

Flappy Bird Game with Arduino Uno

Hello Guys, I hope you all are doing well. My Name is Vivek Garg and I welcome you all to my Blog Mostly Programing. If you're new here I will suggest you to check out my YouTube channel @mostlyprograming. I post 3 New Videos every week, Let's Code Tuesdays, Innovative Thursdays, and Geeky Saturdays. 

Go! Go! Go! Check it out and if you like the content you can maybe give me a subscription or a comment or a like (YOU DECIDE!).

So, Today we are gonna build a fun game with Arduino. This game is called The Flappy Bird game, I bet you must have played this game in your childhood. And if not you can make one today and play.

Components Required

1. 1 x BreadBoard
2. 1 x Arduino Uno Board
3. 1 x I2C LCD Display (16x2)
4. 1 x 10 KOhm Resistor
5. 1 x Push Button
6. Jumper Wires
7. USB A/B Cable

Circuit Diagram

Fig. 1 Circuit Diagram

Connections:

SCL(LCD) ---> A5/SCL Pin

SDA(LCD) ---> A4/ SDA Pin

Vcc (LCD) ---> +5Volts

Gnd (LCD) ---> Gnd 

Place the push button on the breadboard as shown in Fig. 1

Ground 1a terminal of pushbutton through a 10 K ohm Resistor also, connect the same 1a terminal to the D2 pin of Arduino.

Connect 2a terminal of the Push Button to +5Volts.

(Note: A Push Button Functions only when it is pulled up).

That's all the connections required for the Flappy Bird game using Arduino.

Let's see the Arduino Code Now.

Code

	//Follow @mostlyPrograming on Instagram, Facebook
	//Subscribe to our Youtube Channel for more amazing content
	//Code Credits: http://www.mediafire.com/
	#include <LiquidCrystal_I2C.h>
	#include <Wire.h>
	LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
	#define PIN_READWRITE 10
	#define PIN_CONTRAST 12
	#define PIN_BUTTON 2
	#define PIN_AUTOPLAY 1
	#define SPRITE_RUN1 1
	#define SPRITE_RUN2 2
	#define SPRITE_JUMP 3
	#define SPRITE_JUMP_UPPER '.' // Use the '.' character for the head
	#define SPRITE_JUMP_LOWER 4
	#define SPRITE_TERRAIN_EMPTY ' ' // User the ' ' character
	#define SPRITE_TERRAIN_SOLID 5
	#define SPRITE_TERRAIN_SOLID_RIGHT 6
	#define SPRITE_TERRAIN_SOLID_LEFT 7
	#define HERO_HORIZONTAL_POSITION 1 // Horizontal position of hero on screen
	#define TERRAIN_WIDTH 16
	#define TERRAIN_EMPTY 0
	#define TERRAIN_LOWER_BLOCK 1
	#define TERRAIN_UPPER_BLOCK 2
	#define HERO_POSITION_OFF 0 // Hero is invisible
	#define HERO_POSITION_RUN_LOWER_1 1 // Hero is running on lower row (pose 1)
	#define HERO_POSITION_RUN_LOWER_2 2 // (pose 2)
	#define HERO_POSITION_JUMP_1 3 // Starting a jump
	#define HERO_POSITION_JUMP_2 4 // Half-way up
	#define HERO_POSITION_JUMP_3 5 // Jump is on upper row
	#define HERO_POSITION_JUMP_4 6 // Jump is on upper row
	#define HERO_POSITION_JUMP_5 7 // Jump is on upper row
	#define HERO_POSITION_JUMP_6 8 // Jump is on upper row
	#define HERO_POSITION_JUMP_7 9 // Half-way down
	#define HERO_POSITION_JUMP_8 10 // About to land
	#define HERO_POSITION_RUN_UPPER_1 11 // Hero is running on upper row (pose 1)
	#define HERO_POSITION_RUN_UPPER_2 12 // (pose 2)
	static char terrainUpper[TERRAIN_WIDTH + 1];
	static char terrainLower[TERRAIN_WIDTH + 1];
	static bool buttonPushed = false;
	void initializeGraphics() {
	static byte graphics[] = {
	// Run position 1
	B00000,
	B01110,
	B01101,
	B00110,
	B11110,
	B01110,
	B10010,
	B00000,
	// Run position 2
	B00000,
	B01110,
	B01101,
	B00110,
	B11110,
	B01110,
	B01100,
	B00000,
	// Jump
	B00000,
	B01110,
	B01101,
	B11110,
	B00010,
	B01110,
	B00000,
	B00000,
	// Jump lower
	B01110,
	B00000,
	B00000,
	B10000,
	B00000,
	B00000,
	B00000,
	B00000,
	// Ground
	B11111,
	B11111,
	B11111,
	B11111,
	B11111,
	B11111,
	B11111,
	B11111,
	// Ground right
	B00011,
	B00011,
	B00011,
	B00011,
	B00011,
	B00011,
	B00011,
	B00011,
	// Ground left
	B11000,
	B11000,
	B11000,
	B11000,
	B11000,
	B11000,
	B11000,
	B11000,
	};
	int i;
	// Skip using character 0, this allows lcd.print() to be used to
	// quickly draw multiple characters
	for (i = 0; i < 7; ++i) {
	lcd.createChar(i + 1, &graphics[i * 8]);
	}
	for (i = 0; i < TERRAIN_WIDTH; ++i) {
	terrainUpper[i] = SPRITE_TERRAIN_EMPTY;
	terrainLower[i] = SPRITE_TERRAIN_EMPTY;
	}
	}
	// Slide the terrain to the left in half-character increments
	//
	void advanceTerrain(char* terrain, byte newTerrain) {
	for (int i = 0; i < TERRAIN_WIDTH; ++i) {
	char current = terrain[i];
	char next = (i == TERRAIN_WIDTH - 1) ? newTerrain : terrain[i + 1];
	switch (current) {
	case SPRITE_TERRAIN_EMPTY:
	terrain[i] = (next == SPRITE_TERRAIN_SOLID) ? SPRITE_TERRAIN_SOLID_RIGHT : SPRITE_TERRAIN_EMPTY;
	break;
	case SPRITE_TERRAIN_SOLID:
	terrain[i] = (next == SPRITE_TERRAIN_EMPTY) ? SPRITE_TERRAIN_SOLID_LEFT : SPRITE_TERRAIN_SOLID;
	break;
	case SPRITE_TERRAIN_SOLID_RIGHT:
	terrain[i] = SPRITE_TERRAIN_SOLID;
	break;
	case SPRITE_TERRAIN_SOLID_LEFT:
	terrain[i] = SPRITE_TERRAIN_EMPTY;
	break;
	}
	}
	}
	bool drawHero(byte position, char* terrainUpper, char* terrainLower, unsigned int score) {
	bool collide = false;
	char upperSave = terrainUpper[HERO_HORIZONTAL_POSITION];
	char lowerSave = terrainLower[HERO_HORIZONTAL_POSITION];
	byte upper, lower;
	switch (position) {
	case HERO_POSITION_OFF:
	upper = lower = SPRITE_TERRAIN_EMPTY;
	break;
	case HERO_POSITION_RUN_LOWER_1:
	upper = SPRITE_TERRAIN_EMPTY;
	lower = SPRITE_RUN1;
	break;
	case HERO_POSITION_RUN_LOWER_2:
	upper = SPRITE_TERRAIN_EMPTY;
	lower = SPRITE_RUN2;
	break;
	case HERO_POSITION_JUMP_1:
	case HERO_POSITION_JUMP_8:
	upper = SPRITE_TERRAIN_EMPTY;
	lower = SPRITE_JUMP;
	break;
	case HERO_POSITION_JUMP_2:
	case HERO_POSITION_JUMP_7:
	upper = SPRITE_JUMP_UPPER;
	lower = SPRITE_JUMP_LOWER;
	break;
	case HERO_POSITION_JUMP_3:
	case HERO_POSITION_JUMP_4:
	case HERO_POSITION_JUMP_5:
	case HERO_POSITION_JUMP_6:
	upper = SPRITE_JUMP;
	lower = SPRITE_TERRAIN_EMPTY;
	break;
	case HERO_POSITION_RUN_UPPER_1:
	upper = SPRITE_RUN1;
	lower = SPRITE_TERRAIN_EMPTY;
	break;
	case HERO_POSITION_RUN_UPPER_2:
	upper = SPRITE_RUN2;
	lower = SPRITE_TERRAIN_EMPTY;
	break;
	}
	if (upper != ' ') {
	terrainUpper[HERO_HORIZONTAL_POSITION] = upper;
	collide = (upperSave == SPRITE_TERRAIN_EMPTY) ? false : true;
	}
	if (lower != ' ') {
	terrainLower[HERO_HORIZONTAL_POSITION] = lower;
	collide |= (lowerSave == SPRITE_TERRAIN_EMPTY) ? false : true;
	}
	byte digits = (score > 9999) ? 5 : (score > 999) ? 4 : (score > 99) ? 3 : (score > 9) ? 2 : 1;
	// Draw the scene
	terrainUpper[TERRAIN_WIDTH] = '\0';
	terrainLower[TERRAIN_WIDTH] = '\0';
	char temp = terrainUpper[16 - digits];
	terrainUpper[16 - digits] = '\0';
	lcd.setCursor(0, 0);
	lcd.print(terrainUpper);
	terrainUpper[16 - digits] = temp;
	lcd.setCursor(0, 1);
	lcd.print(terrainLower);
	lcd.setCursor(16 - digits, 0);
	lcd.print(score);
	terrainUpper[HERO_HORIZONTAL_POSITION] = upperSave;
	terrainLower[HERO_HORIZONTAL_POSITION] = lowerSave;
	return collide;
	}
	// Handle the button push as an interrupt
	void buttonPush() {
	buttonPushed = true;
	}
	void setup() {
	pinMode(PIN_READWRITE, OUTPUT);
	digitalWrite(PIN_READWRITE, LOW);
	pinMode(PIN_CONTRAST, OUTPUT);
	digitalWrite(PIN_CONTRAST, LOW);
	pinMode(PIN_BUTTON, INPUT);
	digitalWrite(PIN_BUTTON, HIGH);
	pinMode(PIN_AUTOPLAY, OUTPUT);
	digitalWrite(PIN_AUTOPLAY, HIGH);
	// Digital pin 2 maps to interrupt 0
	attachInterrupt(0/*PIN_BUTTON*/, buttonPush, FALLING);
	initializeGraphics();
	lcd.begin(16, 2);
	}
	void loop() {
	static byte heroPos = HERO_POSITION_RUN_LOWER_1;
	static byte newTerrainType = TERRAIN_EMPTY;
	static byte newTerrainDuration = 1;
	static bool playing = false;
	static bool blink = false;
	static unsigned int distance = 0;
	if (!playing) {
	drawHero((blink) ? HERO_POSITION_OFF : heroPos, terrainUpper, terrainLower, distance >> 3);
	if (blink) {
	lcd.setCursor(0, 0);
	lcd.print("FlappyBird");
	}
	delay(250);
	blink = !blink;
	if (buttonPushed) {
	initializeGraphics();
	heroPos = HERO_POSITION_RUN_LOWER_1;
	playing = true;
	buttonPushed = false;
	distance = 0;
	}
	return;
	}
	// Shift the terrain to the left
	advanceTerrain(terrainLower, newTerrainType == TERRAIN_LOWER_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY);
	advanceTerrain(terrainUpper, newTerrainType == TERRAIN_UPPER_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY);
	// Make new terrain to enter on the right
	if (--newTerrainDuration == 0) {
	if (newTerrainType == TERRAIN_EMPTY) {
	newTerrainType = (random(3) == 0) ? TERRAIN_UPPER_BLOCK : TERRAIN_LOWER_BLOCK;
	newTerrainDuration = 2 + random(10);
	} else {
	newTerrainType = TERRAIN_EMPTY;
	newTerrainDuration = 10 + random(10);
	}
	}
	if (buttonPushed) {
	if (heroPos <= HERO_POSITION_RUN_LOWER_2) heroPos = HERO_POSITION_JUMP_1;
	buttonPushed = false;
	}
	if (drawHero(heroPos, terrainUpper, terrainLower, distance >> 3)) {
	playing = false; // The hero collided with something. Too bad.
	} else {
	if (heroPos == HERO_POSITION_RUN_LOWER_2 || heroPos == HERO_POSITION_JUMP_8) {
	heroPos = HERO_POSITION_RUN_LOWER_1;
	} else if ((heroPos >= HERO_POSITION_JUMP_3 && heroPos <= HERO_POSITION_JUMP_5) && terrainLower[HERO_HORIZONTAL_POSITION] != SPRITE_TERRAIN_EMPTY) {
	heroPos = HERO_POSITION_RUN_UPPER_1;
	} else if (heroPos >= HERO_POSITION_RUN_UPPER_1 && terrainLower[HERO_HORIZONTAL_POSITION] == SPRITE_TERRAIN_EMPTY) {
	heroPos = HERO_POSITION_JUMP_5;
	} else if (heroPos == HERO_POSITION_RUN_UPPER_2) {
	heroPos = HERO_POSITION_RUN_UPPER_1;
	} else {
	++heroPos;
	}
	++distance;
	digitalWrite(PIN_AUTOPLAY, terrainLower[HERO_HORIZONTAL_POSITION + 2] == SPRITE_TERRAIN_EMPTY ? HIGH : LOW);
	}
	delay(85);
	}

view raw The Flappy Bird.ino hosted with ❤ by GitHub

You can also download the .ino file from the link below:
Also, the necessary libraries are included in the same folder:
The Flappy Bird.ino

YouTube Video

You can also watch the complete video tutorial here on YouTube.

Also, If you have any queries, feel free to comment down below and I will try my best to solve, or you can directly DM me at my social media accounts.

Instagram

Twitter    

Facebook

YouTube

Content Creator: Vivek Garg