Игра бегущий человек на Arduino

#include <LiquidCrystal.h>
#include"RunningMan.h"
#include <PinChangeInt.h>


LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
static char terrainUpper[TERRAIN_WIDTH + 1];
static char terrainLower[TERRAIN_WIDTH + 1];
static char terrainUpper_2[TERRAIN_WIDTH + 1];
static char terrainUpper_3[TERRAIN_WIDTH + 1];
volatile bool buttonPushed = false;
volatile bool ButtonDownPressed = false;
volatile bool ButtonDownReleased = false;

void initializeGraphics(){
  byte graphics[] = {
    // символ человека на верхней строке
    B00110,
    B00110,
    B01111,
    B10111,
    B10111,
    B10111,
    B01110,
    B01110,
    // символ 1 человека на нижней строке
    B01110,
    B01110,
    B01110,
    B01110,
    B01010,
    B10010,
    B10010,
    B11011,
    // символ 2 человека на нижней строке
    B01110,
    B01110,
    B01110,
    B01110,
    B01110,
    B01110,
    B01110,
    B01111,
    // символ прыжка человека на нижней строке
    B11110,
    B01101,
    B11111,
    B10000,
    B00000,
    B00000,
    B00000,
    B00000,
    //сплошной блок
    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;
    terrainUpper_2[i] = SPRITE_TERRAIN_EMPTY;
    terrainUpper_3[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, char* terrainUpper_2, char* terrainUpper_3) {
  bool collide = false;
  char upperSave = terrainUpper[HERO_HORIZONTAL_POSITION];
  char lowerSave = terrainLower[HERO_HORIZONTAL_POSITION];
  char upper_2_Save = terrainUpper_2[HERO_HORIZONTAL_POSITION];
  char upper_3_Save = terrainUpper_3[HERO_HORIZONTAL_POSITION];
  byte upper, lower, upper_2, upper_3;

  if ((position == HERO_POSITION_RUN_LOWER_1) || (position == HERO_POSITION_RUN_LOWER_2)
   || (position == HERO_POSITION_RUN_UPPER_1) || (position == HERO_POSITION_RUN_UPPER_2)
   || (position == HERO_POSITION_RUN_UPPER_3) || (position == HERO_POSITION_RUN_UPPER_4))
    BigManRunning(); //создание символов для отображение человека
  
  else if ((position == HERO_POSITION_JUMP_1) || (position == HERO_POSITION_JUMP_9))
    BigManJumping(); //создание символа для отображение прыжка
  
  //выбор символа человека в зависимости от положения
  switch (position) {
    case HERO_POSITION_OFF:
      upper = lower = upper_2 = upper_3 = SPRITE_TERRAIN_EMPTY;
      break;
    case HERO_POSITION_RUN_LOWER_1:
      upper_2 = upper_3 = SPRITE_TERRAIN_EMPTY;
      upper = SPRITE_RUN_UP;
      lower = SPRITE_RUN_LOWER_1;
      break;
    case HERO_POSITION_RUN_LOWER_2:
      upper_2 = upper_3 = SPRITE_TERRAIN_EMPTY;
      upper = SPRITE_RUN_UP;
      lower = SPRITE_RUN_LOWER_2;
      break;
    case HERO_POSITION_JUMP_1:
    case HERO_POSITION_JUMP_8:
      upper_2 = upper_3 = SPRITE_TERRAIN_EMPTY;
      upper =  SPRITE_RUN_UP;
      lower = SPRITE_JUMP_LOWER;
    break;
      
    case HERO_POSITION_JUMP_2:
    case HERO_POSITION_JUMP_7:
      upper_3 = SPRITE_TERRAIN_EMPTY;
      upper_2 = SPRITE_JUMP_UPPER;
      upper = SPRITE_RUN_UP;
      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_3 = SPRITE_TERRAIN_EMPTY;
      upper_2 = SPRITE_RUN_UP;
      upper = SPRITE_JUMP_LOWER;
      lower = SPRITE_TERRAIN_EMPTY;  
    break;
    
    case HERO_POSITION_RUN_UPPER_1:
      upper_3 = SPRITE_TERRAIN_EMPTY;
      upper_2 = SPRITE_RUN_UP;
      upper = SPRITE_RUN_LOWER_1;
      lower = SPRITE_TERRAIN_EMPTY;
      break;
      
    case HERO_POSITION_RUN_UPPER_2:
      upper_3 = SPRITE_TERRAIN_EMPTY;
      upper_2 = SPRITE_RUN_UP;
      upper = SPRITE_RUN_LOWER_2;
      lower = SPRITE_TERRAIN_EMPTY;
      break;

    case HERO_POSITION_JUMP_9:
    case HERO_POSITION_JUMP_16:
      upper_3 = SPRITE_TERRAIN_EMPTY;
      upper_2 = SPRITE_RUN_UP;
      upper = SPRITE_JUMP_LOWER;
      lower = SPRITE_TERRAIN_EMPTY;
    break;

    case HERO_POSITION_JUMP_10:
    case HERO_POSITION_JUMP_15:
      upper_3 = SPRITE_JUMP_UPPER;
      upper_2 = SPRITE_RUN_UP;
      upper = SPRITE_JUMP_LOWER;
      lower = SPRITE_TERRAIN_EMPTY;
    break;

    case HERO_POSITION_JUMP_11:
    case HERO_POSITION_JUMP_12:
    case HERO_POSITION_JUMP_13:
    case HERO_POSITION_JUMP_14:
      upper_3 = SPRITE_RUN_UP;
      upper_2 = SPRITE_JUMP_LOWER;
      lower = upper = SPRITE_TERRAIN_EMPTY;  
    break;

    case HERO_POSITION_RUN_UPPER_3:
      upper_3 = SPRITE_RUN_UP;
      upper_2 = SPRITE_RUN_LOWER_1;
      lower = upper = SPRITE_TERRAIN_EMPTY;
    break;

    case HERO_POSITION_RUN_UPPER_4:
      upper_3 = SPRITE_RUN_UP;
      upper_2 = SPRITE_RUN_LOWER_2;
      lower = upper = SPRITE_TERRAIN_EMPTY;
    break;

    case HERO_POSITION_SIT_1:
    case HERO_POSITION_SIT_2:
    case HERO_POSITION_SIT_3:
    {
      SmallManLying(); //создание символов для отображения сидящего человека
      
      lower = upper = upper_2 = upper_3 = SPRITE_TERRAIN_EMPTY;

      if (position == HERO_POSITION_SIT_1)
        lower = SPRITE_LYING;
      else if (position == HERO_POSITION_SIT_2)
        upper = SPRITE_LYING;
      else
        upper_2 = SPRITE_LYING;
    }
    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;
  }
  
  if (upper_2 != ' ') {
    terrainUpper_2[HERO_HORIZONTAL_POSITION] = upper_2;
    collide |= (upper_2_Save == SPRITE_TERRAIN_EMPTY) ? false : true;
  }
  if (upper_3 != ' ') {
    terrainUpper_3[HERO_HORIZONTAL_POSITION] = upper_3;
    collide |= (upper_3_Save == 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';
  terrainUpper_2[TERRAIN_WIDTH] = '\0';
  terrainUpper_3[TERRAIN_WIDTH] = '\0';
  char temp = terrainUpper_3[16-digits];
  terrainUpper_3[16-digits] = '\0';
  lcd.setCursor(0,0);
  lcd.print(terrainUpper_3);
  terrainUpper_3[16-digits] = temp;  
  lcd.setCursor(0,3);
  lcd.print(terrainLower);
  lcd.setCursor(16 - digits, 0);
  lcd.print(score);
  lcd.setCursor(0, 2);
  lcd.print(terrainUpper);
  lcd.setCursor(0, 1);
  lcd.print(terrainUpper_2);

  terrainUpper[HERO_HORIZONTAL_POSITION] = upperSave;
  terrainLower[HERO_HORIZONTAL_POSITION] = lowerSave;
  terrainUpper_2[HERO_HORIZONTAL_POSITION] = upper_2_Save;
  terrainUpper_3[HERO_HORIZONTAL_POSITION] = upper_3_Save;

  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_UP, INPUT);
  digitalWrite(PIN_BUTTON_UP, HIGH);
  pinMode(PIN_AUTOPLAY, OUTPUT);
  digitalWrite(PIN_AUTOPLAY, HIGH);
  pinMode(PIN_BUTTON_DOWN, INPUT);
  digitalWrite(PIN_BUTTON_DOWN, HIGH);
  
  
  PCintPort::attachInterrupt(PIN_BUTTON_UP, &buttonPush, FALLING);
  PCintPort::attachInterrupt(PIN_BUTTON_DOWN, &BUTTON_DOWN_ISR, CHANGE);
    
  initializeGraphics();
  
  lcd.begin(16, 4);
}

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, terrainUpper_2, terrainUpper_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);
  advanceTerrain(terrainUpper_2, newTerrainType == TERRAIN_UPPER_2_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY);
  advanceTerrain(terrainUpper_3, newTerrainType == TERRAIN_UPPER_3_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY);
  
  //создание нового блока
  if (--newTerrainDuration == 0)
  {
    if (newTerrainType == TERRAIN_EMPTY)//если предыдущий блок пустой
    { //создание непустого блока
      newTerrainType = random(1, 5); //произвольный выбор строки блока
      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;
    else if ((heroPos == HERO_POSITION_RUN_UPPER_1) || (heroPos == HERO_POSITION_RUN_UPPER_2))
       heroPos = HERO_POSITION_JUMP_9;
    buttonPushed = false;
  }

  if (ButtonDownPressed) //если нажата кнопка "вниз"
  {
    if (heroPos <= HERO_POSITION_RUN_LOWER_2)
      heroPos = HERO_POSITION_SIT_1;      
    else if ((heroPos == HERO_POSITION_RUN_UPPER_1) || (heroPos == HERO_POSITION_RUN_UPPER_2))
     heroPos = HERO_POSITION_SIT_2;
    else if ((heroPos == HERO_POSITION_RUN_UPPER_3) || (heroPos == HERO_POSITION_RUN_UPPER_4))
     heroPos = HERO_POSITION_SIT_3;
    
    ButtonDownPressed = false;
  }

  if (ButtonDownReleased) //если отпущена кнопка "вниз"
  {
    if (heroPos == HERO_POSITION_SIT_1)
      heroPos = HERO_POSITION_RUN_LOWER_1;
    else if (heroPos == HERO_POSITION_SIT_2)
      heroPos = HERO_POSITION_RUN_UPPER_1;
    else if (heroPos == HERO_POSITION_SIT_3)
      heroPos = HERO_POSITION_RUN_UPPER_3;
      
    ButtonDownReleased = false;
  }
  //если человек столкнулся с чем-то
  if (drawHero(heroPos, terrainUpper, terrainLower, distance >> 3, terrainUpper_2, terrainUpper_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 || heroPos == HERO_POSITION_RUN_UPPER_2) && 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 if ((heroPos >= HERO_POSITION_JUMP_11 && heroPos <= HERO_POSITION_JUMP_13) && terrainUpper[HERO_HORIZONTAL_POSITION] != SPRITE_TERRAIN_EMPTY)
      heroPos = HERO_POSITION_RUN_UPPER_3;
    else if ((heroPos == HERO_POSITION_RUN_UPPER_3 || heroPos == HERO_POSITION_RUN_UPPER_4) && terrainUpper[HERO_HORIZONTAL_POSITION] == SPRITE_TERRAIN_EMPTY)
      heroPos = HERO_POSITION_JUMP_13;
    else if ((heroPos == HERO_POSITION_JUMP_16) && terrainUpper[HERO_HORIZONTAL_POSITION] == SPRITE_TERRAIN_EMPTY)
      heroPos = HERO_POSITION_JUMP_5;
    else if (heroPos == HERO_POSITION_RUN_UPPER_4)
      heroPos = HERO_POSITION_RUN_UPPER_3;       
    else if ((heroPos == HERO_POSITION_SIT_2) && (terrainLower[HERO_HORIZONTAL_POSITION] == SPRITE_TERRAIN_EMPTY))
      heroPos = HERO_POSITION_RUN_LOWER_1;
    else if ((heroPos == HERO_POSITION_SIT_3) && (terrainUpper[HERO_HORIZONTAL_POSITION] == SPRITE_TERRAIN_EMPTY))
    {
      if (terrainLower[HERO_HORIZONTAL_POSITION] != SPRITE_TERRAIN_EMPTY)
        heroPos = HERO_POSITION_RUN_UPPER_1;
      else
        heroPos = HERO_POSITION_JUMP_13;
    }
  
    else if (heroPos < HERO_POSITION_SIT_1)
    {
      ++heroPos;
    }
    
    ++distance;
    
    digitalWrite(PIN_AUTOPLAY, terrainLower[HERO_HORIZONTAL_POSITION + 2] == SPRITE_TERRAIN_EMPTY ? HIGH : LOW);
  }
  delay(100);
}
//----------------------------------------------
void BigManRunning()
{
  byte graphics[] =
  {
    B01110,
    B01110,
    B01110,
    B01110,
    B01110,
    B01110,
    B01110,
    B01111
  };
  
  lcd.createChar(3, &graphics[0]);
}
//----------------------------------------------
void SmallManLying()
{
  byte graphics[] =
      {
        B00000,
        B11000,
        B11000,
        B00000,
        B11111,
        B11100,
        B11111,
        B11110
      };

  lcd.createChar(3, &graphics[0]);
}
//----------------------------------------------
void BigManJumping()
{
  byte graphics[] =
      {
    B01100,
    B01100,
    B00000,
    B11110,
    B01101,
    B11111,
    B10000,
    B00000
      };

  lcd.createChar(3, &graphics[0]);
}
//----------------------------------------------
void BUTTON_DOWN_ISR()
{
  if (!digitalRead(PIN_BUTTON_DOWN))
    ButtonDownPressed = true;
  else
    ButtonDownReleased = true;
}