- Plano de jogo:
- Diagrama de circuito:
- Pré-requisitos:
- Programando o Arduino para o jogo de corrida espacial:
- Jogo Arduino Space Racer funcionando:
Programar sempre foi divertido e ficou muito melhor com plataformas de desenvolvimento como o Arduino. Quase todo programador aqui teria tentado desenvolver algum tipo de jogo usando a linguagem que estão aprendendo / praticando. Isso os ajuda a ajustar suas habilidades de programação de uma forma divertida e produtiva. Eu sou um grande fã do Arduino desde que o conheci e sempre quis experimentar algo legal com ele, quando descobri o quão legal ele pode ficar com um LCD gráfico como o Nokia 5110 junto com o Arduino minha ideia de desenvolver um jogo foi uma forma interessante de ajustar algumas habilidades de programação e se divertir ao mesmo tempo, embora vocês possam estar interessados em desenvolver seu jogo também. Portanto, neste tutorial, aprenderemos como podemos criar um jogo decente usando Arduino e LCDs gráficos.
Já construímos aquele jogo Snake antiquado usando Arduino, então desta vez estamos tentando algo novo e chamamos este jogo de Jogo de Corrida Espacial, onde você precisa manter sua nave protegida de naves inimigas usando o joystick.
Plano de jogo:
Antes de começarmos, é muito importante planejar como seu jogo realmente funcionaria. Escolhi o LCD gráfico Nokia5110 e o joystick para a seleção do hardware. Presumo neste tutorial que você também selecionou o mesmo. Como o Nokia 5110 não vem com muito espaço, planejamos todo o nosso jogo dentro da resolução de 84 * 48 pixels de nossa tela. Já fizemos tutoriais sobre como fazer a interface do Nokia 5110 LCD com Arduino e Joystick com Arduino.
Dentro deste espaço, temos que ajustar bem a área de jogo e a área do quadro de pontuação, que exibirá itens como pontuação e outras coisas. É muito importante saber a localização do pixel de onde você coloca as coisas para rastrear as localizações dos pixels e atualizá-los na tela.
Uma vez que a aparência da tela do jogo é decidida, temos que decidir os personagens em nosso jogo. Para o meu jogo, temos apenas dois, o personagem do jogador, que é uma nave espacial, e um personagem inimigo, que deve se parecer com uma nave alienígena. O LCD da Nokia pode exibir imagens bitmap, então decidi usar essa opção para exibir minha nave espacial e os inimigos.
Assim teremos uma nave espacial que está correndo através das naves alienígenas, esta nave terá três pistas para mudanças a fim de evitar um acerto com os alienígenas. Em todos os momentos, os alienígenas podem ocupar apenas duas pistas e o jogador deve ser capaz de conduzir pela pista livre. Uma vez concluídas essas idéias, podemos prosseguir com o Hardware e depois com a programação.
Diagrama de circuito:
O circuito para este jogo Arduino é muito simples; só precisamos fazer a interface do módulo LCD do Nokia 5110 e do Joystick com o Arduino. O diagrama completo do circuito é mostrado abaixo
O LCD Nokia 5110 funciona com 3,3V e o módulo Joystick funciona com 5V, portanto certifique-se de conectar o LCD apenas com 3,3V, pois 5V pode danificá-lo permanentemente. O LCD se comunica com o Arduino por meio do protocolo SPI e o Joystick apenas lê ADC para ler a mudança na tensão. A configuração da conexão será semelhante a esta abaixo
Pré-requisitos:
Antes de mergulharmos na parte de programação, é importante que vocês sejam convenientes com o módulo Display e o Joystick, para que possam usar os tutoriais a seguir para saber mais sobre eles e depois voltar aqui para se certificar de que as coisas estão funcionando da maneira como nós preciso disso!
- Interface LCD Nokia 5110 com Arduino
- Interface do módulo de joystick com Arduino
Programando o Arduino para o jogo de corrida espacial:
O programa completo do jogo pode ser encontrado no final desta página; você pode usá-lo diretamente em seu IDE Arduino e fazer o upload para sua placa. Mas se você quiser saber o que realmente acontece dentro do código, leia mais.
Como sempre, iniciamos nosso programa adicionando nossos arquivos de cabeçalho de biblioteca, precisamos de três bibliotecas para este projeto, das quais a biblioteca SPI é adicionada ao seu IDE por padrão. As outras duas bibliotecas devem ser baixadas da página Adafruit Github. Siga o tutorial de interface de LCD mencionado na seção de pré-requisitos se você não tiver certeza de como adicionar a biblioteca.
#incluir
Se você seguiu o tutorial, deve saber que é possível exibir as imagens bitmap no LCD. Portanto, temos que converter a imagem necessária em código de bitmap usando o software mencionado no tutorial, você pode selecionar qualquer imagem da internet e usá-la convertendo-a em código de bitmap. Certifique-se de que a imagem seja simples o suficiente para ser exibida em nossa tela LCD, verifique a visualização antes de realmente tentar na tela LCD. Em nosso programa, usamos dois caracteres de bitmap, um é a nave espacial e o outro é a nave inimiga, o código de bitmap para ambos é adicionado em nosso código conforme mostrado abaixo.
// Dados de bitmap para SpaceShip static const unsigned char PROGMEM ship = { B00000000, B00000000, B00000001, B00000000, B00000011, B10000000, B00000010, B10000000, B00000010, B11000000, B00000111, B11000000, B000011101, B11100000, B0001111000, B1110000, B000111111000, B110000100011 B01111111, B11111100, B01111111, B11111100, B01111111, B11111100, B00011111, B11110000, B00000111, B11100000, B00000000, B00000000, }; // Dados de bitmap para o inimigo estático const unsigned char PROGMEM inimigo = { B00000101, B11000000, B00001011, B11100000, B00000011, B11100000, B00110011, B11111000, B01111111, B11111100, B10111111, B11111010, B01110111, B11011100, B01111110, B11111100, B00111111, B11111100, B11101111, B11101110, B11000001, B00000110, B10000001, B00000010, B10000000, B00000010, B00000000, B00000000, };
Temos que especificar os pinos aos quais o display Nokia LCD 5110 está conectado. O display é comunicado usando a comunicação SPI, se você seguiu o diagrama de circuito acima, o código para inicializar o LCD será o seguinte, você não precisa alterá-lo.
Adafruit_PCD8544 display = Adafruit_PCD8544 (7, 6, 5, 4, 3); // Especifique os pinos aos quais o LCD está conectado
Dentro da função de configuração , apenas iniciamos o monitor serial na taxa de transmissão de 9600 para que possamos depurar coisas e então inicializar o display LCD. Também temos que definir o contraste do display LCD, cada display funcionará melhor em um nível de contraste diferente, então brinque com o valor para verificar o que é mais adequado para você. Finalmente, também limpamos a tela para começar do zero.
void setup () { Serial.begin (9600); // Monitor serial para depuração display.begin (); // Iniciar a comunicação do LCD display.setContrast (30); // Define o contraste do display display.clearDisplay (); // limpa a tela e começa de novo }
Assim que a tela é limpa, passamos para a função de loop e exibimos a tela do jogo. A tela do jogo nada mais é do que um esqueleto básico do jogo, juntamente com a pontuação e o nível de velocidade. Usamos a função de linha para desenhar três linhas como bordas e, à direita, exibimos a pontuação e a velocidade do texto, exatamente como os antigos dispositivos de jogos portáteis retrô.
void gamescreen () { // Desenha a Borda da Tela display.drawLine (0, 0, 0, 47, PRETO); display.drawLine (50, 0, 50, 47, PRETO); display.drawLine (0, 47, 50, 47, PRETO); // Insira os textos padrão display.setTextSize (1); display.setTextColor (BLACK); display.setCursor (52,2); display.println ("Velocidade"); display.setCursor (54,12); display.println (game_speed); display.setCursor (52,25); display.println ("Pontuação"); display.setCursor (54,35); display.println (pontuação); }
Em seguida, temos que obter a entrada do usuário para permitir que ele / ela controle a nave espacial. A entrada será recebida do módulo Joystick que está conectado ao pino A1. O valor analógico do sensor será 512 se não for movido e aumentará e diminuirá quando movido ao longo do eixo X. Usamos esses valores para determinar se o usuário deseja mover para a esquerda ou para a direita. Você deve ler o tutorial de interface do Joystick com o Arduino mencionado nos pré-requisitos se achar difícil entender o programa abaixo.
// Obtém a entrada do usuário Joy_X = analogRead (A1); // Lê o valor X do Joystick if (Joy_X <312 && POS! = 1 && control == true) // Se o joystick se move para a direita {POS--; control = false;} // Diminui a posição da espaçonave else if (Joy_X> 712 && POS! = 3 && control == true) // Se o joystick se move para a direita {POS ++; control = false;} // Incrementa a posição da espaçonave else if (Joy_X> 502 && Joy_X <522) // Se o joystick volta à posição inicial control = true; // Preparar para o próximo movimento // Entrada do usuário recebida
Depois de obter a posição da nave espacial do usuário, temos que posicionar a nave naquele local específico. Usamos a função abaixo e passamos o valor da posição como parâmetro, então com base na posição a nave espacial é colocada em sua respectiva pista.
void player_car (char pos) // Coloque a nave com base na posição selecionada pelo usuário { if (pos == 1) display.drawBitmap (2, 32, ship, 15, 15, BLACK); if (pos == 2) display.drawBitmap (18, 32, navio, 15, 15, PRETO); if (pos == 3) display.drawBitmap (34, 32, navio, 15, 15, PRETO); }
Agora que nossa nave está colocada na tela e pronta para a corrida, temos que apresentar as naves inimigas que estarão competindo junto com o jogador. Cada vez que uma nave inimiga cruza a tela, presumimos que ela está morta e quando ela está morta temos que criar uma nova nave espacial. A função abaixo faz exatamente o mesmo. Ele cria uma nova posição para dois navios inimigos e os coloca no topo da tela.
if (inimigo_dead) // Verifique se os navios inimigos estão mortos {// Se eles estão mortos inimigo_0_pos = POS; // cria o primeiro inimigo acima da nave espacial inimigo_1_pos = random (0,4); // cria um segundo inimigo em algum outro lugar aleatório inimigo_phase = 0; // Traga o inimigo do topo inimigo_dead = false; // O inimigo é criado para que não morram mais }
Depois de colocar as naves inimigas no topo da tela, temos que abaixá-lo para que avance como se o nosso jogador estivesse correndo para cima, para isso basta incrementar a fase (o local onde a imagem é exibida) para que desce lentamente. O mesmo é feito para os dois navios inimigos, conforme mostrado abaixo
nave_inimigo (inimigo_0_pos, fase_inimigo); inimigo_phase ++; // Coloque o primeiro inimigo na tela e conduza-o para baixo inimigo_ship (inimigo_1_pos, inimigo_phase); inimigo_phase ++; // Coloque o inimigo secundário na tela e derrube-o
A função nave_inimigo é mostrada abaixo, é muito semelhante à função carro do jogador, mas aqui temos dois parâmetros. Um é para colocar o inimigo em uma trilha e o outro é para mover o inimigo em direção ao fundo.
void inimigo_ship (local interno, fase interna) // Coloque o navio_inimigo no novo local e fase { if (local == 1) display.drawBitmap (2, fase, inimigo, 15, 15, PRETO); if (local == 2) display.drawBitmap (18, fase, inimigo, 15, 15, PRETO); if (local == 3) display.drawBitmap (34, fase, inimigo, 15, 15, PRETO); }
A próxima parte do código deve verificar se a nave espacial evitou a nave inimiga. Para verificar isso, precisamos saber a posição das naves inimigas e da nave espacial do jogador. Já que sabemos tudo isso, só temos que verificar se a posição da nave espacial é a mesma da nave inimiga. Nós verificamos isso apenas se a nave inimiga chegou perto da nave espacial. Se o jogador não evitou o inimigo, o jogo acabou.
if (inimizade_pase> 22 && ((inimigo_0_pos == POS) - (inimigo_1_pos == POS))) // Se a nave tocar qualquer um dos inimigos game_over (); // Exibir jogo acabado
Se o jogador evitou o inimigo com sucesso, devemos matar o inimigo e dar ao jogador um ponto. Para fazer isso nós apenas verificamos se o inimigo alcançou a parte inferior da tela e se isso acontecer nós o matamos usando o código abaixo
if (fase_inimigo> 40) // Se a nave espacial escapar dos inimigos {inimigo_dead = verdadeiro; pontuação ++;} // Aumente a pontuação e mate os inimigos
Que divertido seria se não aumentarmos a dificuldade do jogo à medida que obtemos pontuações altas. Então usamos outra função que monitora a pontuação do jogador e com base na pontuação vai aumentar a velocidade do jogo. A velocidade é controlada usando a função de atraso que irá controlar o intervalo de atualização do jogo, tornando-o rápido ou lento.
void Level_Controller () // Aumenta a velocidade do jogo com base na pontuação. { if (score> = 0 && score <= 10) // If score 0-10 { game_speed = 0; atraso (80); // torna o jogo mais lento em 80ms } if (score> 10 && score <= 20) // If score 10-40 { game_speed = 1; atraso (70); // torna o jogo mais lento em 70 ms } if (score> 20 && score <= 30) // If score 20-40 { game_speed = 2; atraso (60); // torna o jogo mais lento em 60ms } if (score> 30 && score <= 40) // If score 30-40 { game_speed = 3; atraso (50); // torna o jogo mais lento em 50ms } }
Jogo Arduino Space Racer funcionando:
Depois de certificar-se de que o hardware e o programa foram compreendidos, basta construir o circuito e fazer o upload do código para a placa Arduino. Você deve observar o jogo começando conforme mostrado abaixo
Use o joystick para escapar do navio inimigo movendo para a esquerda ou direita. Para evitar cada inimigo, sua pontuação aumentará em um. Quando a pontuação aumenta, a velocidade do jogo também aumenta, ou seja, a velocidade aumenta em 10ms para cada 10 pontos marcados. Você pode ir em frente e desenvolver este jogo para introduzir novos níveis ou fazer algumas alterações no hardware para controlá-lo por meio do movimento usando um acelerômetro. A criatividade é o único limite. Para sua referência, você aprende a usar o Acelerômetro com Arduino aqui.
Espero que você tenha entendido o projeto e gostado de construí-lo. Se você tiver enfrentado qualquer problema para fazer isso funcionar, fique à vontade para postar o problema na seção de comentários abaixo ou use os fóruns para obter ajuda técnica. Jogo feliz !!
Verifique o código completo e o Vídeo de Demonstração abaixo.