Jogo_com_Display.ino

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

static char terrainUpper[TERRAIN_WIDTH + 1];
static char terrainLower[TERRAIN_WIDTH + 1];
static bool buttonPushed = false;

void initializeGraphics()
{
    static byte graphics[] = {
        // Executar posição 1
        B01100,
        B01100,
        B00000,
        B01110,
        B11100,
        B01100,
        B11010,
        B10011,
        // Executar posição 2
        B01100,
        B01100,
        B00000,
        B01100,
        B01100,
        B01100,
        B01100,
        B01110,
        // Pular
        B01100,
        B01100,
        B00000,
        B11110,
        B01101,
        B11111,
        B10000,
        B00000,
        LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

    static char terrainUpper[TERRAIN_WIDTH + 1];
    static char terrainLower[TERRAIN_WIDTH + 1];
    static bool buttonPushed = false;

    void initializeGraphics()
    {
        static byte graphics[] = {
            // Executar posição 1
            B01100,
            B01100,
            B00000,
            B01110,
            B11100,
            B01100,
            B11010,
            B10011,
            // Executar posição 2
            B01100,
            B01100,
            B00000,
            B01100,
            B01100,
            B01100,
            B01100,
            B01110,
            // Pular
            B01100,
            B01100,
            B00000,
            B11110,
            B01101,
            B11111,
            B10000,
            B00000,

        };
        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;
        }
    }

    // Deslize o terreno para a esquerda em incrementos de meio caractere

    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;
            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;

        // Desenhe a cena
        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;
    }
    // Lidar com o botão pressionado como uma interrupção

    void buttonPush()
    {
        buttonPushed = true;
    }

    void setup()
    {
        initializeGraphics();
        lcd.begin(16, 2);
    }

    void loop()
    {
        buttonCheck();
        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;
        }

        // Mude o terreno para a esquerda
        advanceTerrain(terrainLower, newTerrainType == TERRAIN_LOWER_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY);
        advanceTerrain(terrainUpper, newTerrainType == TERRAIN_UPPER_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY);

        // Faça um novo terreno para entrar à direita
        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; // O herói colidiu em algo
        }
        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;
        }
        delay(100);
    }

    void buttonCheck()
    {
        int b = analogRead(A0);
        if (b < 850)
        {
            buttonPushed = true;
        }
    }