Como criar um jogo básico baseado em texto em C++
Jogos baseados em texto em C++ permitem que o jogador insira comandos por meio de uma janela do console e o programa processe os movimentos do jogador. Aqui, criei um jogo da velha baseado em texto que permite duas opções para o usuário jogar. O usuário pode brincar com o compilador C++ ou com outro ser humano. Este jogo possui um recurso que continua somando a pontuação do jogador vencedor. Após o anúncio do resultado do primeiro jogo, uma opção de revanche estará disponível.
Regras para vencer o jogo
Dois jogadores jogam um jogo da velha, colocando X e 0 alternadamente em um dos nove espaços disponíveis em uma grade de três por três. O jogo é vencido pelo primeiro jogador que obtiver três de suas marcas consecutivas na vertical, horizontal ou diagonal. Cada jogador tem que pensar com inteligência e antecipar o próximo movimento do outro jogador.
O código para projetar um jogo da velha baseado em texto tem diferentes seções, divididas com base na funcionalidade. Na primeira seção, o usuário decide se quer jogar com um computador ou com outro ser humano. Depois de decidir o modo de ganho, o programa solicita a entrada do usuário. Ambos os jogadores inserem entradas um após o outro.
//Recebe a opinião dos jogadores
vazio playerInput ( Jogador & jogador ) {
interno posição ;
corte << fim ;
corte << ' \t ' << jogador. obterNome ( ) << ' Vez: ' ;
corte << ' \t Digite a posição ' <> posição ;
posição - = 1 ;
se ( índice vazio [ posição ] == 1 ) {
corte << '-----Posição não vazia-------' << fim ;
playerInput ( jogador ) ;
} outro {
índice vazio [ posição ] = 1 ;
contagem vazia - = 1 ;
jogador. obterNome ( ) . comparar ( 'Jogador I' ) == 0 ? quadro [ posição ] = 'X' : quadro [ posição ] = 'O' ;
}
}
Depois de receber as informações do usuário, ele verifica a regra de vitória. A função checkWin() possui dois parâmetros p1 e p2 para verificar se o jogador ganhou ou não. Diferentes variáveis são declaradas na função i, j e k são variáveis inteiras declaradas para o loop e o sinalizador é uma função booleana para verificar a condição de vitória. O loop começa na primeira posição e continua iterando em todas as nove posições. O first_symbol é um caractere que pode ser 0 ou X se for verdadeiro, então todas as combinações possíveis são verificadas para a regra de vitória. Caso contrário, o iterador passa para a próxima posição e continua até que todas as posições possíveis sejam verificadas. Se a bandeira for definida como verdadeira, um vencedor será declarado e o programa pedirá para fazer a escolha novamente.
vazio verificarWin ( Jogador & p1, Jogador & p2 ) {
interno eu, j, k ;
bool bandeira = falso ;
Caracteres primeiro_símbolo ;
para ( eu = 0 ; eu < 8 ; eu ++ ) {
primeiro_símbolo = quadro [ lista de vitórias [ eu ] . linha [ 0 ] ] ;
se ( ( primeiro_símbolo ! = 'X' ) && ( primeiro_símbolo ! = 'O' ) ) {
bandeira = falso ;
continuar ;
}
bandeira = verdadeiro ;
para ( j = 0 ; j < 3 ; j ++ ) {
se ( primeiro_símbolo ! = quadro [ lista de vitórias [ eu ] . linha [ j ] ] ) {
bandeira = falso ;
quebrar ;
}
}
se ( bandeira ) {
jogoOn = 0 ;
se ( primeiro_símbolo == 'X' ) {
corte << '------------------------' << fim ;
corte << ' \t Jogador eu ganhei' << fim ;
corte << '------------------------' << fim ;
p1. ganho ( ) ;
} outro {
p2. ganho ( ) ;
se ( contraComputador ) {
corte << '------------------------' << fim ;
corte << ' \t Computador GANHOU' << fim ;
corte << '------------------------' << fim ;
} outro {
corte << '------------------------' << fim ;
corte << ' \t Jogador II GANHOU' << fim ;
corte << '------------------------' << fim ;
}
}
displayScore ( p1,p2 ) ;
quebrar ;
}
Esta parte do código mostra a pontuação do jogo. Se o jogo for contra um computador, a pontuação do jogador 1 e do computador será exibida; caso contrário, a pontuação do jogador 1 e do jogador 2 será exibida.
vazio displayScore ( Jogador & p1, Jogador & p2 ) {
corte << fim ;
corte << ' \t PONTUAÇÃO: \t ' ;
se ( contraComputador )
corte << 'Jogador I:' << p1. obter pontuação ( ) << ' \t Computador: ' << p2. obter pontuação ( ) << fim ;
outro
corte << 'Jogador I:' << p1. obter pontuação ( ) << ' \t Jogador II: ' << p2. obter pontuação ( ) << fim ;
}
Este é o código principal para a execução do jogo da velha para dois jogadores. O usuário pode selecionar entre uma variedade de procedimentos a serem executados usando a instrução switch case. Este código fornece uma interface amigável para jogar em um compilador C++, e o código continua em execução até que o usuário selecione a opção de saída.
interno principal ( ){
interno CH ;
enquanto ( 1 ) {
corte << ' ----------CARDÁPIO----------' << fim ;
corte << ' \t 1. Jogo de 1 jogador' << fim ;
corte << ' \t 2. Jogo para 2 jogadores' << fim ;
corte << ' \t 3. Para sair ' << fim ;
corte << ' ----------' << fim ;
corte << fim ;
corte << ' \t Selecione uma opção' <> CH ;
trocar ( CH ) {
caso 1 : {
Jogo * jogo = novo Jogo ;
jogo - > aquecer ( ) ;
jogo - > onePlayerGame ( ) ;
}
quebrar ;
caso 2 : {
Jogo * jogo = novo Jogo ;
jogo - > aquecer ( ) ;
jogo - > jogo para dois jogadores ( ) ;
}
quebrar ;
caso 3 :
retornar 0 ;
padrão :
corte << 'Opção inválida de OOPs! TENTE NOVAMENTE' ;
}
}
retornar 0 ;
}
Código completo para um jogo Tic-Tac-Toc baseado em texto
Este é um código completo para o design e execução de um jogo da velha baseado em texto.
#include
#incluir
#include
#incluir
#include
usando espaço para nome padrão ;
typedef estrutura {
interno * linha ;
} WinList ;
aula Jogador {
privado :
nome da sequência ;
interno pontuação ;
público :
Jogador ( ) : Jogador { '' } { }
Jogador ( cadeia de caracteres f ) : pontuação { 0 } , nome { n } { }
vazio ganho ( ) {
//aumenta a pontuação
pontuação ++ ;
}
interno obter pontuação ( ) { retornar esse - > pontuação ; }
string getNome ( ) { retornar esse - > nome ; }
} ;
aula Jogo {
privado :
Caracteres quadro [ 9 ] ;
interno índice vazio [ 9 ] ;
interno jogoOn, againstComputer ;
interno contagem vazia ;
Lista de vitórias WinList [ 8 ] ;
vazio displayBoard ( ) {
corte << fim ;
corte << ' | | ' << fim ;
corte << ' ' << quadro [ 0 ] << '|' << quadro [ 1 ] << '|' << quadro [ 2 ] << fim ;
corte << ' | | ' << fim ;
corte << '-----------' << fim ;
corte << ' | | ' << fim ;
corte << ' ' << quadro [ 3 ] << '|' << quadro [ 4 ] << '|' << quadro [ 5 ] << fim ;
corte << ' | | ' << fim ;
corte << '-----------' << fim ;
corte << ' | | ' << fim ;
corte << ' ' << quadro [ 6 ] << '|' << quadro [ 7 ] << '|' << quadro [ 8 ] << fim ;
corte << ' | | ' << fim ;
corte << fim ;
}
vazio entrada de computador ( ) {
interno posição ;
posição = Rand ( ) % 10 ;
se ( índice vazio [ posição ] == 1 ) {
se ( contagem vazia < 0 )
retornar ;
entrada de computador ( ) ;
} outro {
corte << 'Escolha do computador:' << posição + 1 << fim ;
índice vazio [ posição ] = 1 ;
contagem vazia - = 1 ;
quadro [ posição ] = 'O' ;
}
}
vazio playerInput ( Jogador & jogador ) {
interno posição ;
corte << fim ;
corte << ' \t ' << jogador. obterNome ( ) << ' Vez: ' ;
corte << ' \t Digite a posição ' <> posição ;
posição - = 1 ;
se ( índice vazio [ posição ] == 1 ) {
corte << '-----Posição não vazia-------' << fim ;
playerInput ( jogador ) ;
} outro {
índice vazio [ posição ] = 1 ;
contagem vazia - = 1 ;
jogador. obterNome ( ) . comparar ( 'Jogador I' ) == 0 ? quadro [ posição ] = 'X' : quadro [ posição ] = 'O' ;
}
}
vazio verificarWin ( Jogador & p1, Jogador & p2 ) {
interno eu, j, k ;
bool bandeira = falso ;
Caracteres primeiro_símbolo ;
para ( eu = 0 ; eu < 8 ; eu ++ ) {
primeiro_símbolo = quadro [ lista de vitórias [ eu ] . linha [ 0 ] ] ;
se ( ( primeiro_símbolo ! = 'X' ) && ( primeiro_símbolo ! = 'O' ) ) {
bandeira = falso ;
continuar ;
}
bandeira = verdadeiro ;
para ( j = 0 ; j < 3 ; j ++ ) {
se ( primeiro_símbolo ! = quadro [ lista de vitórias [ eu ] . linha [ j ] ] ) {
bandeira = falso ;
quebrar ;
}
}
se ( bandeira ) {
jogoOn = 0 ;
se ( primeiro_símbolo == 'X' ) {
corte << '------------------------' << fim ;
corte << ' \t Jogador eu ganhei' << fim ;
corte << '------------------------' << fim ;
p1. ganho ( ) ;
} outro {
p2. ganho ( ) ;
se ( contraComputador ) {
corte << '------------------------' << fim ;
corte << ' \t Computador GANHOU' << fim ;
corte << '------------------------' << fim ;
} outro {
corte << '------------------------' << fim ;
corte << ' \t Jogador II GANHOU' << fim ;
corte << '------------------------' < 0 ) && ( jogoOn ! = 0 ) ) {
se ( contraComputador )
mão == 1 ? entrada de computador ( ) : playerInput ( p2 ) ;
outro
mão == 1 ? playerInput ( p1 ) : playerInput ( p2 ) ;
mão = ! mão ;
displayBoard ( ) ;
verificarWin ( p1,p2 ) ;
}
se ( contagem vazia <= 0 ) {
corte << ' --------------------------' << fim ;
corte << ' \t Sem VENCEDOR' << fim ;
corte << ' --------------------------' << fim ;
}
corte << fim ;
corte <> revanche ;
se ( ( revanche == 'E' ) || ( revanche == 'e' ) ) {
aquecer ( ) ;
jogar ( p1,p2 ) ;
}
}
vazio displayScore ( Jogador & p1, Jogador & p2 ) {
corte << fim ;
corte << ' \t PONTUAÇÃO: \t ' ;
se ( contraComputador )
corte << 'Jogador I:' << p1. obter pontuação ( ) << ' \t Computador: ' << p2. obter pontuação ( ) << fim ;
outro
corte << 'Jogador I:' << p1. obter pontuação ( ) << ' \t Jogador II: ' << p2. obter pontuação ( ) << fim ;
}
público :
Jogo ( ) : contagem vazia { 0 } , jogo ligado { 1 } , contraComputador { 0 } {
aquecer ( ) ;
lista de vitórias [ 0 ] . linha = novo interno [ 3 ] { 0 , 1 , 2 } ;
lista de vitórias [ 1 ] . linha = novo interno [ 3 ] { 3 , 4 , 5 } ;
lista de vitórias [ 2 ] . linha = novo interno [ 3 ] { 6 , 7 , 8 } ;
lista de vitórias [ 3 ] . linha = novo interno [ 3 ] { 0 , 3 , 6 } ;
lista de vitórias [ 4 ] . linha = novo interno [ 3 ] { 1 , 4 , 7 } ;
lista de vitórias [ 5 ] . linha = novo interno [ 3 ] { 2 , 5 , 8 } ;
lista de vitórias [ 6 ] . linha = novo interno [ 3 ] { 0 , 4 , 8 } ;
lista de vitórias [ 7 ] . linha = novo interno [ 3 ] { 2 , 4 , 6 } ;
}
vazio aquecer ( ) {
jogoOn = 1 ;
contagem vazia = 0 ;
areia ( tempo ( 0 ) ) ;
para ( tamanho_t eu = 0 ; eu < 10 ; eu ++ ) {
índice vazio [ eu ] = 0 ;
quadro [ eu ] = ( eu + 1 ) + '0' ;
contagem vazia ++ ;
}
contagem vazia -- ;
}
vazio onePlayerGame ( ) {
//Criando jogador
Jogador P ( 'Jogador I' ) ;
Jogador c ( 'Computador' ) ;
corte << ' -----------------------' << fim ;
corte << ' \t Jogador I: X \t Computador: Ó' << fim ;
corte << ' -----------------------' << fim ;
corte << fim ;
contraComputador = 1 ;
jogar ( c,p ) ;
}
vazio jogo para dois jogadores ( ) {
//Criando jogador
Jogador P ( 'Jogador I' ) ;
Jogador c ( 'Jogador II' ) ;
corte << ' -----------------------' << fim ;
corte << ' \t Jogador I: X \t Jogador II: O' << fim ;
corte << ' -----------------------' << fim ;
corte << fim ;
contraComputador = 0 ;
jogar ( c,p ) ;
}
} ;
interno principal ( )
{
interno CH ;
enquanto ( 1 ) {
corte << ' ----------CARDÁPIO----------' << fim ;
corte << ' \t 1. Jogo de 1 jogador' << fim ;
corte << ' \t 2. Jogo para 2 jogadores' << fim ;
corte << ' \t 3. Para sair ' << fim ;
corte << ' ----------' << fim ;
corte << fim ;
corte << ' \t Selecione uma opção' <> CH ;
trocar ( CH ) {
caso 1 : {
Jogo * jogo = novo Jogo ;
jogo - > aquecer ( ) ;
jogo - > onePlayerGame ( ) ;
}
quebrar ;
caso 2 : {
Jogo * jogo = novo Jogo ;
jogo - > aquecer ( ) ;
jogo - > jogo para dois jogadores ( ) ;
}
quebrar ;
caso 3 :
retornar 0 ;
padrão :
corte << 'Opção inválida de OOPs! TENTE NOVAMENTE' ;
}
}
retornar 0 ;
}
Este é um código completo para a execução do jogo da velha, que pode ser jogado em dois modos, seja com um computador ou com outro ser humano. Este é um código versátil, incluindo todos os comandos possíveis. Quando o usuário insere uma posição que já está preenchida, ele não sobrescreve esta posição e considera este movimento inválido.
Até agora o jogador um selecionou a primeira caixa e no turno seguinte o computador marcou a sexta caixa:
Ambos os jogadores selecionaram as duas caixas até agora e no próximo turno o jogador I escolhe a sétima caixa, resultando na criação de um padrão vertical consecutivo:
O usuário opta por usar o computador para jogar, então após realizar três movimentos, o usuário vence do computador e uma pontuação é adicionada ao registro do jogador 1. Após o término da primeira partida, o compilador solicita a revanche. O usuário decide entre as opções e o programa retorna à seção principal. Após escolher a opção três o compilador existe a execução do código.
Conclusão
Os jogos baseados em texto dependem de caracteres de texto e de uma interface de linha de comando para interação com o jogador. Eles não possuem imagens gráficas, sons ou animações. O usuário insere o comando por meio da janela do console. O jogo da velha baseado em texto e fácil de usar é construído em C++. Ele usa diferentes comandos para criar um jogo que pode ser jogado com um computador ou com outro jogador.