How to Build and Play JumpMan: A Fun Arduino LCD Game with I2C Interfa – Zaitronics

Welcome to JumpMan! This guide will help you set up, understand, and play the game. JumpMan is a simple and fun game where you control a running hero displayed on an I2C LCD screen. Your goal is to avoid obstacles and achieve the highest score possible.

Components Needed

Arduino Jumpman game project guide LCD 16x2 I2C

Arduino board (e.g., Uno, Nano)
I2C LCD display (16x2)
Push button
Breadboard and jumper wires
Optional: Resistor (to adjust LCD brightness)

Setup Instructions

Hardware Setup:

Connect the I2C LCD display to your Arduino:

VCC to 5V
GND to GND
SDA to A4 (for most Arduino boards)
SCL to A5 (for most Arduino boards)

Connect the push button to digital pin 2 and GND on the Arduino.
Optional: Connect a resistor in series with the LCD backlight pin (if your LCD has a separate backlight pin) to adjust brightness.

Library Installation:

Open the Arduino IDE.
Go to Sketch -> Include Library -> Manage Libraries.
Search for LiquidCrystal_I2C.
Install the library.

Uploading the Code:

Connect your Arduino to your computer.
Copy the provided game code.
Paste it into the Arduino IDE.
Select the correct board and port from Tools -> Board and Tools -> Port.
Click the upload button.

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

#define PIN_BUTTON 2
#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 ' '      // Use 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)

LiquidCrystal_I2C lcd(0x27, 16, 2); // Set the LCD address to 0x27 for a 16 chars and 2 line display
static char terrainUpper[TERRAIN_WIDTH + 1];
static char terrainLower[TERRAIN_WIDTH + 1];
static bool buttonPushed = false;

void initializeGraphics(){
  static byte graphics[] = {
    // Run position 1
    B01100,
    B01100,
    B00000,
    B01110,
    B11100,
    B01100,
    B11010,
    B10011,
    // Run position 2
    B01100,
    B01100,
    B00000,
    B01100,
    B01100,
    B01100,
    B01100,
    B01110,
    // Jump
    B01100,
    B01100,
    B00000,
    B11110,
    B01101,
    B11111,
    B10000,
    B00000,
    // Jump lower
    B11110,
    B01101,
    B11111,
    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_BUTTON, INPUT_PULLUP);
  
  // Digital pin 2 maps to interrupt 0
  attachInterrupt(digitalPinToInterrupt(PIN_BUTTON), buttonPush, FALLING);
  
  lcd.init();
  lcd.backlight();
  
  initializeGraphics();
}

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;
      newTerrainType = TERRAIN_EMPTY;
      newTerrainDuration = 1;
      playing = true;
      buttonPushed = false;
      distance = 0;
    }
    return;
  }
  // If the button was pressed, start a jump
  if (buttonPushed) {
    switch (heroPos) {
      case HERO_POSITION_RUN_LOWER_1:
      case HERO_POSITION_RUN_LOWER_2:
        heroPos = HERO_POSITION_JUMP_1;
        break;
      case HERO_POSITION_RUN_UPPER_1:
      case HERO_POSITION_RUN_UPPER_2:
        heroPos = HERO_POSITION_JUMP_3;
        break;
    }
    buttonPushed = false;
  }
  
  // Make the hero run or jump
  switch (heroPos) {
    case HERO_POSITION_RUN_LOWER_1:
      heroPos = HERO_POSITION_RUN_LOWER_2;
      break;
    case HERO_POSITION_RUN_LOWER_2:
      heroPos = HERO_POSITION_RUN_LOWER_1;
      break;
    case HERO_POSITION_RUN_UPPER_1:
      heroPos = HERO_POSITION_RUN_UPPER_2;
      break;
    case HERO_POSITION_RUN_UPPER_2:
      heroPos = HERO_POSITION_RUN_UPPER_1;
      break;
    case HERO_POSITION_JUMP_1:
      heroPos = HERO_POSITION_JUMP_2;
      break;
    case HERO_POSITION_JUMP_2:
      heroPos = HERO_POSITION_JUMP_3;
      break;
    case HERO_POSITION_JUMP_3:
      heroPos = HERO_POSITION_JUMP_4;
      break;
    case HERO_POSITION_JUMP_4:
      heroPos = HERO_POSITION_JUMP_5;
      break;
    case HERO_POSITION_JUMP_5:
      heroPos = HERO_POSITION_JUMP_6;
      break;
    case HERO_POSITION_JUMP_6:
      heroPos = HERO_POSITION_JUMP_7;
      break;
    case HERO_POSITION_JUMP_7:
      heroPos = HERO_POSITION_JUMP_8;
      break;
    case HERO_POSITION_JUMP_8:
      heroPos = HERO_POSITION_RUN_LOWER_1;
      break;
  }
  
  // Create new terrain
  if (newTerrainDuration) {
    --newTerrainDuration;
  }
  else {
    newTerrainType = random(0,3);
    newTerrainDuration = random(4,16);
  }
  advanceTerrain(terrainUpper, (newTerrainType == TERRAIN_UPPER_BLOCK) ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY);
  advanceTerrain(terrainLower, (newTerrainType == TERRAIN_LOWER_BLOCK) ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY);
  playing = !drawHero(heroPos, terrainUpper, terrainLower, distance >> 3);
  ++distance;
  
  delay(100);
}

How to Play

Start the Game:

Upon powering up the Arduino, you’ll see the message “Press Start” on the LCD.
Press the button to start the game.

Game Controls:

Button Press: Press the button to make the hero jump. Timing your jumps correctly is crucial to avoid obstacles.

Game Objective:

The hero continuously runs from left to right on the screen.
Your goal is to avoid the obstacles (blocks) appearing on the screen.
Each obstacle avoided increases your score.
The game ends if the hero collides with an obstacle.

Game Mechanics

Hero Movement:

The hero has running and jumping animations.
Pressing the button initiates a jump, and the hero will go through several jump phases before landing.

Obstacles:

Obstacles appear randomly on the lower and upper rows of the LCD.
The hero must jump to avoid these obstacles.

Score:

The score increases as you avoid obstacles.
The score is displayed on the top right of the LCD screen.

Game Over:

The game ends if the hero collides with an obstacle.
To restart the game, press the button again.

Tips for High Scores

Timing: Mastering the timing of your jumps is key. Practice to get a feel for when to press the button to avoid obstacles.
Anticipation: Pay attention to the patterns of the obstacles. This will help you anticipate and prepare for jumps.
Stay Focused: As your score increases, the game may feel more intense. Stay focused to maintain your high score.

Adjusting LCD Brightness

If you find the LCD too bright, you can adjust the brightness using a resistor:

Connect a resistor in series with the LCD backlight pin (if your LCD has a separate backlight pin).
The resistor value can be adjusted to achieve the desired brightness level.

Enjoy playing JumpMan and challenge your friends to beat your high score!

How to Build and Play JumpMan: A Fun Arduino LCD Game with I2C Interface

Components Needed

Setup Instructions

How to Play

Game Mechanics

Tips for High Scores

Adjusting LCD Brightness

Leave a comment

Your cart

Useful Information

Choose options