Arduino-Based 2D LCD Game

Hi all in this post we will see circuits for Arduino-Based 2D LCD Game

The Arduino-Based 2D Platformer Game is an engaging project that combines hardware and software to create a simple yet entertaining game.

Using an Arduino board and a Liquid Crystal Display (LCD), players control a character that runs and jumps across a dynamically changing terrain.

The game features a basic obstacle avoidance mechanism triggered by a button press. The character’s movements and the scrolling terrain provide an interactive gaming experience.

Component List:

Name	Quantity	Component
R1	1	1 kΩ Resistor
U1	1	Arduino Uno R3
U2	1	LCD 16 x 2
S1 S2	2	Pushbutton

The circuit consists of a button (PIN_BUTTON), an LCD (LiquidCrystal), and a few supporting components. PIN_AUTOPLAY controls an additional gameplay feature, while PIN_READWRITE and PIN_CONTRAST manage the LCD display.

The button serves as the input for player actions, enhancing user interaction. The simple and effective circuit allows for an easy understanding of the hardware components involved.

Arduino Code:

#include <LiquidCrystal.h>
define PIN_BUTTON 2
define PIN_AUTOPLAY 1
define PIN_READWRITE 10
define PIN_CONTRAST 12
define SPRITE_RUN1 1
define SPRITE_RUN2 2
define SPRITE_JUMP 3
define SPRITE_JUMP_UPPER '.'
define SPRITE_JUMP_LOWER 4
define SPRITE_TERRAIN_EMPTY ' '
define SPRITE_TERRAIN_SOLID 5
define SPRITE_TERRAIN_SOLID_RIGHT 6
define SPRITE_TERRAIN_SOLID_LEFT 7
define HERO_HORIZONTAL_POSITION 1
define TERRAIN_WIDTH 16
define TERRAIN_EMPTY 0
define TERRAIN_LOWER_BLOCK 1
define TERRAIN_UPPER_BLOCK 2
define HERO_POSITION_OFF 0
define HERO_POSITION_RUN_LOWER_1 1
define HERO_POSITION_RUN_LOWER_2 2
define HERO_POSITION_JUMP_1 3
define HERO_POSITION_JUMP_2 4
define HERO_POSITION_JUMP_3 5
define HERO_POSITION_JUMP_4 6
define HERO_POSITION_JUMP_5 7
define HERO_POSITION_JUMP_6 8
define HERO_POSITION_JUMP_7 9
define HERO_POSITION_JUMP_8 10
define HERO_POSITION_RUN_UPPER_1 11
define HERO_POSITION_RUN_UPPER_2 12
LiquidCrystal lcd(11, 9, 6, 5, 4, 3);
static char terrainUpper[TERRAIN_WIDTH + 1];
static char terrainLower[TERRAIN_WIDTH + 1];
static bool buttonPushed = false;
void initializeGraphics() {
static byte graphics[] = {
B01100,
B01100,
B00000,
B01110,
B11100,
B01100,
B11010,
B10011,
B01100,
B01100,
B00000,
B01100,
B01100,
B01100,
B01100,
B01110,
B01100,
B01100,
B01100,
B11110,
B01101,
B11111,
B10000,
B00000,
B11110,
B01101,
B11111,
B10000,
B00000,
B00000,
B00000,
B00000,
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
B00011,
B00011,
B00011,
B00011,
B00011,
B00011,
B00011,
B00011,
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
};
int i;
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;
}
}
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;
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;
}
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);
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("Press Start");
}
delay(250);
blink = !blink;
if (buttonPushed) {
initializeGraphics();
heroPos = HERO_POSITION_RUN_LOWER_1;
playing = true;
buttonPushed = false;
distance = 0;
}
return;
}
advanceTerrain(terrainLower, newTerrainType == TERRAIN_LOWER_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY);
advanceTerrain(terrainUpper, newTerrainType == TERRAIN_UPPER_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY);
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;
} 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(50);
}

The Arduino-Based 2D Platformer Game project combines the thrill of gaming with hands-on hardware implementation. It provides a practical example of how Arduino can be used beyond traditional electronics projects.

The dynamic gameplay and straightforward circuit make it an ideal project for both beginners and enthusiasts, fostering creativity and programming skills.

This project not only introduces users to game development with Arduino but also demonstrates the versatility of this microcontroller platform in creating interactive and entertaining applications.