Code:

#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C lcd(0x27,16,2);

#define PIN_BUTTON 2

#define PIN_AUTOPLAY 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 // Horizontal position of hero on screen

#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

#define HERO_POSITION_RUN_LOWER_2 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_BUTTON, INPUT_PULLUP);

pinMode(PIN_AUTOPLAY, OUTPUT);

lcd.init();

lcd.backlight();

// Digital pin 2 maps to interrupt 0

initializeGraphics();

//lcd.begin();

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;

}
 // Shift the terrain to the left

advanceTerrain(terrainLower, newTerrainType == TERRAIN_LOWER_BLOCK ? SPRITE_TERRAIN_SOLID :

advanceTerrain(terrainUpper, newTerrainType == TERRAIN_UPPER_BLOCK ? SPRITE_TERRAIN_SOLID :

// 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) &&

heroPos = HERO_POSITION_RUN_UPPER_1;

} else if (heroPos >= HERO_POSITION_RUN_UPPER_1 && terrainLower[HERO_HORIZONTAL_POSITION] ==

} 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 ? LOW

delay(100);