Hur man skapar ett grundläggande textbaserat spel i C++
Textbaserade spel i C++ låter spelaren mata in kommandon genom ett konsolfönster, och programmet bearbetar spelarens rörelser. Här har jag skapat ett textbaserat tic-tac-toe-spel som tillåter två alternativ för användaren att spela. Användaren kan antingen spela med C++-kompilatorn eller med en medmänniska. Detta spel har en funktion som fortsätter att lägga ihop poängen för den vinnande spelaren. Efter att resultatet av det första spelet har meddelats finns ett alternativ för rematch tillgängligt.
Regler för att vinna spelet
Två spelare spelar ett tic-tac-toe-spel och placerar X och 0 alternativt i en av de nio tillgängliga utrymmena på ett tre-av-tre-rutnät. Spelet vinner den första spelaren som får tre av sina på varandra följande poäng i vertikal, horisontell eller diagonal riktning. Varje spelare måste tänka smart och se framåt till nästa drag av den andra spelaren.
Koden för att designa ett textbaserat tick-tac-toe-spel har olika sektioner, uppdelade efter funktionalitet. I det första avsnittet bestämmer användaren om han vill spela med en dator eller en medmänniska. Efter att ha bestämt förstärkningsläget ber programmet användaren om input. Båda spelarna anger input efter varandra.
//Ta input från spelare
tomhet spelaringång ( Spelare & spelare ) {
int pos ;
cout << endl ;
cout << ' \t ' << spelare. hämta namn ( ) << ' Sväng: ' ;
cout << ' \t Ange positionen ' <> pos ;
pos - = 1 ;
om ( tomtIndex [ pos ] == 1 ) {
cout << '-----Position inte tom-------' << endl ;
spelaringång ( spelare ) ;
} annan {
tomtIndex [ pos ] = 1 ;
emptyCount - = 1 ;
spelare. hämta namn ( ) . jämföra ( 'Spelare I' ) == 0 ? styrelse [ pos ] = 'X' : styrelse [ pos ] = 'O' ;
}
}
Efter att ha tagit in uppgifter från användaren kontrollerar den vinstregeln. CheckWin()-funktionen har två parametrar p1 och p2 för att kontrollera om spelaren har vunnit eller inte. Olika variabler deklareras i funktionen i, j och k är heltalsvariabler som deklareras för slingan och flaggan är en boolesk funktion för att kontrollera vinstvillkoret. Slingan börjar från den allra första positionen och fortsätter att iterera för alla nio positionerna. First_symbolen är ett tecken som kan vara 0 eller X om det är sant, då kontrolleras alla möjliga kombinationer för den vinnande regeln. Annars flyttar iteratorn till nästa position, och detsamma fortsätter tills alla möjliga positioner är kontrollerade. Om flaggan är inställd på sann, utses en vinnare och programmet ber om att göra valet igen.
tomhet checkWin ( Spelare & p1, spelare & p2 ) {
int jag, j,k ;
bool flagga = falsk ;
röding första_symbol ;
för ( i = 0 ; i < 8 ; i ++ ) {
första_symbol = styrelse [ vinstlista [ i ] . rad [ 0 ] ] ;
om ( ( första_symbol ! = 'X' ) && ( första_symbol ! = 'O' ) ) {
flagga = falsk ;
Fortsätta ;
}
flagga = Sann ;
för ( j = 0 ; j < 3 ; j ++ ) {
om ( första_symbol ! = styrelse [ vinstlista [ i ] . rad [ j ] ] ) {
flagga = falsk ;
ha sönder ;
}
}
om ( flagga ) {
gameOn = 0 ;
om ( första_symbol == 'X' ) {
cout << '------------------------' << endl ;
cout << ' \t Spelare jag vann' << endl ;
cout << '------------------------' << endl ;
p1. vann ( ) ;
} annan {
p2. vann ( ) ;
om ( mot dator ) {
cout << '------------------------' << endl ;
cout << ' \t Dator vann' << endl ;
cout << '------------------------' << endl ;
} annan {
cout << '------------------------' << endl ;
cout << ' \t Spelare II VANN' << endl ;
cout << '------------------------' << endl ;
}
}
visaScore ( p1, p2 ) ;
ha sönder ;
}
Den här delen av koden visar poängen för spelet. Om spelet är mot en dator, så visas poängen för spelare 1 och datorn, annars visas poängen för spelare 1 och spelare 2.
tomhet visaScore ( Spelare & p1, spelare & p2 ) {
cout << endl ;
cout << ' \t GÖRA: \t ' ;
om ( mot dator )
cout << 'Spelare I:' << p1. getScore ( ) << ' \t Dator: ' << p2. getScore ( ) << endl ;
annan
cout << 'Spelare I:' << p1. getScore ( ) << ' \t Spelare II: ' << p2. getScore ( ) << endl ;
}
Detta är huvudkoden för att köra tic-tac-toe-spel för två spelare. Användaren kan välja från en mängd olika procedurer som ska utföras med hjälp av switch case-satsen. Denna kod ger ett användarvänligt gränssnitt för att spela ett spel på en C++-kompilator, och koden fortsätter att köras tills användaren väljer utgångsalternativet.
int huvud ( ){
int kap ;
medan ( 1 ) {
cout << ' ---------MENY----------' << endl ;
cout << ' \t 1. 1-spelares spel' << endl ;
cout << ' \t 2. 2-spelares spel' << endl ;
cout << ' \t 3. Att avsluta ' << endl ;
cout << ' ----------' << endl ;
cout << endl ;
cout << ' \t Välj ett alternativ' <> kap ;
växla ( kap ) {
fall 1 : {
Spel * spel = ny Spel ;
spel - > värme ( ) ;
spel - > onePlayerGame ( ) ;
}
ha sönder ;
fall 2 : {
Spel * spel = ny Spel ;
spel - > värme ( ) ;
spel - > twoPlayerGame ( ) ;
}
ha sönder ;
fall 3 :
lämna tillbaka 0 ;
standard :
cout << 'OJ Ogiltigt alternativ! FÖRSÖK IGEN' ;
}
}
lämna tillbaka 0 ;
}
Komplett kod för ett textbaserat Tic-Tac-Toc-spel
Detta är en komplett kod för design och utförande av ett textbaserat tic-tac-toe-spel.
#include
#inkludera
#include
#inkludera
#inkludera
använder sig av namnutrymme std ;
typdef struktur {
int * rad ;
} WinList ;
klass Spelare {
privat :
strängnamn ;
int Göra ;
offentlig :
Spelare ( ) : Spelare { '' } { }
Spelare ( sträng n ) : Göra { 0 } , namn { n } { }
tomhet vann ( ) {
//öka poängen
Göra ++ ;
}
int getScore ( ) { lämna tillbaka detta - > Göra ; }
sträng getName ( ) { lämna tillbaka detta - > namn ; }
} ;
klass Spel {
privat :
röding styrelse [ 9 ] ;
int tomtIndex [ 9 ] ;
int gameOn, mot dator ;
int emptyCount ;
WinList vinstlista [ 8 ] ;
tomhet displayboard ( ) {
cout << endl ;
cout << ' | | ' << endl ;
cout << ' ' << styrelse [ 0 ] << ' | ' << styrelse [ 1 ] << ' | ' << styrelse [ 2 ] << endl ;
cout << ' | | ' << endl ;
cout << '----------------' << endl ;
cout << ' | | ' << endl ;
cout << ' ' << styrelse [ 3 ] << ' | ' << styrelse [ 4 ] << ' | ' << styrelse [ 5 ] << endl ;
cout << ' | | ' << endl ;
cout << '----------------' << endl ;
cout << ' | | ' << endl ;
cout << ' ' << styrelse [ 6 ] << ' | ' << styrelse [ 7 ] << ' | ' << styrelse [ 8 ] << endl ;
cout << ' | | ' << endl ;
cout << endl ;
}
tomhet datoringång ( ) {
int pos ;
pos = rand ( ) % 10 ;
om ( tomtIndex [ pos ] == 1 ) {
om ( emptyCount < 0 )
lämna tillbaka ;
datoringång ( ) ;
} annan {
cout << 'Datorvälj:' << pos + 1 << endl ;
tomtIndex [ pos ] = 1 ;
emptyCount - = 1 ;
styrelse [ pos ] = 'O' ;
}
}
tomhet spelaringång ( Spelare & spelare ) {
int pos ;
cout << endl ;
cout << ' \t ' << spelare. hämta namn ( ) << ' Sväng: ' ;
cout << ' \t Ange positionen ' <> pos ;
pos - = 1 ;
om ( tomtIndex [ pos ] == 1 ) {
cout << '-----Position inte tom-------' << endl ;
spelaringång ( spelare ) ;
} annan {
tomtIndex [ pos ] = 1 ;
emptyCount - = 1 ;
spelare. hämta namn ( ) . jämföra ( 'Spelare I' ) == 0 ? styrelse [ pos ] = 'X' : styrelse [ pos ] = 'O' ;
}
}
tomhet checkWin ( Spelare & p1, spelare & p2 ) {
int jag, j,k ;
bool flagga = falsk ;
röding första_symbol ;
för ( i = 0 ; i < 8 ; i ++ ) {
första_symbol = styrelse [ vinstlista [ i ] . rad [ 0 ] ] ;
om ( ( första_symbol ! = 'X' ) && ( första_symbol ! = 'O' ) ) {
flagga = falsk ;
Fortsätta ;
}
flagga = Sann ;
för ( j = 0 ; j < 3 ; j ++ ) {
om ( första_symbol ! = styrelse [ vinstlista [ i ] . rad [ j ] ] ) {
flagga = falsk ;
ha sönder ;
}
}
om ( flagga ) {
gameOn = 0 ;
om ( första_symbol == 'X' ) {
cout << '------------------------' << endl ;
cout << ' \t Spelare jag vann' << endl ;
cout << '------------------------' << endl ;
p1. vann ( ) ;
} annan {
p2. vann ( ) ;
om ( mot dator ) {
cout << '------------------------' << endl ;
cout << ' \t Dator vann' << endl ;
cout << '------------------------' << endl ;
} annan {
cout << '------------------------' << endl ;
cout << ' \t Spelare II VANN' << endl ;
cout << '------------------------' < 0 ) && ( gameOn ! = 0 ) ) {
om ( mot dator )
hand == 1 ? datoringång ( ) : spelaringång ( p2 ) ;
annan
hand == 1 ? spelaringång ( p1 ) : spelaringång ( p2 ) ;
hand = ! hand ;
displayboard ( ) ;
checkWin ( p1, p2 ) ;
}
om ( emptyCount <= 0 ) {
cout << ' ------------------------------' << endl ;
cout << ' \t Ingen VINNARE' << endl ;
cout << ' ------------------------------' << endl ;
}
cout << endl ;
cout <> returmatch ;
om ( ( returmatch == 'OCH' ) || ( returmatch == 'och' ) ) {
värme ( ) ;
spela ( p1, p2 ) ;
}
}
tomhet visaScore ( Spelare & p1, spelare & p2 ) {
cout << endl ;
cout << ' \t GÖRA: \t ' ;
om ( mot dator )
cout << 'Spelare I:' << p1. getScore ( ) << ' \t Dator: ' << p2. getScore ( ) << endl ;
annan
cout << 'Spelare I:' << p1. getScore ( ) << ' \t Spelare II: ' << p2. getScore ( ) << endl ;
}
offentlig :
Spel ( ) : emptyCount { 0 } , gameOn { 1 } , mot dator { 0 } {
värme ( ) ;
vinstlista [ 0 ] . rad = ny int [ 3 ] { 0 , 1 , 2 } ;
vinstlista [ 1 ] . rad = ny int [ 3 ] { 3 , 4 , 5 } ;
vinstlista [ 2 ] . rad = ny int [ 3 ] { 6 , 7 , 8 } ;
vinstlista [ 3 ] . rad = ny int [ 3 ] { 0 , 3 , 6 } ;
vinstlista [ 4 ] . rad = ny int [ 3 ] { 1 , 4 , 7 } ;
vinstlista [ 5 ] . rad = ny int [ 3 ] { 2 , 5 , 8 } ;
vinstlista [ 6 ] . rad = ny int [ 3 ] { 0 , 4 , 8 } ;
vinstlista [ 7 ] . rad = ny int [ 3 ] { 2 , 4 , 6 } ;
}
tomhet värme ( ) {
gameOn = 1 ;
emptyCount = 0 ;
srand ( tid ( 0 ) ) ;
för ( storlek_t i = 0 ; i < 10 ; i ++ ) {
tomtIndex [ i ] = 0 ;
styrelse [ i ] = ( i + 1 ) + '0' ;
emptyCount ++ ;
}
emptyCount -- ;
}
tomhet onePlayerGame ( ) {
//Skapar spelare
Spelare sid ( 'Spelare I' ) ;
Spelare c ( 'Dator' ) ;
cout << ' ----------------------------' << endl ;
cout << ' \t Spelare I: X \t Dator: O' << endl ;
cout << ' ----------------------------' << endl ;
cout << endl ;
mot dator = 1 ;
spela ( c, sid ) ;
}
tomhet twoPlayerGame ( ) {
//Skapar spelare
Spelare sid ( 'Spelare I' ) ;
Spelare c ( 'Spelare II' ) ;
cout << ' ----------------------------' << endl ;
cout << ' \t Spelare I: X \t Spelare II: O' << endl ;
cout << ' ----------------------------' << endl ;
cout << endl ;
mot dator = 0 ;
spela ( c, sid ) ;
}
} ;
int huvud ( )
{
int kap ;
medan ( 1 ) {
cout << ' ---------MENY----------' << endl ;
cout << ' \t 1. 1-spelares spel' << endl ;
cout << ' \t 2. 2-spelares spel' << endl ;
cout << ' \t 3. Att avsluta ' << endl ;
cout << ' ----------' << endl ;
cout << endl ;
cout << ' \t Välj ett alternativ' <> kap ;
växla ( kap ) {
fall 1 : {
Spel * spel = ny Spel ;
spel - > värme ( ) ;
spel - > onePlayerGame ( ) ;
}
ha sönder ;
fall 2 : {
Spel * spel = ny Spel ;
spel - > värme ( ) ;
spel - > twoPlayerGame ( ) ;
}
ha sönder ;
fall 3 :
lämna tillbaka 0 ;
standard :
cout << 'OJ Ogiltigt alternativ! FÖRSÖK IGEN' ;
}
}
lämna tillbaka 0 ;
}
Detta är en komplett kod för att köra tic-tac-toe-spelet, som kan spelas i två lägen, antingen med en dator eller en medmänniska. Detta är en mångsidig kod, inklusive alla möjliga kommandon. När användaren matar in en position som redan är fylld, skriver den inte över denna position och anser att denna flytt är ogiltig.
Hittills har spelare ett valt den första rutan och sedan i nästa tur har datorn markerat den sjätte rutan:
Båda spelarna har valt de två rutorna tills nu och i nästa omgång väljer spelaren I den sjunde rutan vilket resulterar i att skapa ett på varandra följande vertikalt mönster:
Användaren väljer att använda datorn för att spela ett spel, så efter att ha tagit tre drag, vann användaren från datorn och en poäng läggs till rekordet för spelare 1. När den första matchen är över ber kompilatorn om ommatchen. Användaren bestämmer från alternativen och programmet återgår till huvudsektionen. Efter att ha valt alternativ tre existerar kompilatorn exekvering av kod.
Slutsats
Textbaserade spel förlitar sig på texttecken och ett kommandoradsgränssnitt för interaktion med spelaren. De har inga grafiska bilder, ljud eller animationer. Användaren matar in kommandot genom konsolfönstret. Det användarvänliga textbaserade tic-tac-toe-spelet är byggt med C++. Den använder olika kommandon för att skapa ett spel som antingen kan spelas med en dator eller en annan medspelare.