Crie um jogo Tic-Tac-Toe em C++
O exemplo a seguir fornece os princípios básicos para criar este jogo da velha interativo para dois jogadores. Ele apresenta uma abordagem simples e fácil para programá-lo com C++ e fornece um código-fonte bem documentado para reviver os desafios da infância com amigos em um novo formato digital. Vejamos o seguinte código.
Exemplo: Tic-Tac-Toe básico baseado em console sem usar o array 2D
Neste exemplo, usaremos um array 2D, funções e condições if-else para fazer o jogo da velha em C++. Neste jogo, dois jogadores podem se revezar na inserção de seus movimentos, e isso determina o estado do jogo verificando se há vencedor ou empate. Veja o seguinte código fornecido:
#include
usando namespace std ;
vazio drawboard ( Caracteres quadro [ 3 ] [ 3 ] ) ;
bool éMoveValid ( Caracteres quadro [ 3 ] [ 3 ] , interno linha , interno coluna ) ;
bool isBoardFull ( Caracteres quadro [ 3 ] [ 3 ] ) ;
Caracteres verificarWinner ( Caracteres quadro [ 3 ] [ 3 ] ) ;
interno principal ( ) {
Caracteres quadro [ 3 ] [ 3 ] = { { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } } ;
interno linha , coluna ;
Caracteres player atual = 'X' ;
enquanto ( verdadeiro ) {
drawboard ( quadro ) ;
corte << 'Jogador' << player atual << 'é a vez. Insira a linha (1-3) e a coluna (1-3): ' ;
comendo >> linha >> coluna ;
linha --;
coluna --;
se ( isMoveValid ( quadro , linha , coluna ) ) {
quadro [ linha ] [ coluna ] = player atual ;
Caracteres ganhador = verificarWinner ( quadro ) ;
se ( ganhador != ' ' ) {
drawboard ( quadro ) ;
corte << 'Jogador' << ganhador << 'é um vencedor! \n ' ;
quebrar ;
}
se ( isBoardFull ( quadro ) ) {
drawboard ( quadro ) ;
corte << 'É um empate! \n ' ;
quebrar ;
}
player atual = ( player atual == 'X' ) ? 'O' : 'X' ;
} outro {
corte << 'Movimento inválido. Escolha outra célula. \n ' ;
} }
retornar 0 ;
}
vazio drawboard ( Caracteres quadro [ 3 ] [ 3 ] ) {
corte << 'b| \t 1 \t | \t 2 \t | \t 3 \t | \n ' ;
corte << ' ______________________ \n ' ;
para ( interno eu = 0 ; eu < 3 ; eu ++ ) {
corte << eu + 1 << '|' ;
para ( interno t = 0 ; t < 3 ; t ++ ) {
corte << '' << quadro [ eu ] [ t ] ;
se ( t < 2 ) corte << ' \t | \t ' ;
}
corte << ' \t | \n ' ;
se ( eu < 2 ) corte << ' ______________________ \n ' ;
}
corte << ' \n ' ; }
bool éMoveValid ( Caracteres quadro [ 3 ] [ 3 ] , interno linha , interno coluna ) {
retornar ( linha >= 0 && linha < 3 && coluna >= 0 && coluna < 3 && quadro [ linha ] [ coluna ] == ' ' ) ;
}
bool isBoardFull ( Caracteres quadro [ 3 ] [ 3 ] ) {
para ( interno eu = 0 ; eu < 3 ; eu ++ ) {
para ( interno t = 0 ; t < 3 ; t ++ ) {
se ( quadro [ eu ] [ t ] == ' ' ) {
retornar falso ;
} } }
retornar verdadeiro ; }
Caracteres verificarWinner ( Caracteres quadro [ 3 ] [ 3 ] ) {
para ( interno eu = 0 ; eu < 3 ; eu ++ ) {
se ( quadro [ eu ] [ 0 ] == quadro [ eu ] [ 1 ] && quadro [ eu ] [ 1 ] == quadro [ eu ] [ 2 ] && quadro [ eu ] [ 0 ] != ' ' ) {
retornar quadro [ eu ] [ 0 ] ;
}
se ( quadro [ 0 ] [ eu ] == quadro [ 1 ] [ eu ] && quadro [ 1 ] [ eu ] == quadro [ 2 ] [ eu ] && quadro [ 0 ] [ eu ] != ' ' ) {
retornar quadro [ 0 ] [ eu ] ;
} }
se ( quadro [ 0 ] [ 0 ] == quadro [ 1 ] [ 1 ] && quadro [ 1 ] [ 1 ] == quadro [ 2 ] [ 2 ] && quadro [ 0 ] [ 0 ] != ' ' ) {
retornar quadro [ 0 ] [ 0 ] ;
}
se ( quadro [ 0 ] [ 2 ] == quadro [ 1 ] [ 1 ] && quadro [ 1 ] [ 1 ] == quadro [ 2 ] [ 0 ] && quadro [ 0 ] [ 2 ] != ' ' ) {
retornar quadro [ 0 ] [ 2 ] ;
}
retornar ' ' ;
}
Aqui está uma análise de sua funcionalidade:
O “#include
Existem quatro protótipos de função neste programa – eles são drawBoard(), isMoveValid(), isBoardFull() e checkWinner(). A declaração da função é conhecida como protótipo de função. Embora venha depois da função principal do programa, ela será utilizada. A função principal contém o loop do jogo e a lógica para gerenciar os turnos e movimentos dos jogadores. Dentro da função principal, o tabuleiro do jogo é inicializado com espaços.
Caracteres quadro [ 3 ] [ 3 ] = { { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } } ;
Depois disso, duas variáveis row e col são definidas para armazenar a entrada de movimento do jogador. O “char currentPlayer = ‘X’;” define que o jogador “X” vai primeiro.
Agora, o loop do jogo while (true) começa e continua até que haja um vencedor ou empate. Este loop “while” chama “drawBoard();” para exibir o quadro. Após exibir a placa no console, o usuário é solicitado a escolher uma célula para marcar na seguinte instrução de código:
corte << 'Jogador' << player atual << 'é a vez. Insira linha e coluna (1-3): ' ;
O jogador insere seu movimento em “cin >> row >> col;”.
Ao selecionar uma célula para marcação, o programa irá primeiro verificar a validade da entrada, garantindo que a célula ainda não esteja preenchida chamando a função isMoveValid().
quadro [ linha ] [ coluna ] = player atual ;Esta afirmação coloca a marca do jogador no tabuleiro.
Caracteres ganhador = verificarWinner ( quadro ) ;se ( ganhador != ' ' ) {
drawboard ( quadro ) ;
corte << 'Jogador' << ganhador << 'ganha! \n ' ;
Estas declarações verificam se há um vencedor sempre que um jogador marca uma entrada no tabuleiro. O nome do vencedor será anunciado se houver um vencedor e o programa sairá do ciclo do jogo.
se ( isBoardFull ( quadro ) ) {Esta afirmação verifica se há empate. A condição de empate ocorre quando o tabuleiro está cheio e não há vencedor. Neste caso, “É um empate!” está impresso na tela.
player atual = ( player atual == 'X' ) ? 'O' : 'X' ;Esta declaração troca os jogadores para dar a cada jogador a chance de jogar sua vez.
corte << 'Movimento inválido. Escolha outra célula. \n ' ;Se a movimentação não for válida, o usuário será solicitado a inserir novamente e escolher qualquer outra célula.
Após a função “principal”, serão iniciadas as definições de função para os protótipos de função que foram declarados anteriormente. A primeira função definida aqui é drawBoard() que é usada para desenhar o jogo da velha para o console. A função drawBoard() imprime o estado atual do tabuleiro, incluindo linhas de grade.
A próxima função definida aqui é isMoveValid(). Esta função é usada para determinar se um movimento é permitido tanto dentro do tabuleiro quanto em uma célula vazia. A função isBoardFull() é usada para verificar se o tabuleiro ainda está cheio. Esta é uma condição para uma situação de empate quando não há vencedor. O isBoardFull() verifica se todas as posições do tabuleiro estão preenchidas, o que indica empate se não houver vencedor. Se houver um vencedor, ele pode ser verificado usando a função checkWinner(). O checkWinner() verifica todas as possíveis linhas vencedoras em busca da marca do mesmo jogador (“X” ou “O”) e retorna a marca do jogador vencedor se for encontrada ou um caractere de espaço “ “ se ainda não houver vencedor. A seguir está a saída do programa. Mostra cada turno de cada jogador.
Primeiro, o tabuleiro está claro; o jogador “X” é solicitado a escolher a célula a ser marcada. Aqui, o jogador “X” insere 2 e 2. As células da linha 2 e coluna 2 são marcadas. Consulte a placa marcada a seguir:
Agora é a vez do jogador O. O jogador é solicitado a escolher uma célula a ser marcada. O jogador “O” escolhe 1 para a linha e 1 para a coluna. A célula escolhida é marcada para o jogador “O” conforme mostrado no seguinte trecho de saída:
Todos os turnos de cada jogador seguirão o mesmo padrão. É a vez do jogador X, e o jogador escolhe 1 para a linha e 2 para a coluna. Consulte os seguintes instantâneos de saída fornecidos:
Agora a vez é do jogador “O”. O jogador escolhe 1 para a linha e 3 para a coluna.
O próximo turno é novamente do jogador “X”. O jogador escolhe 3 para a linha e 1 para a coluna.
O jogador “O” escolhe 3 para a linha e 2 para a coluna.
O jogador “X” seleciona a segunda linha e a terceira coluna.
O jogador “O” agora seleciona a segunda linha e a primeira coluna.
O jogador “X” escolhe a terceira linha e a terceira coluna desta vez.
Nenhum jogador poderia traçar qualquer linha horizontal, vertical ou diagonal, portanto há empate. Não há vencedor para o conjunto de insumos escolhido.
No geral, o código compreende um loop de jogo principal que é responsável por lidar com o estado do jogo e a entrada do usuário, juntamente com diversas funções utilitárias que são usadas para desenhar o tabuleiro, validar os movimentos, verificar se há um tabuleiro completo e determinar se há um vencedor. .
Conclusão
Desenvolver um jogo da velha usando C++ é um excelente exercício prático para reforçar suas habilidades de programação. O artigo explica com precisão como criar o jogo da velha em C++. A orientação passo a passo fornecida neste artigo abrangeu uma matriz 2D, funções e condições if-else para que os leitores entendessem a mecânica do jogo, as interações do usuário e a estruturação eficiente do código. O passo a passo detalhado do código e a explicação das funções que são cruciais para a jogabilidade central equipam os leitores com informações valiosas sobre as práticas de programação C++ e as complexidades do desenvolvimento de um jogo simples.