Construa um Jogo da Velha com Arduino em Touchscreen: Tutorial Passo a Passo

Componentes e Materiais

Arduino UNO	×	1
Touchscreen 2,8"	×	1

Aplicativos e Serviços Online

• Arduino IDE

Sobre o Projeto

Olá amigos, bem-vindos a mais um tutorial Arduino! Neste tutorial detalhado, vamos construir um jogo da velha (Tic-Tac-Toe) com Arduino. Como podem ver, estamos usando uma tela touchscreen e jogando contra o computador. Um jogo simples como a velha é uma excelente introdução à programação de jogos e inteligência artificial. Embora não utilizemos algoritmos de IA propriamente ditos, entenderemos por que eles são necessários em jogos mais complexos.

Desenvolver jogos para Arduino não é fácil e exige bastante tempo. Porém, podemos criar jogos simples porque é divertido e nos permite explorar tópicos avançados de programação, como inteligência artificial. É uma ótima experiência de aprendizado e, no final, você terá um jogo bacana para as crianças!

Vamos começar a construir este projeto.

Passo 1: Obtenha Todas as Peças

As peças necessárias para construir este projeto são:

• Um Arduino Uno
• Uma Touchscreen 2,8"

O custo do projeto é muito baixo: apenas $15.

Antes de tentar construir este projeto, assista ao vídeo que preparei sobre o display touchscreen clicando no card aqui. Isso ajudará você a entender o código e calibrar a tela touchscreen.

Passo 2: O Display Touch Colorido 2,8" para Arduino

Descobri esta touchscreen no banggood.com e decidi comprá-la para testar em alguns projetos. Como podem ver, o display é barato, custa cerca de $11.

Compre aqui.

O display oferece resolução de 320x240 pixels e vem como um shield, o que torna a conexão com o Arduino extremamente fácil. O display usa quase todos os pinos digitais e analógicos do Arduino Uno. Ao usar este shield, sobram apenas 2 pinos digitais e 1 pino analógico para nossos projetos. Felizmente, o display funciona bem com o Arduino Mega também, então quando precisarmos de mais pinos, podemos usar o Mega em vez do Uno. Infelizmente, este display não funciona com o Arduino Due ou a placa Wemos D1 ESP8266. Outra vantagem do shield é que ele oferece um slot para micro SD, muito fácil de usar.

Passo 3: Montando o Projeto e Testando

Após conectar a tela ao Arduino Uno, podemos carregar o código e estamos prontos para jogar.

Primeiro, pressionamos o botão "Iniciar Jogo" e o jogo começa. O Arduino joga primeiro. Podemos então fazer nossa jogada simplesmente tocando a tela. O Arduino faz sua jogada e assim por diante. O jogador que conseguir colocar três de suas marcas em uma linha horizontal, vertical ou diagonal vence o jogo. Quando o jogo termina, a tela "Fim de Jogo" aparece. Podemos pressionar o botão "Jogar Novamente" para reiniciar.

O Arduino é muito bom neste jogo. Ele vencerá a maioria das partidas, ou, se você for um jogador muito bom, o jogo terminará em empate. Projetei intencionalmente o algoritmo para cometer alguns erros, dando ao jogador humano uma chance de vencer. Adicionando apenas duas linhas ao código, podemos tornar o Arduino imbatível. Mas como um chip de $2, a CPU do Arduino, pode vencer o cérebro humano? O programa que desenvolvemos é mais inteligente que o cérebro humano?

Passo 4: O Algoritmo do Jogo

Para responder a essa pergunta, vamos analisar o algoritmo implementado.

O computador sempre joga primeiro. Esta decisão por si só torna o jogo muito mais fácil para o Arduino vencer. A primeira jogada é sempre um canto. A segunda jogada do Arduino também é um canto aleatório dos restantes, sem se importar com a jogada do jogador. A partir deste ponto, o Arduino primeiro verifica se o jogador pode vencer na próxima jogada e bloqueia esse movimento. Se o jogador não puder vencer em uma única jogada, ele joga em um canto se disponível ou aleatoriamente nos restantes. É isso: este algoritmo simples pode vencer o jogador humano sempre ou, no pior caso, resultar em empate. Este não é o melhor algoritmo para jogo da velha, mas um dos mais simples.

Este algoritmo pode ser implementado no Arduino facilmente, porque o jogo da velha é muito simples e podemos analisá-lo e resolvê-lo facilmente. Se projetarmos a árvore do jogo, podemos descobrir estratégias vencedoras e implementá-las facilmente no código ou deixar a CPU calcular a árvore do jogo em tempo real e escolher a melhor jogada por si mesma. Claro, o algoritmo que usamos neste jogo é muito simples, porque o jogo é muito simples. Se tentarmos projetar um algoritmo vencedor para xadrez, mesmo com o computador mais rápido não conseguiríamos calcular a árvore do jogo em mil anos! Para jogos assim, precisamos de outra abordagem: precisamos de algoritmos de Inteligência Artificial e, claro, enorme poder de processamento. Mais sobre isso em um futuro vídeo.

Passo 5: Código do Projeto

Vamos dar uma olhada rápida no código do projeto. Precisamos de três bibliotecas para que o código compile:

• Adafruit TFTLCD Modificada
• Adafruit GFX
• Touchscreen

Como podem ver, mesmo um jogo simples como este requer mais de 600 linhas de código. O código é complexo, então não tentarei explicá-lo em um tutorial curto. Mostrarei a implementação do algoritmo para as jogadas do Arduino.

Primeiro, jogamos dois cantos aleatórios:

int firstMoves[]={0,2,6,8}; // usaremos estas posições primeiro
for(counter=0;counter<4;counter++) // Conta primeiras jogadas
{
  if(board[firstMoves[counter]]!=0) // Primeira jogada feita por alguém
  {
    movesPlayed++;
  }
}
do{
  if(moves<=2)
  {
    int randomMove = random(4);
    int c = firstMoves[randomMove];
    if (board[c]==0)
    {
      delay(1000);
      board[c]=2;
      Serial.print(firstMoves[randomMove]);
      Serial.println();
      drawCpuMove(firstMoves[randomMove]);
      b=1;
    }
  }

Em seguida, a cada rodada verificamos se o jogador pode vencer na próxima jogada:

int checkOpponent()
{
  if(board[0]==1 && board[1]==1 && board[2]==0) return 2;
  else if(board[0]==1 && board[1]==0 && board[2]==1) return 1;
  else if (board[1]==1 && board[2]==1 && board[0]==0) return 0;
  else if (board[3]==1 && board[4]==1 && board[5]==0) return 5;
  else if (board[4]==1 && board[5]==1 && board[3]==0) return 3;
  else if (board[3]==1 && board[4]==0 && board[5]==1) return 4;
  else if (board[1]==0 && board[4]==1 && board[7]==1) return 1;
  else return 100;
}

Se sim, bloqueamos essa jogada, na maioria das vezes. Não bloqueamos todas as jogadas para dar chance ao jogador humano de vencer. Consegue descobrir quais jogadas não são bloqueadas? Após bloquear, jogamos um canto restante ou uma jogada aleatória. Você pode estudar o código e implementar seu próprio algoritmo imbatível facilmente. Como sempre, o código do projeto está anexado a este tutorial.

NOTA: Como a Banggood oferece o mesmo display com dois drivers diferentes, se o código acima não funcionar, altere a função initDisplay para:

void initDisplay() {
  tft.reset();
  tft.begin(0x9341);
  tft.setRotation(3);
}

graphics.c
TicTacToeEasy.ino

Passo 6: Considerações Finais e Melhorias

Como podem ver, mesmo com um Arduino Uno, podemos construir um algoritmo imbatível para jogos simples. Este projeto é ótimo porque é fácil de construir e, ao mesmo tempo, uma excelente introdução à inteligência artificial e programação de jogos. Tentarei construir projetos mais avançados com inteligência artificial no futuro usando o Raspberry Pi, mais poderoso. Fiquem ligados! Adoraria ouvir sua opinião sobre este projeto.

Deixe seus comentários abaixo e não esqueça de curtir o tutorial se achou interessante. Obrigado!

Código

Trecho de Código #1

int firstMoves[]={0,2,6,8}; // will use these positions first
for(counter=0;counter<4;counter++) //Count first moves played
{
  if(board[firstMoves[counter]]!=0)
  {
    movesPlayed++;
  }
}
do{
  if(moves<=2)
  {
    int randomMove =random(4);
    int c=firstMoves[randomMove];
    if (board[c]==0)
    {
      delay(1000);
      board[c]=2;
      Serial.print(firstMoves[randomMove]);
      Serial.println();
      drawCpuMove(firstMoves[randomMove]);
      b=1;
    }
  }

Trecho de Código #2

int checkOpponent()
{
  if(board[0]==1 && board[1]==1 && board[2]==0) return 2;
  else if(board[0]==1 && board[1]==0 && board[2]==1) return 1;
  else if (board[1]==1 && board[2]==1 && board[0]==0) return 0;
  else if (board[3]==1 && board[4]==1 && board[5]==0) return 5;
  else if (board[4]==1 && board[5]==1 && board[3]==0) return 3;
  else if (board[3]==1 && board[4]==0 && board[5]==1) return 4;
  else if (board[1]==0 && board[4]==1 && board[7]==1) return 1;
  else return 100;
}

Links Úteis

• Biblioteca Adafruit GFX (GitHub)
• Biblioteca Touch Screen (GitHub)