Arduino - blocos de piano: 16 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Olá pessoal da internet, Isso vai ser sobre como fazer o que DEFINITIVAMENTE não é uma cópia de um jogo para celular em um arduino uno r3.

então, para começar, você vai precisar de todas as peças, que são as seguintes! 1x Arduino Uno r3 ($ 42)

2x escudo do teclado LCD ($ 19 cada)

5x botões

5x resistores de 220Ω

28x fios

Certo, uma vez que você tenha todas as peças, é hora de começar!

Etapa 1: Fiação

Comece conectando seu arduino e amigos conforme mostrado no diagrama, Certifique-se de que os botões estejam ligados da maneira correta, com os slots A0-4 no lado do solo dos trilhos dos botões, ou o arduino pensará que os botões estão sendo pressionados constantemente em vez de apenas um toque.

Etapa 2: declarações de declaração

Todo o código aqui deve ir antes de sua configuração void e loop void, isso porque todas essas variáveis e objetos são usados em várias das funções que iremos configurar.

Comece colocando:

#incluir

no topo do seu código, isso diz ao arduino para usar a biblioteca "LiquidCrystal.h" e as funções que fazem parte dela.

A próxima etapa é definir os pinos que estamos usando para nossos botões, colocando este código abaixo de nosso #include:

#define btnEnter A0 # define btn1 15 #define btn2 16 #define btn3 17 #define btn4 18

Definimos os termos btnEnter e btn1 a btn 4 para facilitar a leitura do código ou alterá-los, se necessário. Isso significa que quando digitarmos btn1, o arduino saberá que, na verdade, queremos dizer o botão 15. Embora estejamos chamando as portas de porta 15, 16, 17 e 18, elas são rotuladas no arduino como A1 A2 A3 e A4, isso porque são portas usadas especificamente para entradas analógicas, embora as utilizemos apenas para entradas digitais.

Em seguida, vamos criar os objetos que irão controlar os monitores de cristal líquido. Para fazer isso coloque este código abaixo de nossas definições

LiquidCrystal lcdLeft (8, 9, 12, 10, 11, 13); LiquidCrystal lcdRight (2, 3, 4, 5, 6, 7);

O que isso faz é dizer ao arduino que, quando chamamos lcdLeft ou lcdRight, estamos nos referindo a um objeto LiquidCrystal. Os números nos colchetes anexados informam ao arduino quais portas o objeto deve usar para enviar mensagens ao LCD quando usamos suas funções.

Agora precisamos declarar as variáveis colocando o próximo bit de código abaixo das declarações do objeto:

// essas variáveis são opções que você pode alterar - números mais altos = velocidade de jogo mais rápida upint intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// configurar variáveis para o gameboolean bolPlay; // rastreia se o jogador int intScore; // rastreia a pontuação do jogador int intDiff; // apenas uma coisa estética para dizer em que dificuldade o jogo está // configurar variáveis para input int intEnter; // rastreia se o usuário pressiona o botão Enter int intInput; // rastreia quais botões o usuário pressiona boolean bolTilePressed; // assegure-se de que o jogador não pressione acidentalmente um botão 5x e perca // as variáveis de configuração para o turn int intTick; // conta os milhões (por loop) até intDelay int intDelay; // o tempo que o programa espera até a próxima curva em milis int intGameSpeed; // um pouco das opções de depuração boolean bolSerialBoard; // quando verdadeiro irá imprimir a placa no monitor serial

Declaramos uma variável informando o tipo de dados e, em seguida, o nome da variável, ex. int thisIsAnInteger

Variáveis booleanas, como bolSerialBoard e bolPlay, podem ter apenas um de dois valores, verdadeiro ou falso.

Variáveis inteiras (int) como intScore e intInput podem aceitar números inteiros como valores, como 1, 5 ou 100.

Alguns outros tipos de dados notáveis que não estamos usando aqui são uma string, que é um pedaço de texto, e um float, que é um número decimal.

Cada uma das variáveis aqui são usadas em vários lugares diferentes pelo programa, aqui está uma sinopse do que cada uma faz

bolPlay diz ao programa se o menu deve ser exibido ou se o jogo real deve ser executado.

intScore rastreia a pontuação do jogador conforme eles atingem os ladrilhos, intDiff é usado no menu principal para dizer ao programa que trecho de texto deve ser impresso no LCD, intEnter é usado para dizer ao programa se o botão Enter (mais à esquerda) está pressionado, intInput é usado para informar ao programa qual dos outros 4 botões está pressionado.

bolTilePressed é usado para garantir que o programa só leia quando o botão é pressionado e não quando é pressionado.

intGameSpeed, intGameSpeedEasy, intGameSpeedMedium e intGameSpeedHard são usados para controlar a rapidez com que o jogo deve acelerar com base na dificuldade selecionada.

intTick e intDelay são usados para impedir que o programa mova a placa toda vez que ele faz um loop.

bolSerialBoard é usado para permitir que o programa envie a placa para o monitor serial do arduino como uma série de números para fins de teste.

Finalmente, é hora de declarar nossa placa como uma matriz usando este código:

// configurar jogo arrayint arrGame [16] [4] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};

Um array é uma matriz que contém qualquer ponto no qual pode ser chamado para matemática ou para ser alterado.

Seu código agora deve ser parecido com isto;

// incluir bibliotecas # incluir

// essas variáveis são opções que você pode alterar - números mais altos = maior velocidade do jogo

int intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// Definir pinos

#define btnEnter A0 #define btn1 15 #define btn2 16 #define btn3 17 #define btn4 18

// cria objetos LCD (n, ~, n, ~, ~, n)

LiquidCrystal lcdLeft (8, 9, 12, 10, 11, 13); LiquidCrystal lcdRight (2, 3, 4, 5, 6, 7);

// configurar a matriz do jogo

int arrGame [16] [4] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};

// configurar variáveis para o jogo

boolean bolPlay; // rastreia se o jogador int intScore; // rastreia a pontuação do jogador int intDiff; // apenas uma coisa estética para dizer em que dificuldade o jogo está

// configurar variáveis para entrada

int intEnter; // rastreia se o usuário pressiona o botão Enter int intInput; // rastreia quais botões o usuário pressiona boolean bolTilePressed; // garante que o jogador não pressione acidentalmente um botão 5x e perca

// configurar variáveis para turno

int intTick; // conta os milhões (por loop) até intDelay int intDelay; // o tempo que o programa espera até a próxima curva em milis int intGameSpeed;

// um pouco das opções de depuração

boolean bolSerialBoard; // quando verdadeiro irá imprimir a placa no monitor serial

Etapa 3: A função de configuração

O loop de configuração é uma função lida pelo arduino apenas uma vez, ao iniciar pela primeira vez.

No loop de configuração, estamos apenas definindo os valores de algumas de nossas variáveis porque, em vez de definir um valor para elas ao declará-las, estamos fazendo isso aqui.

Comece colocando este código em sua configuração de void.

bolPlay = falso; intScore = 0; intTick = 0; intDelay = 1000; IntDiff = 1; intGameSpeed = intGameSpeedMedium;

Cada linha está apenas configurando uma variável para um valor.

bolPlay é definido como falso para que o jogo não comece a ser reproduzido.

intScore é definido como 0, porque naturalmente sua pontuação começa em 0.

intTick começa em 0 porque o programa não está contando nada no momento.

intDelay é definido como 1000 porque essa é a taxa na qual os blocos começam.

intDiff é apenas uma coisa ascética para que o programa saiba o que escrever para a dificuldade do jogo.

intGameSpeed é definido como qualquer intGameSpeedMedium, o que significa que é definido como dificuldade média.

Em seguida, coloque este código em Void Setup abaixo do código que você acabou de inserir.

lcdLeft.begin (16, 2); lcdRight.begin (16, 2);

Serial.begin (9600);

Isso diz ao arduino para começar a se comunicar com o computador por meio do monitor serial (visível ao clicar no botão no canto superior direito do IDE do arduino).

Sua configuração de vazio agora deve ser parecida com isto!

void setup () {Serial.begin (9600); // inicia o monitor serial // configura as variáveis bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; IntDiff = 1; intGameSpeed = intGameSpeedMedium; // começar lcdLeft.begin (16, 2) do lcd; lcdRight.begin (16, 2); }

Etapa 4: a função de loop

A função de loop é executada pelo arduino a cada iteração do arduino.

Copie o seguinte código em seu Void Loop.

loop void () {input (); // verifique se há entrada de jogo if (bolPlay == true) {if (intTick> = intDelay) {// verifique se o jogo deve ser jogado ou continue aguardando Serial.println ("~~~~~~~~ ~~ "); // imprime para indicar que o tabuleiro está se movendo // writeSerial (); // se a opção estiver habilitada, escreva a placa em serial buttonsGame (); // verifica as entradas do jogador playBoard (); // move o tabuleiro e adiciona um novo ladrilho clearLcd (); // limpe os LCDs antes de desenhar drawBoard (); // desenhe a placa no bottomCheck () do lcd; intTick = 0; // redefine intTick} else {buttonsGame (); // verificar as entradas do jogador clearLcd (); // limpe os LCDs antes de desenhar drawBoard (); // desenhe o tabuleiro no lcd intTick = intTick + intGameSpeed; // adiciona ao tique}} else {clearLcd (); // limpe os LCDs antes de desenhar title (); // exibe o título e as informações da pontuação buttonsMenu (); // lê a entrada do jogador clearBoard (); // garante a placa inteira = 0} delay (10); // atrasar o arduino por um breve momento}

quando bolPlay é igual a true, significa que o jogo está sendo executado e todo o código para quando o jogo está sendo executado deve ser executado, mas só queremos que o tabuleiro adicione uma nova peça e desça quando intTick for maior que nosso intDelay, caso contrário, ainda queremos permitir que o usuário pressione um botão para acertar um bloco e para intTick aumentar a velocidade.

A maior parte desse código usa funções que ainda não criamos, e as faremos nas próximas etapas. O objetivo dessas funções é o seguinte.

A entrada lê quais botões o usuário pressionou.

buttonsGame controla o que os botões fazem quando estão no jogo, e não no menu

playBoard adiciona uma nova peça ao tabuleiro e, em seguida, move tudo no tabuleiro para baixo um espaço

clearLCD limpa os LCDs para garantir que nenhum fantasma seja deixado para trás dos ladrilhos

drawBoard passa por arrGame e o imprime nos LCDs

clearBoard limpa todo o arrGame quando o jogo não está em jogo

bottomCheck verifica o final do arrGame para uma condição de falha

título exibe o título do jogo e informações de pontuação quando no menu

O menu de botões controla o que as entradas do usuário fazem quando estão no menu.

gameOver é outra função, embora não seja chamada aqui, pois é chamada nas funções bottomCheck e buttonsGame.

Etapa 5: A Função ClearLCD

para criar uma função, começamos adicionando-a ao código

void functionName () {

}

o "functionName" pode ser qualquer coisa, desde que ainda não exista.

Copie este código em seu programa:

void clearLcd () {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 1; ii ++) {lcdLeft.setCursor (i, ii); lcdLeft.write (""); lcdRight.setCursor (i, ii); lcdRight.write (""); }}}

isso percorre todo o array usando 2 loops contados para passar por cada ponto nos LCDs e escrever um espaço.

Sem ser redefinido para nada, o LCD manterá tudo o que foi escrito anteriormente

Etapa 6: a função DrawBoard

copie este código em seu programa

void drawBoard () {for (int i = 1; i <= 15; i ++) {// desenha os collums 1 e 2 no LCD esquerdo // se o bloco = 0 não escreve nada, = 1 escreve "#", = 2 escreva "@" lcdLeft.setCursor (i, 1); // definido para a primeira coluna (mais à esquerda) if (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // definido para a segunda coluna (centro esquerdo) if (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // definir para a terceira coluna (centro à direita) if (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // definido para a quarta coluna (mais à direita) if (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.escrever("@");} } }

isso usa um loop para percorrer cada linha do quadro, em seguida, verifica se alguma coluna na linha é igual a 1 ou 2, com base nisso, ele então imprime no LCD uma hashtag, para um bloco ainda a ser hit, ou um @ para um bloco de acerto.

Etapa 7: a função PlayBoard

copie este código em seu programa.

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // limpar a linha superior arrGame [0] [random (0, 4)] = 1; // define um ponto aleatório na linha superior para ser um ladrilho para (int i = 15; i> = 1; i -) {// trabalhando da parte inferior do tabuleiro para o topo para (int ii = 0; ii <= 3; ii ++) {// para cada colum arrGame [ii] = arrGame [i - 1] [ii]; }}}

este código começa limpando toda a linha superior para 0, ou nenhum ladrilho, e então define um ladrilho aleatório como 1 e não acerta.

Em seguida, ele passa por um loop contado ao contrário, de 15 a 1, definindo a linha como igual ao que quer que a linha acima seja igual, fazendo com que o tabuleiro se mova para baixo no LCD

Etapa 8: A função ClearBoard

copie este código em seu programa.

void clearBoard () {// redefine os valores de tique e atraso intTick = 0; intDelay = 1000; // vá até o tabuleiro e defina tudo como 0 para (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

Este código é executado quando o jogo não está sendo reproduzido, para garantir que todo o arrGame esteja definido como 0, ou nenhuma peça, usando loops contados para percorrer a matriz.

O código também redefine os valores de intDelay e intTick.

Etapa 9: a função de título

copie o seguinte código em seu programa

void title () {// escreve o título no LCD e espaço para a pontuação lcdRight.setCursor (0, 0); lcdRight.write ("Ladrilhos de piano"); lcdRight.setCursor (0, 1); lcdRight.write ("Pontuação:"); // converte a pontuação em uma string char strScore [3]; sprintf (strScore, "% d", intScore); // exibe a pontuação no LCD lcdRight.write (strScore); // adicione o diffictuly lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write ("Fácil"); } if (intDiff == 1) {lcdRight.write ("Médio"); } if (intDiff == 2) {lcdRight.write ("Hard"); } // Pressione um pouco da instrução lcdLeft.setCursor (0, 0); lcdLeft.write ("Pressione Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write ("para começar!"); }

Este código grava o título do jogo e a pontuação nos LCDs, ele informa ao LCD onde começar a digitar usando LCD.setCursor e, em seguida, escreve a string em LCD.write.

Uma nova variável também é criada aqui, strScore, é usada para converter intScore em uma string ou tipo de dados char usando a função sprintf.

intDiff também é usado aqui, com base em seus valores ele imprime as diferentes opções de dificuldade.

Etapa 10: a função ButtonsMenu

insira o seguinte código em seu programa

void buttonsMenu () {// quando enter é pressionado, inicia o jogo e redefine o valor da pontuação if (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // quando o botão 3 é pressionado ativa a opção de depuração de impressão da placa em série if (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Placa serial ativa"); bolSerialBoard = true; } else {Serial.println ("Placa serial desativada"); bolSerialBoard = false; }} // define a velocidade do jogo para dificuldade fácil if (intInput == 0) {Serial.print ("Jogo definido para fácil ("); Serial.print (intGameSpeedEasy); Serial.println ("aceleração ms)"); IntDiff = 0; intGameSpeed = intGameSpeedEasy; } // define a velocidade do jogo para dificuldade média if (intInput == 1) {Serial.print ("Jogo definido para médio ("); Serial.print (intGameSpeedMedium); Serial.println ("aceleração ms)"); IntDiff = 1; intGameSpeed = intGameSpeedMedium; } // define a velocidade do jogo para dificuldade difícil if (intInput == 2) {Serial.print ("Jogo definido para difícil ("); Serial.print (intGameSpeedHard); Serial.println ("aceleração ms)"); IntDiff = 2; intGameSpeed = intGameSpeedHard; }}

este código só é executado quando bolPlay é igual a false no void Loop

se intEnter estiver definido como 1, significa que o botão Enter foi pressionado; se estiver sendo pressionado, o programa define bolPlay como verdadeiro e o jogo é iniciado.

O programa então lê a que intInput é igual. se for igual a 0 o primeiro botão da esquerda está sendo pressionado, subindo para a direita até 3. Se intInput for igual a 4 nenhum botão está sendo pressionado.

se os botões 0-2 forem pressionados, o jogo mudará a dificuldade, ajustando também o valor da velocidade do jogo, o que significa que irá acelerar mais rápido.

se o botão 3 for pressionado, o jogo ativará ou desativará um modo de depuração em que todo o tabuleiro é impresso no monitor serial para auxiliar na localização de problemas no programa.

Etapa 11: A função ButtonsGame

copie o seguinte código em seu programa

void buttonsGame () {if (intInput! = 4) {// se um botão for pressionado if (bolTilePressed == false) {// somente se bolTilePressed for uma ação de gatilho falsa para verificar um botão, pressione bolTilePressed = true; // em seguida, defina bolTilePressed como true para certificar-se de que não seja disparado acidentalmente novamente int intLowestTile = 0; // a ser definido para o ladrilho com o ladrilho mais baixo int intCheckedTile = 15; // para manter o controle de quais blocos foram verificados while (intLowestTile == 0) {// contanto que não esteja definido para nada, verifique os blocos para (int i = 0; i 100) {// contanto que int o atraso não é inferior a 100 intDelay = intDelay - 20; // obtém um valor dele}} else {Serial.println ("Botão errado pressionado"); fim de jogo(); // caso contrário, o jogo acaba}}}}}

O código só é executado quando bolPlay é igual a true no void Loop.

Como o buttonsMenu baseado no valor de intInput, ele verifica se o jogador acertou uma peça ou errou uma.

Ele faz isso percorrendo arrGame de baixo para cima usando um loop while para procurar qual linha é a mais baixa com um bloco não atingido. Em seguida, verifica se o local na linha correspondente ao botão pressionado é uma peça não acertada ou não, se não for acertada, define-o como 2 em vez de 1, o que significa que será exibido como um @, caso contrário, aciona o gameOver função que ainda devemos criar.

Essa função também utiliza a variável bolTilePressed definindo-a como true quando um botão é pressionado e false quando nenhum botão é pressionado. Isso é para garantir que o usuário não perca acidentalmente o jogo porque o programa pensou que ele pressionou o botão várias vezes ao mantê-lo pressionado.

Etapa 12: A função GameOver

Copie o seguinte código em seu programa

void gameOver () {Serial.println ("Game Over!"); Serial.print ("Sua pontuação foi:"); Serial.println (intScore); Serial.print ("Sua velocidade era:"); Serial.println (intDelay); bolPlay = false; }

Isso é acionado pelas funções checkBottom ou buttonsGame e aciona o final do jogo definindo bolPlay como falso.

Ele também imprime uma mensagem no monitor serial para a pontuação do usuário e os blocos de velocidade foram adicionados em milissegundos.

Etapa 13: A função de entrada

Copie o seguinte código em seu programa.

void input () {intEnter = digitalRead (btnEnter); // leia digite // leia qual das outras entradas, ou se nenhuma for definida como 4 if (digitalRead (btn1) == HIGH) {intInput = 0;} else {if (digitalRead (btn2) == HIGH) {intInput = 1;} else {if (digitalRead (btn3) == HIGH) {intInput = 2;} else {if (digitalRead (btn4) == HIGH) {intInput = 3;} else {intInput = 4; }}}} // serial imprime as entradas if (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } else {// se nenhum botão for pressionado reset bolTilePressed bolTilePressed = false; }}

Este código é usado com as funções buttonsGame e buttonsMenu. com base nos botões que o usuário pressionou, ele define o valor de intInput ou, se nenhum botão for pressionado, define intInput como igual a 4.

Se nenhum botão for pressionado, é aqui que bolTilePressed é redefinido para a função buttonsGame.

Ele também imprime uma mensagem para o monitor serial no qual o botão é pressionado.

Etapa 14: A função BottomCheck

copie o código a seguir para o seu programa.

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// para as 4 colunas if (arrGame [15] == 1) {// se um bloco está na parte inferior Serial.println ("Bloco na parte inferior"); arrGame [15] = 2; drawBoard (); atraso (400); arrGame [15] = 1; drawBoard (); atraso (400); arrGame [15] = 2; drawBoard (); atraso (400); arrGame [15] = 1; drawBoard (); atraso (400); fim de jogo(); }}}

usando um loop, este código verifica a linha inferior do arrGame para quaisquer peças não acertadas (peças iguais a 1), se houver uma peça não acertada na parte inferior da tela, ele irá piscar a peça e então acionar a função game over.

Etapa 15: a função WriteSerial

copie o seguinte código em seu programa

void writeSerial () {if (bolSerialBoard == true) {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {Serial.print (arrGame [ii]); Serial.print (","); } Serial.println (""); }}}

Esta é a função seguida pela opção de depuração que pode ser habilitada na função buttonsMenu. Se bolSerialBoard for definido como true nessa função, ele passará por arrGame e imprimirá toda a placa no monitor serial para fins de teste usando um array.

Etapa 16: Conclusão

Todo o seu código não deve estar completo e parecer algo assim!

/ * * Nome - Piano Tiles; Arduino * Por - Domenic Marulli * Data - 11 / *

/ incluir bibliotecas

#incluir

// essas variáveis são opções que você pode alterar - números mais altos = maior velocidade do jogo

int intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// Definir pinos

#define btnEnter A0 #define btn1 15 #define btn2 16 #define btn3 17 #define btn4 18

// cria objetos LCD (n, ~, n, ~, ~, n)

LiquidCrystal lcdLeft (8, 9, 12, 10, 11, 13); LiquidCrystal lcdRight (2, 3, 4, 5, 6, 7);

// configurar a matriz do jogo

int arrGame [16] [4] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};

// configurar variáveis para o jogo

boolean bolPlay; // rastreia se o jogador int intScore; // rastreia a pontuação do jogador int intDiff; // apenas uma coisa estética para dizer em que dificuldade o jogo está

// configurar variáveis para entrada

int intEnter; // rastreia se o usuário pressiona o botão Enter int intInput; // rastreia quais botões o usuário pressiona boolean bolTilePressed; // garante que o jogador não pressione acidentalmente um botão 5x e perca

// configurar variáveis para turno

int intTick; // conta os milhões (por loop) até intDelay int intDelay; // o tempo que o programa espera até a próxima curva em milis int intGameSpeed;

// um pouco das opções de depuração

boolean bolSerialBoard; // quando verdadeiro irá imprimir a placa no monitor serial

// a configuração que será executada uma vez

void setup () {Serial.begin (9600); // inicia o monitor serial // configura as variáveis bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; IntDiff = 1; intGameSpeed = intGameSpeedMedium; // começar lcdLeft.begin (16, 2) do lcd; lcdRight.begin (16, 2); }

// o loop que será executado a cada 10 milissegundos

loop void () {input (); // verifique se há entrada de jogo if (bolPlay == true) {if (intTick> = intDelay) {// verifique se o jogo deve ser jogado ou continue aguardando Serial.println ("~~~~~~~~ ~~ "); // imprime para indicar que o tabuleiro está se movendo // writeSerial (); // se a opção estiver habilitada, escreva a placa em serial buttonsGame (); // verifica as entradas do jogador playBoard (); // move o tabuleiro e adiciona um novo ladrilho clearLcd (); // limpe os LCDs antes de desenhar drawBoard (); // desenhe a placa no bottomCheck () do lcd; intTick = 0; // redefine intTick} else {buttonsGame (); // verificar as entradas do jogador clearLcd (); // limpe os LCDs antes de desenhar drawBoard (); // desenhe o tabuleiro no lcd intTick = intTick + intGameSpeed; // adiciona ao tique}} else {clearLcd (); // limpe os LCDs antes de desenhar title (); // exibe o título e as informações da pontuação buttonsMenu (); // lê a entrada do jogador clearBoard (); // garante a placa inteira = 0} delay (10); // atrasar o arduino por um breve momento}

// limpa o lcd, para que as células não inseridas não sejam deixadas lá

void clearLcd () {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 1; ii ++) {lcdLeft.setCursor (i, ii); lcdLeft.write (""); lcdRight.setCursor (i, ii); lcdRight.write (""); }}}

// desenha o tabuleiro no LCD

void drawBoard () {for (int i = 1; i <= 15; i ++) {// desenha os collums 1 e 2 no LCD esquerdo // se o bloco = 0 não escreve nada, = 1 escreve "#", = 2 escreva "@" lcdLeft.setCursor (i, 1); // definido para a primeira coluna (mais à esquerda) if (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // definido para a segunda coluna (centro esquerdo) if (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // definir para a terceira coluna (centro à direita) if (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // definido para a quarta coluna (mais à direita) if (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.escrever("@");} } }

// move o tabuleiro para baixo e coloca um valor aleatório para ser uma peça

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // limpar a linha superior arrGame [0] [random (0, 4)] = 1; // define um ponto aleatório na linha superior para ser um ladrilho para (int i = 15; i> = 1; i -) {// trabalhando da parte inferior do tabuleiro para o topo para (int ii = 0; ii <= 3; ii ++) {// para cada colum arrGame [ii] = arrGame [i - 1] [ii]; }}}

// define todo o tabuleiro para 0 e redefine as variáveis para pré-jogo

void clearBoard () {// redefine os valores de tique e atraso intTick = 0; intDelay = 1000; // vá até o tabuleiro e defina tudo como 0 para (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

// exibe o menu principal no LCD

void title () {// escreve o título no LCD e espaço para a pontuação lcdRight.setCursor (0, 0); lcdRight.write ("Ladrilhos de piano"); lcdRight.setCursor (0, 1); lcdRight.write ("Pontuação:"); // converte a pontuação em uma string char strScore [3]; sprintf (strScore, "% d", intScore); // exibe a pontuação no LCD lcdRight.write (strScore); // adicione o diffictuly lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write ("Fácil"); } if (intDiff == 1) {lcdRight.write ("Médio"); } if (intDiff == 2) {lcdRight.write ("Hard"); } // Pressione um pouco da instrução lcdLeft.setCursor (0, 0); lcdLeft.write ("Pressione Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write ("para começar!"); }

// verifica os botões e o que fazer com eles enquanto estiver fora do jogo

void buttonsMenu () {// quando enter é pressionado, inicia o jogo e redefine o valor da pontuação if (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // quando o botão 3 é pressionado ativa a opção de depuração de impressão da placa em série if (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Placa serial ativa"); bolSerialBoard = true; } else {Serial.println ("Placa serial desativada"); bolSerialBoard = false; }} // define a velocidade do jogo para dificuldade fácil if (intInput == 0) {Serial.print ("Jogo definido para fácil ("); Serial.print (intGameSpeedEasy); Serial.println ("aceleração ms)"); IntDiff = 0; intGameSpeed = intGameSpeedEasy; } // define a velocidade do jogo para dificuldade média if (intInput == 1) {Serial.print ("Jogo definido para médio ("); Serial.print (intGameSpeedMedium); Serial.println ("aceleração ms)"); IntDiff = 1; intGameSpeed = intGameSpeedMedium; } // define a velocidade do jogo para dificuldade difícil if (intInput == 2) {Serial.print ("Jogo definido para difícil ("); Serial.print (intGameSpeedHard); Serial.println ("aceleração ms)"); IntDiff = 2; intGameSpeed = intGameSpeedHard; }}

// verifica os botões e o que fazer com eles durante o jogo

void buttonsGame () {if (intInput! = 4) {// se um botão for pressionado if (bolTilePressed == false) {// somente se bolTilePressed for uma ação de gatilho falsa para verificar um botão, pressione bolTilePressed = true; // em seguida, defina bolTilePressed como true para garantir que ele não seja disparado acidentalmente novamente int intLowestTile = 0; // a ser definido como o ladrilho com o ladrilho mais baixo int intCheckedTile = 15; // para manter o controle de quais blocos foram verificados while (intLowestTile == 0) {// contanto que não esteja definido para nada, verifique os blocos para (int i = 0; i 100) {// contanto que int o atraso não é inferior a 100 intDelay = intDelay - 20; // obtém um valor dele}} else {Serial.println ("Botão errado pressionado"); fim de jogo(); // caso contrário, o jogo acaba}}}}}

void gameOver () {

Serial.println ("Fim do jogo!"); Serial.print ("Sua pontuação foi:"); Serial.println (intScore); Serial.print ("Sua velocidade era:"); Serial.println (intDelay); bolPlay = false; }

// verifica a entrada do jogador

void input () {intEnter = digitalRead (btnEnter); // leia digite // leia qual das outras entradas, ou se nenhuma for definida como 4 if (digitalRead (btn1) == HIGH) {intInput = 0;} else {if (digitalRead (btn2) == HIGH) {intInput = 1;} else {if (digitalRead (btn3) == HIGH) {intInput = 2;} else {if (digitalRead (btn4) == HIGH) {intInput = 3;} else {intInput = 4; }}}} // serial imprime as entradas if (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } else {// se nenhum botão for pressionado reset bolTilePressed bolTilePressed = false; }}

// verifica a parte inferior do tabuleiro em busca de falhas

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// para as 4 colunas if (arrGame [15] == 1) {// se um bloco está na parte inferior Serial.println ("Bloco na parte inferior"); arrGame [15] = 2; drawBoard (); atraso (400); arrGame [15] = 1; drawBoard (); atraso (400); arrGame [15] = 2; drawBoard (); atraso (400); arrGame [15] = 1; drawBoard (); atraso (400); fim de jogo(); }}}

// imprime a placa no monitor serial se bolSerialBoard for verdadeiro

void writeSerial () {if (bolSerialBoard == true) {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {Serial.print (arrGame [ii]); Serial.print (","); } Serial.println (""); }}}

Depois de inserir todo o código, faça o upload para o seu arduino e divirta-se!