Come creare un gioco semplice basato su testo in C++
I giochi basati su testo in C++ consentono al giocatore di inserire comandi tramite una finestra della console e il programma elabora le mosse del giocatore. Qui, ho creato un gioco di tris basato su testo che consente all'utente di giocare con due opzioni. L'utente può giocare con il compilatore C++ o con un altro essere umano. Questo gioco ha una funzione che continua ad sommare il punteggio per il giocatore vincente. Dopo l'annuncio del risultato della prima partita, è disponibile un'opzione di rivincita.
Regole per vincere la partita
Due giocatori giocano a tris, posizionando X e 0 alternativamente in uno dei nove spazi disponibili su una griglia tre per tre. La partita viene vinta dal primo giocatore che ottiene tre dei suoi punti consecutivi in direzione verticale, orizzontale o diagonale. Ogni giocatore deve pensare in modo intelligente e guardare avanti alla mossa successiva dell'altro giocatore.
Il codice per progettare un gioco di tris testuale è composto da diverse sezioni, suddivise in base alla funzionalità. Nella prima sezione l'utente decide se giocare con un computer o con un altro essere umano. Dopo aver deciso la modalità di guadagno, il programma chiede input all'utente. Entrambi i giocatori inseriscono l'input uno dopo l'altro.
//Prende input dai giocatori
vuoto playerInput ( Giocatore & giocatore ) {
int pos ;
cout << fine ;
cout << ' \T ' << giocatore. getNome ( ) << ' Giro: ' ;
cout << ' \T Inserisci la posizione ' <> pos ;
pos - = 1 ;
Se ( vuotoIndice [ pos ] == 1 ) {
cout << '-----Posizione non vuota-------' << fine ;
playerInput ( giocatore ) ;
} altro {
vuotoIndice [ pos ] = 1 ;
vuotoConteggio - = 1 ;
giocatore. getNome ( ) . confrontare ( 'Giocatore I' ) == 0 ? asse [ pos ] = 'X' : asse [ pos ] = 'O' ;
}
}
Dopo aver ricevuto input dall'utente, controlla la regola di vincita. La funzione checkWin() ha due parametri p1 e p2 per verificare se il giocatore ha vinto o meno. Diverse variabili sono dichiarate nella funzione i, j e k sono variabili intere dichiarate per il ciclo e il flag è una funzione booleana per verificare la condizione di vittoria. Il ciclo inizia dalla primissima posizione e continua a ripetere tutte le nove posizioni. Il first_symbol è un carattere che può essere 0 o X se è vero, vengono controllate tutte le combinazioni possibili per la regola vincente. Altrimenti l'iteratore si sposta alla posizione successiva, e continua così finché non vengono controllate tutte le possibili posizioni. Se il flag è impostato su vero, viene dichiarato un vincitore e il programma chiede di effettuare nuovamente la scelta.
vuoto checkWin ( Giocatore & p1,Giocatore & p2 ) {
int io, j, k ;
bool bandiera = falso ;
car primo_simbolo ;
per ( io = 0 ; io < 8 ; io ++ ) {
primo_simbolo = asse [ winlist [ io ] . riga [ 0 ] ] ;
Se ( ( primo_simbolo ! = 'X' ) && ( primo_simbolo ! = 'O' ) ) {
bandiera = falso ;
Continua ;
}
bandiera = VERO ;
per ( J = 0 ; J < 3 ; J ++ ) {
Se ( primo_simbolo ! = asse [ winlist [ io ] . riga [ J ] ] ) {
bandiera = falso ;
rottura ;
}
}
Se ( bandiera ) {
inizio partita = 0 ;
Se ( primo_simbolo == 'X' ) {
cout << '------------------------' << fine ;
cout << ' \T Giocatore che ho vinto' << fine ;
cout << '------------------------' << fine ;
p1. vinto ( ) ;
} altro {
p2. vinto ( ) ;
Se ( controComputer ) {
cout << '------------------------' << fine ;
cout << ' \T Il computer ha vinto' << fine ;
cout << '------------------------' << fine ;
} altro {
cout << '------------------------' << fine ;
cout << ' \T Il Giocatore II HA VINTO' << fine ;
cout << '------------------------' << fine ;
}
}
displayScore ( p1,p2 ) ;
rottura ;
}
Questa parte del codice mostra il punteggio della partita. Se la partita è contro un computer, verrà visualizzato il punteggio del giocatore 1 e del computer, altrimenti verrà visualizzato il punteggio del giocatore 1 e del giocatore 2.
vuoto displayScore ( Giocatore & p1, Giocatore & p2 ) {
cout << fine ;
cout << ' \T PUNTO: \T ' ;
Se ( controComputer )
cout << ' Giocatore I: ' << p1. getScore ( ) << ' \T Calcolatore: ' << p2. getScore ( ) << fine ;
altro
cout << ' Giocatore I: ' << p1. getScore ( ) << ' \T Giocatore II: ' << p2. getScore ( ) << fine ;
}
Questo è il codice principale per l'esecuzione del gioco del tris per due giocatori. L'utente può scegliere tra una varietà di procedure da eseguire utilizzando l'istruzione switch case. Questo codice fornisce un'interfaccia intuitiva per giocare su un compilatore C++ e l'esecuzione del codice continua finché l'utente non seleziona l'opzione di uscita.
int principale ( ){
int cap ;
Mentre ( 1 ) {
cout << ' ----------MENÙ----------' << fine ;
cout << ' \T 1. Partita per 1 giocatore' << fine ;
cout << ' \T 2. Gioco per 2 giocatori' << fine ;
cout << ' \T 3. Per uscire ' << fine ;
cout << ' ----------' << fine ;
cout << fine ;
cout << ' \T Seleziona un'opzione' <> cap ;
interruttore ( cap ) {
caso 1 : {
Gioco * gioco = nuovo Gioco ;
gioco - > Calore ( ) ;
gioco - > onePlayerGame ( ) ;
}
rottura ;
caso 2 : {
Gioco * gioco = nuovo Gioco ;
gioco - > Calore ( ) ;
gioco - > TwoPlayerGame ( ) ;
}
rottura ;
caso 3 :
ritorno 0 ;
predefinito :
cout << 'Spiacenti Opzione non valida! RIPROVA' ;
}
}
ritorno 0 ;
}
Codice completo per un gioco Tic-Tac-Toc basato su testo
Questo è un codice completo per la progettazione e l'esecuzione di un gioco di tris basato su testo.
#include
#include
#include
#include
#include
utilizzando spazio dei nomi standard ;
typedef struttura {
int * riga ;
} WinList ;
classe Giocatore {
privato :
nome della stringa ;
int punto ;
pubblico :
Giocatore ( ) : Giocatore { '' } { }
Giocatore ( corda n ) : punto { 0 } , nome { N } { }
vuoto vinto ( ) {
//incrementa il punteggio
punto ++ ;
}
int getScore ( ) { ritorno Questo - > punto ; }
stringa getNome ( ) { ritorno Questo - > nome ; }
} ;
classe Gioco {
privato :
car asse [ 9 ] ;
int vuotoIndice [ 9 ] ;
int gameOn, controComputer ;
int vuotoConteggio ;
Lista delle vittorie WinList [ 8 ] ;
vuoto tabellone ( ) {
cout << fine ;
cout << ' | | ' << fine ;
cout << ' ' << asse [ 0 ] << ' | ' << asse [ 1 ] << ' | ' << asse [ 2 ] << fine ;
cout << ' | | ' << fine ;
cout << '-----------' << fine ;
cout << ' | | ' << fine ;
cout << ' ' << asse [ 3 ] << ' | ' << asse [ 4 ] << ' | ' << asse [ 5 ] << fine ;
cout << ' | | ' << fine ;
cout << '-----------' << fine ;
cout << ' | | ' << fine ;
cout << ' ' << asse [ 6 ] << ' | ' << asse [ 7 ] << ' | ' << asse [ 8 ] << fine ;
cout << ' | | ' << fine ;
cout << fine ;
}
vuoto computerInput ( ) {
int pos ;
pos = Rand ( ) % 10 ;
Se ( vuotoIndice [ pos ] == 1 ) {
Se ( vuotoConteggio < 0 )
ritorno ;
computerInput ( ) ;
} altro {
cout << 'Computer scegli:' << pos + 1 << fine ;
vuotoIndice [ pos ] = 1 ;
vuotoConteggio - = 1 ;
asse [ pos ] = 'O' ;
}
}
vuoto playerInput ( Giocatore & giocatore ) {
int pos ;
cout << fine ;
cout << ' \T ' << giocatore. getNome ( ) << ' Giro: ' ;
cout << ' \T Inserisci la posizione ' <> pos ;
pos - = 1 ;
Se ( vuotoIndice [ pos ] == 1 ) {
cout << '-----Posizione non vuota-------' << fine ;
playerInput ( giocatore ) ;
} altro {
vuotoIndice [ pos ] = 1 ;
vuotoConteggio - = 1 ;
giocatore. getNome ( ) . confrontare ( 'Giocatore I' ) == 0 ? asse [ pos ] = 'X' : asse [ pos ] = 'O' ;
}
}
vuoto checkWin ( Giocatore & p1,Giocatore & p2 ) {
int io, j, k ;
bool bandiera = falso ;
car primo_simbolo ;
per ( io = 0 ; io < 8 ; io ++ ) {
primo_simbolo = asse [ winlist [ io ] . riga [ 0 ] ] ;
Se ( ( primo_simbolo ! = 'X' ) && ( primo_simbolo ! = 'O' ) ) {
bandiera = falso ;
Continua ;
}
bandiera = VERO ;
per ( J = 0 ; J < 3 ; J ++ ) {
Se ( primo_simbolo ! = asse [ winlist [ io ] . riga [ J ] ] ) {
bandiera = falso ;
rottura ;
}
}
Se ( bandiera ) {
inizio partita = 0 ;
Se ( primo_simbolo == 'X' ) {
cout << '------------------------' << fine ;
cout << ' \T Giocatore che ho vinto' << fine ;
cout << '------------------------' << fine ;
p1. vinto ( ) ;
} altro {
p2. vinto ( ) ;
Se ( controComputer ) {
cout << '------------------------' << fine ;
cout << ' \T Il computer ha vinto' << fine ;
cout << '------------------------' << fine ;
} altro {
cout << '------------------------' << fine ;
cout << ' \T Il Giocatore II HA VINTO' << fine ;
cout << '------------------------' < 0 ) && ( inizio partita ! = 0 ) ) {
Se ( controComputer )
mano == 1 ? computerInput ( ) : playerInput ( p2 ) ;
altro
mano == 1 ? playerInput ( p1 ) : playerInput ( p2 ) ;
mano = ! mano ;
tabellone ( ) ;
checkWin ( p1,p2 ) ;
}
Se ( vuotoConteggio <= 0 ) {
cout << ' ------------------------------' << fine ;
cout << ' \T Nessun VINCITORE' << fine ;
cout << ' ------------------------------' << fine ;
}
cout << fine ;
cout <> rivincita ;
Se ( ( rivincita == 'E' ) || ( rivincita == 'E' ) ) {
Calore ( ) ;
giocare ( p1,p2 ) ;
}
}
vuoto displayScore ( Giocatore & p1, Giocatore & p2 ) {
cout << fine ;
cout << ' \T PUNTO: \T ' ;
Se ( controComputer )
cout << ' Giocatore I: ' << p1. getScore ( ) << ' \T Calcolatore: ' << p2. getScore ( ) << fine ;
altro
cout << ' Giocatore I: ' << p1. getScore ( ) << ' \T Giocatore II: ' << p2. getScore ( ) << fine ;
}
pubblico :
Gioco ( ) : vuotoConteggio { 0 } , inizio partita { 1 } , controComputer { 0 } {
Calore ( ) ;
winlist [ 0 ] . riga = nuovo int [ 3 ] { 0 , 1 , 2 } ;
winlist [ 1 ] . riga = nuovo int [ 3 ] { 3 , 4 , 5 } ;
winlist [ 2 ] . riga = nuovo int [ 3 ] { 6 , 7 , 8 } ;
winlist [ 3 ] . riga = nuovo int [ 3 ] { 0 , 3 , 6 } ;
winlist [ 4 ] . riga = nuovo int [ 3 ] { 1 , 4 , 7 } ;
winlist [ 5 ] . riga = nuovo int [ 3 ] { 2 , 5 , 8 } ;
winlist [ 6 ] . riga = nuovo int [ 3 ] { 0 , 4 , 8 } ;
winlist [ 7 ] . riga = nuovo int [ 3 ] { 2 , 4 , 6 } ;
}
vuoto Calore ( ) {
inizio partita = 1 ;
vuotoConteggio = 0 ;
srand ( tempo ( 0 ) ) ;
per ( taglia_t io = 0 ; io < 10 ; io ++ ) {
vuotoIndice [ io ] = 0 ;
asse [ io ] = ( io + 1 ) + '0' ;
vuotoConteggio ++ ;
}
vuotoConteggio -- ;
}
vuoto onePlayerGame ( ) {
//Creazione del giocatore
Giocatore pag ( 'Giocatore I' ) ;
Giocatore C ( 'Computer' ) ;
cout << ' -----------------------' << fine ;
cout << ' \T Giocatore I: X \T Computer: O' << fine ;
cout << ' -----------------------' << fine ;
cout << fine ;
controComputer = 1 ;
giocare ( c, pag ) ;
}
vuoto TwoPlayerGame ( ) {
//Creazione del giocatore
Giocatore pag ( 'Giocatore I' ) ;
Giocatore C ( 'Giocatore II' ) ;
cout << ' -----------------------' << fine ;
cout << ' \T Giocatore I: X \T Giocatore II: O' << fine ;
cout << ' -----------------------' << fine ;
cout << fine ;
controComputer = 0 ;
giocare ( c, pag ) ;
}
} ;
int principale ( )
{
int cap ;
Mentre ( 1 ) {
cout << ' ----------MENÙ----------' << fine ;
cout << ' \T 1. Partita per 1 giocatore' << fine ;
cout << ' \T 2. Gioco per 2 giocatori' << fine ;
cout << ' \T 3. Per uscire ' << fine ;
cout << ' ----------' << fine ;
cout << fine ;
cout << ' \T Seleziona un'opzione' <> cap ;
interruttore ( cap ) {
caso 1 : {
Gioco * gioco = nuovo Gioco ;
gioco - > Calore ( ) ;
gioco - > onePlayerGame ( ) ;
}
rottura ;
caso 2 : {
Gioco * gioco = nuovo Gioco ;
gioco - > Calore ( ) ;
gioco - > TwoPlayerGame ( ) ;
}
rottura ;
caso 3 :
ritorno 0 ;
predefinito :
cout << 'Spiacenti Opzione non valida! RIPROVA' ;
}
}
ritorno 0 ;
}
Si tratta di un codice completo per l'esecuzione del gioco del tris, che può essere giocato in due modalità, sia con un computer che con un altro essere umano. Questo è un codice versatile, che include tutti i possibili comandi. Quando l'utente inserisce una posizione che è già occupata, non sovrascrive questa posizione e considera questa mossa non valida.
Fino ad ora il giocatore uno ha selezionato la prima casella e poi nel turno successivo il computer ha segnato la sesta casella:
Entrambi i giocatori hanno selezionato le due caselle fino ad ora e nel turno successivo il giocatore I sceglie la settima casella creando uno schema verticale consecutivo:
L'utente sceglie di utilizzare il computer per giocare, quindi dopo aver eseguito tre mosse, l'utente vince dal computer e un punteggio viene aggiunto al record del giocatore 1. Al termine della prima partita, il compilatore richiede la rivincita. L'utente decide dalle opzioni e il programma ritorna alla sezione principale. Dopo aver scelto l'opzione tre, il compilatore esegue l'esecuzione del codice.
Conclusione
I giochi basati su testo si basano su caratteri di testo e un'interfaccia a riga di comando per l'interazione con il giocatore. Non contengono immagini grafiche, suoni o animazioni. L'utente immette il comando tramite la finestra della console. Il gioco tris basato su testo intuitivo è realizzato utilizzando C++. Utilizza diversi comandi per creare un gioco che può essere giocato con un computer o con un altro giocatore.