Cum se creează un joc de bază bazat pe text în C++
Jocurile bazate pe text în C++ permit jucătorului să introducă comenzi printr-o fereastră de consolă, iar programul procesează mișcările jucătorului. Aici, am creat un joc tic-tac-toe bazat pe text care permite utilizatorului să joace două opțiuni. Utilizatorul poate juca fie cu compilatorul C++, fie cu un alt om. Acest joc are o caracteristică care continuă să adună scorul pentru jucătorul câștigător. După ce rezultatul primului joc este anunțat, este disponibilă o opțiune de revanșă.
Reguli pentru câștigarea jocului
Doi jucători joacă un joc tic-tac-toe, plasând alternativ X și 0 într-unul dintre cele nouă spații disponibile pe o grilă de trei pe trei. Jocul este câștigat de primul jucător care obține trei dintre notele sale consecutive în direcție verticală, orizontală sau diagonală. Fiecare jucător trebuie să gândească inteligent și să privească înainte la următoarea mișcare a celuilalt jucător.
Codul pentru proiectarea unui joc tic-tac-toe bazat pe text are diferite secțiuni, împărțite în funcție de funcționalitate. În prima secțiune, utilizatorul decide dacă să se joace cu un computer sau cu un om. După ce a decis modul de câștig, programul solicită utilizatorului introducerea. Ambii jucători introduc intrare unul după altul.
//Preia contribuții de la jucători
gol playerInput ( Jucător & jucător ) {
int poz ;
cout << endl ;
cout << ' \t ' << jucător. getName ( ) << ' Întoarce: ' ;
cout << ' \t Introdu poziția ' <> poz ;
poz - = 1 ;
dacă ( emptyIndex [ poz ] == 1 ) {
cout << '-----Poziția nu este goală-------' << endl ;
playerInput ( jucător ) ;
} altfel {
emptyIndex [ poz ] = 1 ;
emptyCount - = 1 ;
jucător. getName ( ) . comparaţie ( 'Jucatorul I' ) == 0 ? bord [ poz ] = 'X' : bord [ poz ] = 'O' ;
}
}
După ce a primit intrări de la utilizator, acesta verifică regula de câștig. Funcția checkWin() are doi parametri p1 și p2 pentru a verifica dacă jucătorul a câștigat sau nu. Diferite variabile sunt declarate în funcția i, j și k sunt variabile întregi declarate pentru buclă, iar indicatorul este o funcție booleană pentru a verifica condiția de câștig. Bucla începe din prima poziție și continuă să se repete pentru toate cele nouă poziții. First_symbol este un caracter care poate fi 0 sau X dacă este adevărat, atunci toate combinațiile posibile sunt verificate pentru regula câștigătoare. În caz contrar, iteratorul se mută la următoarea poziție și același lucru continuă până când sunt verificate toate pozițiile posibile. Dacă steagul este setat să fie adevărat, atunci un câștigător este declarat și programul cere să facă alegerea din nou.
gol checkWin ( Jucător & p1,Jucător & p2 ) {
int i,j,k ;
bool steag = fals ;
char primul_simbol ;
pentru ( i = 0 ; i < 8 ; i ++ ) {
primul_simbol = bord [ lista câștigătoare [ i ] . rând [ 0 ] ] ;
dacă ( ( primul_simbol ! = 'X' ) && ( primul_simbol ! = 'O' ) ) {
steag = fals ;
continua ;
}
steag = Adevărat ;
pentru ( j = 0 ; j < 3 ; j ++ ) {
dacă ( primul_simbol ! = bord [ lista câștigătoare [ i ] . rând [ j ] ] ) {
steag = fals ;
pauză ;
}
}
dacă ( steag ) {
joc început = 0 ;
dacă ( primul_simbol == 'X' ) {
cout << '------------------------' << endl ;
cout << ' \t Jucătorul pe care l-am câștigat' << endl ;
cout << '------------------------' << endl ;
p1. castigat ( ) ;
} altfel {
p2. castigat ( ) ;
dacă ( împotrivaComputerului ) {
cout << '------------------------' << endl ;
cout << ' \t Calculatorul a CÂȘTIGAT' << endl ;
cout << '------------------------' << endl ;
} altfel {
cout << '------------------------' << endl ;
cout << ' \t Jucătorul II CÂȘTIGĂ' << endl ;
cout << '------------------------' << endl ;
}
}
displayScore ( p1,p2 ) ;
pauză ;
}
Această parte a codului arată scorul jocului. Dacă jocul este împotriva unui computer, atunci este afișat scorul pentru jucătorul 1 și computerul, în caz contrar, este afișat scorul pentru jucătorul 1 și jucătorul 2.
gol displayScore ( Jucător & p1, Jucător & p2 ) {
cout << endl ;
cout << ' \t SCOR: \t ' ;
dacă ( împotrivaComputerului )
cout << 'Jucătorul I:' << p1. getScore ( ) << ' \t Calculator: ' << p2. getScore ( ) << endl ;
altfel
cout << 'Jucătorul I:' << p1. getScore ( ) << ' \t Jucătorul II: ' << p2. getScore ( ) << endl ;
}
Acesta este codul principal pentru execuția jocului tic-tac-toe pentru doi jucători. Utilizatorul poate selecta dintr-o varietate de proceduri care urmează să fie efectuate folosind declarația switch case. Acest cod oferă o interfață ușor de utilizat pentru a juca un joc pe un compilator C++, iar codul continuă să se execute până când utilizatorul selectează opțiunea de ieșire.
int principal ( ){
int cap ;
in timp ce ( 1 ) {
cout << ' ----------MENIUL----------' << endl ;
cout << ' \t 1. Joc pentru 1 jucător' << endl ;
cout << ' \t 2. Joc pentru 2 jucători' << endl ;
cout << ' \t 3. Pentru a ieși ' << endl ;
cout << ' ----------' << endl ;
cout << endl ;
cout << ' \t Selecteaza o optiune' <> cap ;
intrerupator ( cap ) {
caz 1 : {
Joc * joc = nou Joc ;
joc - > căldură ( ) ;
joc - > onePlayerGame ( ) ;
}
pauză ;
caz 2 : {
Joc * joc = nou Joc ;
joc - > căldură ( ) ;
joc - > TwoPlayerGame ( ) ;
}
pauză ;
caz 3 :
întoarcere 0 ;
Mod implicit :
cout << „OOPs Opțiune nevalidă! ÎNCERCAȚI DIN NOU” ;
}
}
întoarcere 0 ;
}
Cod complet pentru un joc Tic-Tac-Toc bazat pe text
Acesta este un cod complet pentru proiectarea și execuția unui joc tic-tac-toe bazat pe text.
#include
#include
#include
#include<șir>
#include
folosind spatiu de nume std ;
typedef struct {
int * rând ;
} WinList ;
clasă Jucător {
privat :
nume șir ;
int Scor ;
public :
Jucător ( ) : Jucător { '' } { }
Jucător ( șir n ) : Scor { 0 } , Nume { n } { }
gol castigat ( ) {
//incrementează scorul
Scor ++ ;
}
int getScore ( ) { întoarcere acest - > Scor ; }
șir getName ( ) { întoarcere acest - > Nume ; }
} ;
clasă Joc {
privat :
char bord [ 9 ] ;
int emptyIndex [ 9 ] ;
int gameOn, contraComputer ;
int emptyCount ;
Lista de câștiguri WinList [ 8 ] ;
gol displayBoard ( ) {
cout << endl ;
cout << ' | | ' << endl ;
cout << ' ' << bord [ 0 ] << ' | ' << bord [ 1 ] << ' | ' << bord [ 2 ] << endl ;
cout << ' | | ' << endl ;
cout << '-----------' << endl ;
cout << ' | | ' << endl ;
cout << ' ' << bord [ 3 ] << ' | ' << bord [ 4 ] << ' | ' << bord [ 5 ] << endl ;
cout << ' | | ' << endl ;
cout << '-----------' << endl ;
cout << ' | | ' << endl ;
cout << ' ' << bord [ 6 ] << ' | ' << bord [ 7 ] << ' | ' << bord [ 8 ] << endl ;
cout << ' | | ' << endl ;
cout << endl ;
}
gol computerInput ( ) {
int poz ;
poz = rand ( ) % 10 ;
dacă ( emptyIndex [ poz ] == 1 ) {
dacă ( emptyCount < 0 )
întoarcere ;
computerInput ( ) ;
} altfel {
cout << 'Computer alege:' << poz + 1 << endl ;
emptyIndex [ poz ] = 1 ;
emptyCount - = 1 ;
bord [ poz ] = 'O' ;
}
}
gol playerInput ( Jucător & jucător ) {
int poz ;
cout << endl ;
cout << ' \t ' << jucător. getName ( ) << ' Întoarce: ' ;
cout << ' \t Introdu poziția ' <> poz ;
poz - = 1 ;
dacă ( emptyIndex [ poz ] == 1 ) {
cout << '-----Poziția nu este goală-------' << endl ;
playerInput ( jucător ) ;
} altfel {
emptyIndex [ poz ] = 1 ;
emptyCount - = 1 ;
jucător. getName ( ) . comparaţie ( 'Jucatorul I' ) == 0 ? bord [ poz ] = 'X' : bord [ poz ] = 'O' ;
}
}
gol checkWin ( Jucător & p1,Jucător & p2 ) {
int i,j,k ;
bool steag = fals ;
char primul_simbol ;
pentru ( i = 0 ; i < 8 ; i ++ ) {
primul_simbol = bord [ lista câștigătoare [ i ] . rând [ 0 ] ] ;
dacă ( ( primul_simbol ! = 'X' ) && ( primul_simbol ! = 'O' ) ) {
steag = fals ;
continua ;
}
steag = Adevărat ;
pentru ( j = 0 ; j < 3 ; j ++ ) {
dacă ( primul_simbol ! = bord [ lista câștigătoare [ i ] . rând [ j ] ] ) {
steag = fals ;
pauză ;
}
}
dacă ( steag ) {
joc început = 0 ;
dacă ( primul_simbol == 'X' ) {
cout << '------------------------' << endl ;
cout << ' \t Jucătorul pe care l-am câștigat' << endl ;
cout << '------------------------' << endl ;
p1. castigat ( ) ;
} altfel {
p2. castigat ( ) ;
dacă ( împotrivaComputerului ) {
cout << '------------------------' << endl ;
cout << ' \t Calculatorul a CÂȘTIGAT' << endl ;
cout << '------------------------' << endl ;
} altfel {
cout << '------------------------' << endl ;
cout << ' \t Jucătorul II CÂȘTIGĂ' << endl ;
cout << '------------------------' < 0 ) && ( joc început ! = 0 ) ) {
dacă ( împotrivaComputerului )
mână == 1 ? computerInput ( ) : playerInput ( p2 ) ;
altfel
mână == 1 ? playerInput ( p1 ) : playerInput ( p2 ) ;
mână = ! mână ;
displayBoard ( ) ;
checkWin ( p1,p2 ) ;
}
dacă ( emptyCount <= 0 ) {
cout << ' ------------------------' << endl ;
cout << ' \t Fără CÂȘTIGĂTOR' << endl ;
cout << ' ------------------------' << endl ;
}
cout << endl ;
cout <> revanșa ;
dacă ( ( revanșa == 'ȘI' ) || ( revanșa == 'și' ) ) {
căldură ( ) ;
Joaca ( p1,p2 ) ;
}
}
gol displayScore ( Jucător & p1, Jucător & p2 ) {
cout << endl ;
cout << ' \t SCOR: \t ' ;
dacă ( împotrivaComputerului )
cout << 'Jucătorul I:' << p1. getScore ( ) << ' \t Calculator: ' << p2. getScore ( ) << endl ;
altfel
cout << 'Jucătorul I:' << p1. getScore ( ) << ' \t Jucătorul II: ' << p2. getScore ( ) << endl ;
}
public :
Joc ( ) : emptyCount { 0 } , joc început { 1 } , contraComputer { 0 } {
căldură ( ) ;
lista câștigătoare [ 0 ] . rând = nou int [ 3 ] { 0 , 1 , 2 } ;
lista câștigătoare [ 1 ] . rând = nou int [ 3 ] { 3 , 4 , 5 } ;
lista câștigătoare [ 2 ] . rând = nou int [ 3 ] { 6 , 7 , 8 } ;
lista câștigătoare [ 3 ] . rând = nou int [ 3 ] { 0 , 3 , 6 } ;
lista câștigătoare [ 4 ] . rând = nou int [ 3 ] { 1 , 4 , 7 } ;
lista câștigătoare [ 5 ] . rând = nou int [ 3 ] { 2 , 5 , 8 } ;
lista câștigătoare [ 6 ] . rând = nou int [ 3 ] { 0 , 4 , 8 } ;
lista câștigătoare [ 7 ] . rând = nou int [ 3 ] { 2 , 4 , 6 } ;
}
gol căldură ( ) {
joc început = 1 ;
emptyCount = 0 ;
srand ( timp ( 0 ) ) ;
pentru ( dimensiunea_t i = 0 ; i < 10 ; i ++ ) {
emptyIndex [ i ] = 0 ;
bord [ i ] = ( i + 1 ) + '0' ;
emptyCount ++ ;
}
emptyCount -- ;
}
gol onePlayerGame ( ) {
//Crearea playerului
Jucător p ( 'Jucatorul I' ) ;
Jucătorul c ( 'Calculator' ) ;
cout << ' ------------------------' << endl ;
cout << ' \t Jucătorul I: X \t Computer: O' << endl ;
cout << ' ------------------------' << endl ;
cout << endl ;
împotrivaComputerului = 1 ;
Joaca ( c,p ) ;
}
gol TwoPlayerGame ( ) {
//Crearea playerului
Jucător p ( 'Jucatorul I' ) ;
Jucătorul c ( „Jucătorul II” ) ;
cout << ' ------------------------' << endl ;
cout << ' \t Jucătorul I: X \t Jucătorul II: O' << endl ;
cout << ' ------------------------' << endl ;
cout << endl ;
împotrivaComputerului = 0 ;
Joaca ( c,p ) ;
}
} ;
int principal ( )
{
int cap ;
in timp ce ( 1 ) {
cout << ' ----------MENIUL----------' << endl ;
cout << ' \t 1. Joc pentru 1 jucător' << endl ;
cout << ' \t 2. Joc pentru 2 jucători' << endl ;
cout << ' \t 3. Pentru a ieși ' << endl ;
cout << ' ----------' << endl ;
cout << endl ;
cout << ' \t Selecteaza o optiune' <> cap ;
intrerupator ( cap ) {
caz 1 : {
Joc * joc = nou Joc ;
joc - > căldură ( ) ;
joc - > onePlayerGame ( ) ;
}
pauză ;
caz 2 : {
Joc * joc = nou Joc ;
joc - > căldură ( ) ;
joc - > TwoPlayerGame ( ) ;
}
pauză ;
caz 3 :
întoarcere 0 ;
Mod implicit :
cout << „OOPs Opțiune nevalidă! ÎNCERCAȚI DIN NOU” ;
}
}
întoarcere 0 ;
}
Acesta este un cod complet pentru execuția jocului tic-tac-toe, care poate fi jucat în două moduri, fie cu un computer, fie cu un om. Acesta este un cod versatil, care include toate comenzile posibile. Când utilizatorul introduce o poziție care este deja ocupată, nu suprascrie această poziție și consideră această mutare invalidă.
Până acum, jucătorul 1 a selectat prima casetă și apoi, în rândul următor, computerul a marcat a șasea casetă:
Ambii jucători au selectat cele două casete până acum și în rândul următor jucătorul I alege a șaptea casetă, rezultând în crearea unui model vertical consecutiv:
Utilizatorul alege să folosească computerul pentru a juca un joc, așa că după ce a luat trei mutări, utilizatorul a câștigat de pe computer și un scor este adăugat la înregistrarea jucătorului 1. După ce primul meci se termină, compilatorul cere revanșa. Utilizatorul decide din opțiuni și programul revine la secțiunea principală. După alegerea opțiunii trei, compilatorul există execuția codului.
Concluzie
Jocurile bazate pe text se bazează pe caractere text și pe o interfață de linie de comandă pentru interacțiunea cu jucătorul. Nu au imagini grafice, sunete sau animații. Utilizatorul introduce comanda prin fereastra consolei. Jocul ușor de utilizat, bazat pe text, este construit folosind C++. Utilizează diferite comenzi pentru a crea un joc care poate fi jucat fie cu un computer, fie cu un alt jucător.