Jogo Da Velha Jogos

O tabuleiro 3x3 é mais traiçoeiro do que parece quando você tenta programar uma IA para ele

Vou direto ao ponto. Jogo da velha jogos simples à primeira vista, mas criar uma versão jogável que não seja apenas um monte de condicionais if/else funciona melhor do que você imagina. A maioria dos iniciantes tenta codificar todas as combinações de vitória manualmente, e isso resulta em três linhas de código e dez condicionais que ninguém consegue manter. A estrutura básica é um array de nove posições. Cada posição vai de 0 a 8, lida da esquerda para a direita e de cima para baixo. Jogador X marca com 1, jogador O com -1, e posições vazias ficam como 0. As linhas vencedoras são fixas: (0,1,2), (3,4,5), (6,7,8) para horizontais; (0,3,6), (1,4,7), (2,5,8) para verticais; e (0,4,8), (2,4,6) para diagonais. São oito combinações no total. Nada mais.

Jogo da velha jogos: implementando a lógica com Minimax

O algoritmo Minimax resolve o jogo inteiro. Não é mágica, é recursão pura. A função avalia cada movimento possível, atribui um valor numérico, e escolhe o caminho que maximiza o pontuação do jogador atual enquanto minimiza a do oponente. Para o jogador X, que quer vencer, o algoritmo busca o maior valor. Para o jogador O, que quer evitar a derrota, busca o menor. O valor das folhas da árvore de decisão funciona assim: vitória do X dá +10, vitória do O dá -10, e empate dá 0. Como o X sempre move primeiro na ramificação, cada nível alterna entre maximizar e minimizar. A profundidade máxima da árvore é de nove níveis no pior caso, o que significa aproximadamente 362.880 nós visitados no total. Computador comum resolve isso em menos de um segundo. Eu tive um problema específico com isso recentemente. Quando implementei o Minimax sem considerar a profundidade, a IA sempre escolhia o movimento que levava ao empate mais rápido em vez de uma vitória mais demorada. Para um jogo tão simples isso não faria diferença prática, mas se você quiser criar diferentes níveis de dificuldade, precisa penalizar empates precoces e premiar vitórias mais longas. A correção foi subtrair a profundidade atual do valor da folha: vitória em três movimentos vira +7, vitória em cinco movimentos vira +5. Assim a IA prefere adiar o empate quando não pode ganhar.

O código em si é bastante enxuto. Aqui vai uma implementação funcional em JavaScript: let board = [0, 0, 0, 0, 0, 0, 0, 0, 0];
let lines = [[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[2,5,8],[0,4,8],[2,4,6]]; function checkWinner(b) {
  for (let line of lines) {
    let [a, c, d] = line;
    if (b[a] && b[a] === b[c] && b[a] === b[d]) return b[a];
  }
  return 0;
}

function minimax(b, depth, isMaximizing) {
  let winner = checkWinner(b);
  if (winner === 1) return 10 - depth;
  if (winner === -1) return depth - 10;
  if (!b.includes(0)) return 0;
  if (isMaximizing) {
    let best = -Infinity;
    for (let i = 0; i < 9; i++) {
      if (b[i] === 0) {
        b[i] = 1;
        best = Math.max(best, minimax(b, depth + 1, false));
        b[i] = 0;
      }
    }
    return best;
  } else {
    let best = Infinity;
    for (let i = 0; i < 9; i++) {
      if (b[i] === 0) {
        b[i] = -1;
        best = Math.min(best, minimax(b, depth + 1, true));
        b[i] = 0;
      }
    }
    return best;
  }
} function bestMove() {
  let bestScore = -Infinity;
  let move = -1;
  for (let i = 0; i < 9; i++) {
    if (board[i] === 0) {
      board[i] = 1;
      let score = minimax(board, 0, false);
      board[i] = 0;
      if (score > bestScore) { bestScore = score; move = i; }
    }
  }
  return move;
} Esse código já é suficiente para uma IA invencível. Se você quiser expor isso em uma página web, basta criar o grid com botões ou divs clicáveis, chamar o checkWinner após cada jogada humana, e depois disparar o bestMove() para o turno da máquina. O render do tabuleiro pode ser feito com um simples loop que itera sobre o array e preenche as células.

Existem limitações que vale anotar antes de levar isso para produção. O Minimax puro é inviável para variantes maiores do jogo da velha, como o 4x4 ou 5x5. A árvore de decisão cresce exponencialmente, e um tabuleiro 5x5 leva minutos para calcular cada jogada em hardware comum. Nesses casos, limitar a profundidade da busca ou usar poda alfa-beta faz diferença real. Com poda alfa-beta, você descarta ramos inteiros da árvore que não precisam ser avaliados, reduzindo o tempo de computação consideravelmente. Outro ponto prático: muitos tutoriais online pulem a parte de verificar empate antes de continuar a busca recursiva, e isso pode fazer o algoritmo tentar avaliar posições fora do tabuleiro ou entrar em loops infinitos se o código de verificação de fim de jogo estiver errado. Sempre teste a condição de empate antes de recorrer. Se não houver espaços vazios e ninguém tiver ganhado, retorne 0 imediatamente. Se o seu objetivo é apenas ter um jogo da velha funcional para colocar num portfólio ou num site simples, esse nível de complexidade pode ser exagero. Uma implementação ingênua com verificação de todas as linhas após cada movimento e um randomizador para a IA resolve o problema em quinze minutos de trabalho. A diferença aparece só quando você quer que a máquina seja realmente difícil de vencer, o que é o motivo mais comum de alguém precisar do Minimax.

Para quem quer expandir depois, considere adicionar persistência de partidas, histórico de vitórias e empates, e talvez um modo duas pessoas local. Nada disso exige mudança na lógica do algoritmo, só na camada de interface. O núcleo permanece o mesmo. Se quiser testar algo pronto, existem várias versões open source no GitHub. Procure por tic-tac-toe minimax e você encontra implementações em JavaScript, Python e até C++. A maioria segue exatamente a estrutura que mostrei aqui, com pequenas variações na forma de representar o tabuleiro ou de tratar a pontuação.