Jak stworzyć podstawową grę tekstową w C++
Gry tekstowe w C++ umożliwiają graczowi wprowadzanie poleceń przez okno konsoli, a program przetwarza ruchy gracza. Tutaj stworzyłem tekstową grę w kółko i krzyżyk, która umożliwia użytkownikowi grę w dwie opcje. Użytkownik może bawić się kompilatorem C++ lub z innym człowiekiem. Ta gra ma funkcję, która stale sumuje punkty zwycięskiego gracza. Po ogłoszeniu wyniku pierwszego meczu dostępna jest opcja rewanżu.
Zasady wygrywania gry
Dwóch graczy gra w kółko i krzyżyk, umieszczając naprzemiennie X i 0 na jednym z dziewięciu dostępnych pól siatki trzy na trzy. Grę wygrywa ten gracz, który jako pierwszy zdobędzie trzy kolejne znaczniki w kierunku pionowym, poziomym lub ukośnym. Każdy gracz musi mądrze myśleć i patrzeć w przyszłość na następny ruch drugiego gracza.
Kod do projektowania tekstowej gry w kółko i krzyżyk składa się z różnych sekcji, podzielonych ze względu na funkcjonalność. W pierwszej części użytkownik decyduje, czy grać z komputerem, czy z drugim człowiekiem. Po podjęciu decyzji o trybie wzmocnienia program prosi użytkownika o wprowadzenie danych. Obaj gracze wprowadzają dane jeden po drugim.
//Przyjmij uwagi od graczy
próżnia Wejście gracza ( Gracz & gracz ) {
wew poz ;
cout << koniec ;
cout << ' \T ' << gracz. pobierzNazwę ( ) << ' Zakręt: ' ;
cout << ' \T Podaj pozycję” <> poz ;
poz - = 1 ;
Jeśli ( pustyIndeks [ poz ] == 1 ) {
cout << „-----Pozycja nie jest pusta-------” << koniec ;
Wejście gracza ( gracz ) ;
} w przeciwnym razie {
pustyIndeks [ poz ] = 1 ;
pustyliczba - = 1 ;
gracz. pobierzNazwę ( ) . porównywać ( „Gracz I” ) == 0 ? tablica [ poz ] = 'X' : tablica [ poz ] = „O” ;
}
}
Po pobraniu danych wejściowych od użytkownika sprawdza regułę wygranej. Funkcja checkWin() ma dwa parametry p1 i p2 umożliwiające sprawdzenie, czy gracz wygrał, czy nie. W funkcji zadeklarowano różne zmienne, i, j i k są zmiennymi całkowitymi zadeklarowanymi dla pętli, a flaga jest funkcją boolowską służącą do sprawdzania warunku wygranej. Pętla rozpoczyna się od pierwszej pozycji i kontynuuje iterację dla wszystkich dziewięciu pozycji. Pierwszy_symbol to znak, który może wynosić 0 lub X, jeśli jest prawdziwy, wówczas wszystkie możliwe kombinacje są sprawdzane pod kątem zwycięskiej reguły. W przeciwnym wypadku iterator przechodzi do kolejnej pozycji i kontynuuje tę samą czynność, aż do sprawdzenia wszystkich możliwych pozycji. Jeśli flaga jest ustawiona na true, zostaje ogłoszony zwycięzca, a program prosi o ponowne dokonanie wyboru.
próżnia sprawdźWygraj ( Gracz & p1, Gracz & p2 ) {
wew i, j, k ;
bool flaga = FAŁSZ ;
zwęglać pierwszy_symbol ;
Do ( I = 0 ; I < 8 ; I ++ ) {
pierwszy_symbol = tablica [ lista wygranych [ I ] . wiersz [ 0 ] ] ;
Jeśli ( ( pierwszy_symbol ! = 'X' ) && ( pierwszy_symbol ! = „O” ) ) {
flaga = FAŁSZ ;
Kontynuować ;
}
flaga = PRAWDA ;
Do ( J = 0 ; J < 3 ; J ++ ) {
Jeśli ( pierwszy_symbol ! = tablica [ lista wygranych [ I ] . wiersz [ J ] ] ) {
flaga = FAŁSZ ;
przerwa ;
}
}
Jeśli ( flaga ) {
gra włączona = 0 ;
Jeśli ( pierwszy_symbol == 'X' ) {
cout << „----------------------------” << koniec ;
cout << ' \T Gracz, którego WYGRAŁEM” << koniec ;
cout << „----------------------------” << koniec ;
p1. wygrał ( ) ;
} w przeciwnym razie {
p2. wygrał ( ) ;
Jeśli ( przeciwko Komputerowi ) {
cout << „--------------------------------------” << koniec ;
cout << ' \T Komputer wygrany” << koniec ;
cout << „--------------------------------------” << koniec ;
} w przeciwnym razie {
cout << „--------------------------------------” << koniec ;
cout << ' \T Gracz II WYGRAŁ” << koniec ;
cout << „--------------------------------------” << koniec ;
}
}
wyświetl wynik ( p1, p2 ) ;
przerwa ;
}
Ta część kodu pokazuje wynik gry. Jeśli gra toczy się przeciwko komputerowi, wyświetlany jest wynik gracza 1 i komputera, w przeciwnym razie wyświetlany jest wynik gracza 1 i gracza 2.
próżnia wyświetl wynik ( Gracz & p1, Gracz & p2 ) {
cout << koniec ;
cout << ' \T WYNIK: \T ' ;
Jeśli ( przeciwko Komputerowi )
cout << „Gracz I:” << p1. uzyskaj wynik ( ) << ' \T Komputer: ' << p2. uzyskaj wynik ( ) << koniec ;
w przeciwnym razie
cout << „Gracz I:” << p1. uzyskaj wynik ( ) << ' \T Gracz II: „ << p2. uzyskaj wynik ( ) << koniec ;
}
To jest główny kod do gry w kółko i krzyżyk dla dwóch graczy. Użytkownik może wybierać spośród różnych procedur, które mają zostać przeprowadzone przy użyciu instrukcji switch case. Ten kod zapewnia przyjazny dla użytkownika interfejs do grania w grę na kompilatorze C++, a kod jest wykonywany, dopóki użytkownik nie wybierze opcji wyjścia.
wew główny ( ){
wew rozdz ;
chwila ( 1 ) {
cout << ' ----------MENU----------' << koniec ;
cout << ' \T 1. Gra dla 1 gracza” << koniec ;
cout << ' \T 2. Gra dla 2 graczy” << koniec ;
cout << ' \T 3. Aby wyjść” << koniec ;
cout << „ -----' << koniec ;
cout << koniec ;
cout << ' \T Wybierz opcję' <> rozdz ;
przełącznik ( rozdz ) {
sprawa 1 : {
Gra * gra = nowy Gra ;
gra - > ciepło ( ) ;
gra - > gra jednego gracza ( ) ;
}
przerwa ;
sprawa 2 : {
Gra * gra = nowy Gra ;
gra - > ciepło ( ) ;
gra - > gra dwuosobowa ( ) ;
}
przerwa ;
sprawa 3 :
powrót 0 ;
domyślny :
cout << „OOPs nieprawidłowa opcja! SPRÓBUJ PONOWNIE” ;
}
}
powrót 0 ;
}
Kompletny kod tekstowej gry w kółko i krzyżyk
Jest to kompletny kod do projektowania i wykonywania tekstowej gry w kółko i krzyżyk.
#include
#include
#include
#include
#include
za pomocą przestrzeń nazw st ;
typedef struktura {
wew * wiersz ;
} Lista wygranych ;
klasa Gracz {
prywatny :
nazwa ciągu ;
wew wynik ;
publiczny :
Gracz ( ) : Gracz { „” } { }
Gracz ( ciąg rz ) : wynik { 0 } , nazwa { N } { }
próżnia wygrał ( ) {
//zwiększ wynik
wynik ++ ;
}
wew uzyskaj wynik ( ) { powrót Ten - > wynik ; }
ciąg getName ( ) { powrót Ten - > nazwa ; }
} ;
klasa Gra {
prywatny :
zwęglać tablica [ 9 ] ;
wew pustyIndeks [ 9 ] ;
wew gameOn, przeciwko komputerowi ;
wew pustyliczba ;
Lista wygranych [ 8 ] ;
próżnia wyświetlacz ( ) {
cout << koniec ;
cout << „ | | ” << koniec ;
cout << ' ' << tablica [ 0 ] << ' | ' << tablica [ 1 ] << ' | ' << tablica [ 2 ] << koniec ;
cout << „ | | ” << koniec ;
cout << '--------------' << koniec ;
cout << „ | | ” << koniec ;
cout << ' ' << tablica [ 3 ] << ' | ' << tablica [ 4 ] << ' | ' << tablica [ 5 ] << koniec ;
cout << „ | | ” << koniec ;
cout << '--------------' << koniec ;
cout << „ | | ” << koniec ;
cout << ' ' << tablica [ 6 ] << ' | ' << tablica [ 7 ] << ' | ' << tablica [ 8 ] << koniec ;
cout << „ | | ” << koniec ;
cout << koniec ;
}
próżnia Wejście komputerowe ( ) {
wew poz ;
poz = skraj ( ) % 10 ;
Jeśli ( pustyIndeks [ poz ] == 1 ) {
Jeśli ( pustyliczba < 0 )
powrót ;
Wejście komputerowe ( ) ;
} w przeciwnym razie {
cout << 'Wybierz komputer: ' << poz + 1 << koniec ;
pustyIndeks [ poz ] = 1 ;
pustyliczba - = 1 ;
tablica [ poz ] = „O” ;
}
}
próżnia Wejście gracza ( Gracz & gracz ) {
wew poz ;
cout << koniec ;
cout << ' \T ' << gracz. pobierzNazwę ( ) << ' Zakręt: ' ;
cout << ' \T Podaj pozycję” <> poz ;
poz - = 1 ;
Jeśli ( pustyIndeks [ poz ] == 1 ) {
cout << „-----Pozycja nie jest pusta-------” << koniec ;
Wejście gracza ( gracz ) ;
} w przeciwnym razie {
pustyIndeks [ poz ] = 1 ;
pustyliczba - = 1 ;
gracz. pobierzNazwę ( ) . porównywać ( „Gracz I” ) == 0 ? tablica [ poz ] = 'X' : tablica [ poz ] = „O” ;
}
}
próżnia sprawdźWygraj ( Gracz & p1, Gracz & p2 ) {
wew i, j, k ;
bool flaga = FAŁSZ ;
zwęglać pierwszy_symbol ;
Do ( I = 0 ; I < 8 ; I ++ ) {
pierwszy_symbol = tablica [ lista wygranych [ I ] . wiersz [ 0 ] ] ;
Jeśli ( ( pierwszy_symbol ! = 'X' ) && ( pierwszy_symbol ! = „O” ) ) {
flaga = FAŁSZ ;
Kontynuować ;
}
flaga = PRAWDA ;
Do ( J = 0 ; J < 3 ; J ++ ) {
Jeśli ( pierwszy_symbol ! = tablica [ lista wygranych [ I ] . wiersz [ J ] ] ) {
flaga = FAŁSZ ;
przerwa ;
}
}
Jeśli ( flaga ) {
gra włączona = 0 ;
Jeśli ( pierwszy_symbol == 'X' ) {
cout << „----------------------------” << koniec ;
cout << ' \T Gracz, którego WYGRAŁEM” << koniec ;
cout << „----------------------------” << koniec ;
p1. wygrał ( ) ;
} w przeciwnym razie {
p2. wygrał ( ) ;
Jeśli ( przeciwko Komputerowi ) {
cout << „----------------------------” << koniec ;
cout << ' \T Komputer wygrany” << koniec ;
cout << „----------------------------” << koniec ;
} w przeciwnym razie {
cout << „----------------------------” << koniec ;
cout << ' \T Gracz II WYGRAŁ” << koniec ;
cout << „----------------------------” < 0 ) && ( gra włączona ! = 0 ) ) {
Jeśli ( przeciwko Komputerowi )
ręka == 1 ? Wejście komputerowe ( ) : Wejście gracza ( p2 ) ;
w przeciwnym razie
ręka == 1 ? Wejście gracza ( p1 ) : Wejście gracza ( p2 ) ;
ręka = ! ręka ;
wyświetlacz ( ) ;
sprawdźWygraj ( p1, p2 ) ;
}
Jeśli ( pustyliczba <= 0 ) {
cout << „ -----------------------” << koniec ;
cout << ' \T Brak ZWYCIĘZCY” << koniec ;
cout << „ -----------------------” << koniec ;
}
cout << koniec ;
cout <> rewanż ;
Jeśli ( ( rewanż == 'I' ) || ( rewanż == 'I' ) ) {
ciepło ( ) ;
grać ( p1, p2 ) ;
}
}
próżnia wyświetl wynik ( Gracz & p1, Gracz & p2 ) {
cout << koniec ;
cout << ' \T WYNIK: \T ' ;
Jeśli ( przeciwko Komputerowi )
cout << „Gracz I:” << p1. uzyskaj wynik ( ) << ' \T Komputer: ' << p2. uzyskaj wynik ( ) << koniec ;
w przeciwnym razie
cout << „Gracz I:” << p1. uzyskaj wynik ( ) << ' \T Gracz II: „ << p2. uzyskaj wynik ( ) << koniec ;
}
publiczny :
Gra ( ) : pustyliczba { 0 } , gra włączona { 1 } , przeciwko komputerowi { 0 } {
ciepło ( ) ;
lista wygranych [ 0 ] . wiersz = nowy wew [ 3 ] { 0 , 1 , 2 } ;
lista wygranych [ 1 ] . wiersz = nowy wew [ 3 ] { 3 , 4 , 5 } ;
lista wygranych [ 2 ] . wiersz = nowy wew [ 3 ] { 6 , 7 , 8 } ;
lista wygranych [ 3 ] . wiersz = nowy wew [ 3 ] { 0 , 3 , 6 } ;
lista wygranych [ 4 ] . wiersz = nowy wew [ 3 ] { 1 , 4 , 7 } ;
lista wygranych [ 5 ] . wiersz = nowy wew [ 3 ] { 2 , 5 , 8 } ;
lista wygranych [ 6 ] . wiersz = nowy wew [ 3 ] { 0 , 4 , 8 } ;
lista wygranych [ 7 ] . wiersz = nowy wew [ 3 ] { 2 , 4 , 6 } ;
}
próżnia ciepło ( ) {
gra włączona = 1 ;
pustyliczba = 0 ;
srand ( czas ( 0 ) ) ;
Do ( rozmiar_t I = 0 ; I < 10 ; I ++ ) {
pustyIndeks [ I ] = 0 ;
tablica [ I ] = ( I + 1 ) + „0” ;
pustyliczba ++ ;
}
pustyliczba -- ;
}
próżnia gra jednego gracza ( ) {
//Tworzenie gracza
Gracz str ( „Gracz I” ) ;
Gracz C ( 'Komputer' ) ;
cout << „ ------------------' << koniec ;
cout << ' \T Gracz I: X \T Komputer: O' << koniec ;
cout << „ ------------------' << koniec ;
cout << koniec ;
przeciwko Komputerowi = 1 ;
grać ( c, s ) ;
}
próżnia gra dwuosobowa ( ) {
//Tworzenie gracza
Gracz str ( „Gracz I” ) ;
Gracz C ( „Gracz II” ) ;
cout << „ ------------------' << koniec ;
cout << ' \T Gracz I: X \T Gracz II: O” << koniec ;
cout << „ ------------------' << koniec ;
cout << koniec ;
przeciwko Komputerowi = 0 ;
grać ( c, s ) ;
}
} ;
wew główny ( )
{
wew rozdz ;
chwila ( 1 ) {
cout << ' ----------MENU----------' << koniec ;
cout << ' \T 1. Gra dla 1 gracza” << koniec ;
cout << ' \T 2. Gra dla 2 graczy” << koniec ;
cout << ' \T 3. Aby wyjść” << koniec ;
cout << „ -----' << koniec ;
cout << koniec ;
cout << ' \T Wybierz opcję' <> rozdz ;
przełącznik ( rozdz ) {
sprawa 1 : {
Gra * gra = nowy Gra ;
gra - > ciepło ( ) ;
gra - > gra jednego gracza ( ) ;
}
przerwa ;
sprawa 2 : {
Gra * gra = nowy Gra ;
gra - > ciepło ( ) ;
gra - > gra dwuosobowa ( ) ;
}
przerwa ;
sprawa 3 :
powrót 0 ;
domyślny :
cout << „OOPs nieprawidłowa opcja! SPRÓBUJ PONOWNIE” ;
}
}
powrót 0 ;
}
Jest to kompletny kod do gry w kółko i krzyżyk, w którą można grać w dwóch trybach, albo z komputerem, albo z drugim człowiekiem. Jest to kod uniwersalny, zawierający wszystkie możliwe polecenia. Gdy użytkownik wprowadzi pozycję, która jest już zajęta, nie nadpisuje tej pozycji i uważa ten ruch za nieważny.
Do tej pory pierwszy gracz wybrał pierwsze pole, a w następnej turze komputer zaznaczył szóste pole:
Obaj gracze wybrali do tej pory dwa pola, a w następnej turze gracz I wybiera siódme pole, tworząc w ten sposób kolejny pionowy wzór:
Użytkownik decyduje się na grę przy użyciu komputera, więc po wykonaniu trzech ruchów użytkownik wygrywa z komputera, a do rekordu gracza 1 dodawany jest jeden wynik. Po zakończeniu pierwszego meczu kompilator prosi o rewanż. Użytkownik wybiera jedną z opcji i program powraca do sekcji głównej. Po wybraniu opcji trzeciej kompilator rozpoczyna wykonywanie kodu.
Wniosek
Gry tekstowe opierają się na znakach tekstowych i interfejsie wiersza poleceń umożliwiającym interakcję z graczem. Nie mają obrazów graficznych, dźwięków ani animacji. Użytkownik wprowadza polecenie poprzez okno konsoli. Przyjazna dla użytkownika, tekstowa gra w kółko i krzyżyk zbudowana w języku C++. Używa różnych poleceń, aby stworzyć grę, w którą można grać z komputerem lub innym graczem.