Een eenvoudig tekstgebaseerd spel maken in C++
Op tekst gebaseerde games in C++ stellen de speler in staat opdrachten in te voeren via een consolevenster, en het programma verwerkt de bewegingen van de speler. Hier heb ik een op tekst gebaseerd boter-kaas-en-eieren-spel gemaakt waarmee de gebruiker twee opties kan spelen. De gebruiker kan spelen met de C++-compiler of met een medemens. Dit spel heeft een functie die de score voor de winnende speler blijft optellen. Nadat de uitkomst van de eerste game is aangekondigd, is er een rematch-optie beschikbaar.
Regels voor het winnen van het spel
Twee spelers spelen een boter-kaas-en-eierenspel, waarbij X en 0 afwisselend in een van de negen beschikbare velden op een raster van drie bij drie worden geplaatst. Het spel wordt gewonnen door de eerste speler die drie van zijn opeenvolgende markeringen in verticale, horizontale of diagonale richting behaalt. Elke speler moet slim nadenken en vooruitkijken naar de volgende zet van de andere speler.
De code voor het ontwerpen van een op tekst gebaseerd boter-kaas-en-eierenspel bestaat uit verschillende secties, onderverdeeld op basis van functionaliteit. In het eerste deel beslist de gebruiker of hij met een computer of met een medemens speelt. Nadat het programma de versterkingsmodus heeft bepaald, vraagt het programma de gebruiker om invoer. Beide spelers voeren de een na de ander de invoer in.
//Neem input van spelers
leegte spelerInvoer ( Speler & speler ) {
int pos ;
uit << eindl ;
uit << ' \T ' << speler. getName ( ) << ' Draai: ' ;
uit << ' \T Vul de positie in' <> pos ;
pos - = 1 ;
als ( leegIndex [ pos ] == 1 ) {
uit << '-----Positie niet leeg-------' << eindl ;
spelerInvoer ( speler ) ;
} anders {
leegIndex [ pos ] = 1 ;
leegTel - = 1 ;
speler. getName ( ) . vergelijken ( 'Speler I' ) == 0 ? bord [ pos ] = 'X' : bord [ pos ] = 'O' ;
}
}
Na invoer van de gebruiker te hebben ontvangen, controleert het de winregel. De functie checkWin() heeft twee parameters p1 en p2 om te controleren of de speler heeft gewonnen of niet. Verschillende variabelen worden gedeclareerd in de functie i, j en k zijn gehele variabelen die voor de lus worden gedeclareerd en de vlag is een Booleaanse functie om de winvoorwaarde te controleren. De lus begint vanaf de allereerste positie en blijft herhalen voor alle negen posities. Het eerste_symbool is een teken dat 0 of X kan zijn. Als het waar is, worden alle mogelijke combinaties gecontroleerd op de winnende regel. Anders gaat de iterator naar de volgende positie en blijft dezelfde doorgaan totdat alle mogelijke posities zijn gecontroleerd. Als de vlag waar is, wordt er een winnaar uitgeroepen en vraagt het programma om de keuze opnieuw te maken.
leegte checkWin ( Speler & p1, speler & p2 ) {
int ik,j,k ;
bool vlag = vals ;
verkoold eerste_symbool ;
voor ( i = 0 ; i < 8 ; i ++ ) {
eerste_symbool = bord [ winlijst [ i ] . rij [ 0 ] ] ;
als ( ( eerste_symbool ! = 'X' ) && ( eerste_symbool ! = 'O' ) ) {
vlag = vals ;
doorgaan ;
}
vlag = WAAR ;
voor ( J = 0 ; J < 3 ; J ++ ) {
als ( eerste_symbool ! = bord [ winlijst [ i ] . rij [ J ] ] ) {
vlag = vals ;
pauze ;
}
}
als ( vlag ) {
spelAan = 0 ;
als ( eerste_symbool == 'X' ) {
uit << '-----------------------' << eindl ;
uit << ' \T Speler die ik heb gewonnen' << eindl ;
uit << '-----------------------' << eindl ;
p1. won ( ) ;
} anders {
p2. won ( ) ;
als ( tegen Computer ) {
uit << '-----------------------' << eindl ;
uit << ' \T Computer gewonnen' << eindl ;
uit << '-----------------------' << eindl ;
} anders {
uit << '-----------------------' << eindl ;
uit << ' \T Speler II heeft gewonnen' << eindl ;
uit << '-----------------------' << eindl ;
}
}
weergaveScore ( p1,p2 ) ;
pauze ;
}
Dit deel van de code toont de score van het spel. Als het spel tegen een computer is, wordt de score van speler 1 en de computer weergegeven, anders wordt de score van speler 1 en speler 2 weergegeven.
leegte weergaveScore ( Speler & p1, speler & p2 ) {
uit << eindl ;
uit << ' \T SCORE: \T ' ;
als ( tegen Computer )
uit << ' Speler I: ' << p1. haalScore ( ) << ' \T Computer: ' << p2. haalScore ( ) << eindl ;
anders
uit << ' Speler I: ' << p1. haalScore ( ) << ' \T Speler II: ' << p2. haalScore ( ) << eindl ;
}
Dit is de hoofdcode voor de uitvoering van het boter-kaas-en-eieren-spel voor twee spelers. De gebruiker kan kiezen uit een verscheidenheid aan procedures die moeten worden uitgevoerd met behulp van de switch case-instructie. Deze code biedt een gebruiksvriendelijke interface voor het spelen van een game op een C++-compiler, en de code blijft worden uitgevoerd totdat de gebruiker de afsluitoptie selecteert.
int voornaamst ( ){
int ch ;
terwijl ( 1 ) {
uit << ' ----------MENU----------' << eindl ;
uit << ' \T 1. Spel voor 1 speler' << eindl ;
uit << ' \T 2. Spel voor 2 spelers' << eindl ;
uit << ' \T 3. Om af te sluiten ' << eindl ;
uit << ' ----------' << eindl ;
uit << eindl ;
uit << ' \T Kies een optie' <> ch ;
schakelaar ( ch ) {
geval 1 : {
Spel * spel = nieuw Spel ;
spel - > warmte ( ) ;
spel - > onePlayerGame ( ) ;
}
pauze ;
geval 2 : {
Spel * spel = nieuw Spel ;
spel - > warmte ( ) ;
spel - > tweespelerspel ( ) ;
}
pauze ;
geval 3 :
opbrengst 0 ;
standaard :
uit << 'OOPs ongeldige optie! PROBEER OPNIEUW' ;
}
}
opbrengst 0 ;
}
Volledige code voor een op tekst gebaseerd Tic-Tac-Toc-spel
Dit is een complete code voor het ontwerp en de uitvoering van een op tekst gebaseerd boter-kaas-en-eierenspel.
#include
#include
#include
#include
#include
gebruik makend van naamruimte soa ;
typedef structureren {
int * rij ;
} WinLijst ;
klas Speler {
privaat :
tekenreeks naam ;
int scoren ;
openbaar :
Speler ( ) : Speler { '' } { }
Speler ( string n ) : scoren { 0 } , naam { N } { }
leegte won ( ) {
//verhoog de score
scoren ++ ;
}
int haalScore ( ) { opbrengst dit - > scoren ; }
tekenreeks getName ( ) { opbrengst dit - > naam ; }
} ;
klas Spel {
privaat :
verkoold bord [ 9 ] ;
int leegIndex [ 9 ] ;
int gameOn, tegen Computer ;
int leegTel ;
WinList-winlijst [ 8 ] ;
leegte displayscherm ( ) {
uit << eindl ;
uit << ' | | ' << eindl ;
uit << ' ' << bord [ 0 ] << ' | ' << bord [ 1 ] << ' | ' << bord [ 2 ] << eindl ;
uit << ' | | ' << eindl ;
uit << '-----------' << eindl ;
uit << ' | | ' << eindl ;
uit << ' ' << bord [ 3 ] << ' | ' << bord [ 4 ] << ' | ' << bord [ 5 ] << eindl ;
uit << ' | | ' << eindl ;
uit << '-----------' << eindl ;
uit << ' | | ' << eindl ;
uit << ' ' << bord [ 6 ] << ' | ' << bord [ 7 ] << ' | ' << bord [ 8 ] << eindl ;
uit << ' | | ' << eindl ;
uit << eindl ;
}
leegte computerInvoer ( ) {
int pos ;
pos = rand ( ) % 10 ;
als ( leegIndex [ pos ] == 1 ) {
als ( leegTel < 0 )
opbrengst ;
computerInvoer ( ) ;
} anders {
uit << 'Computerkeuze:' << pos + 1 << eindl ;
leegIndex [ pos ] = 1 ;
leegTel - = 1 ;
bord [ pos ] = 'O' ;
}
}
leegte spelerInvoer ( Speler & speler ) {
int pos ;
uit << eindl ;
uit << ' \T ' << speler. getName ( ) << ' Draai: ' ;
uit << ' \T Vul de positie in' <> pos ;
pos - = 1 ;
als ( leegIndex [ pos ] == 1 ) {
uit << '-----Positie niet leeg-------' << eindl ;
spelerInvoer ( speler ) ;
} anders {
leegIndex [ pos ] = 1 ;
leegTel - = 1 ;
speler. getName ( ) . vergelijken ( 'Speler I' ) == 0 ? bord [ pos ] = 'X' : bord [ pos ] = 'O' ;
}
}
leegte checkWin ( Speler & p1, speler & p2 ) {
int ik,j,k ;
bool vlag = vals ;
verkoold eerste_symbool ;
voor ( i = 0 ; i < 8 ; i ++ ) {
eerste_symbool = bord [ winlijst [ i ] . rij [ 0 ] ] ;
als ( ( eerste_symbool ! = 'X' ) && ( eerste_symbool ! = 'O' ) ) {
vlag = vals ;
doorgaan ;
}
vlag = WAAR ;
voor ( J = 0 ; J < 3 ; J ++ ) {
als ( eerste_symbool ! = bord [ winlijst [ i ] . rij [ J ] ] ) {
vlag = vals ;
pauze ;
}
}
als ( vlag ) {
spelAan = 0 ;
als ( eerste_symbool == 'X' ) {
uit << '-----------------------' << eindl ;
uit << ' \T Speler die ik heb gewonnen' << eindl ;
uit << '-----------------------' << eindl ;
p1. won ( ) ;
} anders {
p2. won ( ) ;
als ( tegen Computer ) {
uit << '-----------------------' << eindl ;
uit << ' \T Computer gewonnen' << eindl ;
uit << '-----------------------' << eindl ;
} anders {
uit << '-----------------------' << eindl ;
uit << ' \T Speler II heeft gewonnen' << eindl ;
uit << '-----------------------' < 0 ) && ( spelAan ! = 0 ) ) {
als ( tegen Computer )
hand == 1 ? computerInvoer ( ) : spelerInvoer ( p2 ) ;
anders
hand == 1 ? spelerInvoer ( p1 ) : spelerInvoer ( p2 ) ;
hand = ! hand ;
displayscherm ( ) ;
checkWin ( p1,p2 ) ;
}
als ( leegTel <= 0 ) {
uit << ' -----------------------' << eindl ;
uit << ' \T Geen WINNAAR' << eindl ;
uit << ' -----------------------' << eindl ;
}
uit << eindl ;
uit <> herkansing ;
als ( ( herkansing == 'EN' ) || ( herkansing == 'En' ) ) {
warmte ( ) ;
toneelstuk ( p1,p2 ) ;
}
}
leegte weergaveScore ( Speler & p1, speler & p2 ) {
uit << eindl ;
uit << ' \T SCORE: \T ' ;
als ( tegen Computer )
uit << ' Speler I: ' << p1. haalScore ( ) << ' \T Computer: ' << p2. haalScore ( ) << eindl ;
anders
uit << ' Speler I: ' << p1. haalScore ( ) << ' \T Speler II: ' << p2. haalScore ( ) << eindl ;
}
openbaar :
Spel ( ) : leegTel { 0 } , spelAan { 1 } , tegen Computer { 0 } {
warmte ( ) ;
winlijst [ 0 ] . rij = nieuw int [ 3 ] { 0 , 1 , 2 } ;
winlijst [ 1 ] . rij = nieuw int [ 3 ] { 3 , 4 , 5 } ;
winlijst [ 2 ] . rij = nieuw int [ 3 ] { 6 , 7 , 8 } ;
winlijst [ 3 ] . rij = nieuw int [ 3 ] { 0 , 3 , 6 } ;
winlijst [ 4 ] . rij = nieuw int [ 3 ] { 1 , 4 , 7 } ;
winlijst [ 5 ] . rij = nieuw int [ 3 ] { 2 , 5 , 8 } ;
winlijst [ 6 ] . rij = nieuw int [ 3 ] { 0 , 4 , 8 } ;
winlijst [ 7 ] . rij = nieuw int [ 3 ] { 2 , 4 , 6 } ;
}
leegte warmte ( ) {
spelAan = 1 ;
leegTel = 0 ;
strand ( tijd ( 0 ) ) ;
voor ( maat_t i = 0 ; i < 10 ; i ++ ) {
leegIndex [ i ] = 0 ;
bord [ i ] = ( i + 1 ) + '0' ;
leegTel ++ ;
}
leegTel -- ;
}
leegte onePlayerGame ( ) {
// Speler maken
Speler p ( 'Speler I' ) ;
Speler c ( 'Computer' ) ;
uit << ' -----------------------' << eindl ;
uit << ' \T Speler I: X \T Computer: O' << eindl ;
uit << ' -----------------------' << eindl ;
uit << eindl ;
tegen Computer = 1 ;
toneelstuk ( c, p ) ;
}
leegte tweespelerspel ( ) {
// Speler maken
Speler p ( 'Speler I' ) ;
Speler c ( 'Speler II' ) ;
uit << ' -----------------------' << eindl ;
uit << ' \T Speler I: X \T Speler II: O' << eindl ;
uit << ' -----------------------' << eindl ;
uit << eindl ;
tegen Computer = 0 ;
toneelstuk ( c, p ) ;
}
} ;
int voornaamst ( )
{
int ch ;
terwijl ( 1 ) {
uit << ' ----------MENU----------' << eindl ;
uit << ' \T 1. Spel voor 1 speler' << eindl ;
uit << ' \T 2. Spel voor 2 spelers' << eindl ;
uit << ' \T 3. Om af te sluiten ' << eindl ;
uit << ' ----------' << eindl ;
uit << eindl ;
uit << ' \T Kies een optie' <> ch ;
schakelaar ( ch ) {
geval 1 : {
Spel * spel = nieuw Spel ;
spel - > warmte ( ) ;
spel - > onePlayerGame ( ) ;
}
pauze ;
geval 2 : {
Spel * spel = nieuw Spel ;
spel - > warmte ( ) ;
spel - > tweespelerspel ( ) ;
}
pauze ;
geval 3 :
opbrengst 0 ;
standaard :
uit << 'OOPs ongeldige optie! PROBEER OPNIEUW' ;
}
}
opbrengst 0 ;
}
Dit is een complete code voor de uitvoering van het boter-kaas-en-eieren-spel, dat in twee modi kan worden gespeeld, met een computer of met een medemens. Dit is een veelzijdige code, inclusief alle mogelijke opdrachten. Wanneer de gebruiker een stelling invoert die al bezet is, overschrijft hij deze stelling niet en beschouwt hij deze zet als ongeldig.
Tot nu toe heeft speler één het eerste vakje geselecteerd en in de volgende beurt heeft de computer het zesde vakje gemarkeerd:
Beide spelers hebben tot nu toe de twee vakjes geselecteerd en in de volgende beurt kiest speler I het zevende vakje, waardoor een opeenvolgend verticaal patroon ontstaat:
De gebruiker kiest ervoor om de computer te gebruiken om een partij te spelen, dus na drie zetten te hebben gedaan, wint de gebruiker van de computer en wordt één score toegevoegd aan het record van speler 1. Nadat de eerste wedstrijd voorbij is, vraagt de samensteller om de herkansing. De gebruiker kiest uit de opties en het programma keert terug naar het hoofdgedeelte. Na het kiezen van optie drie bestaat de compiler uit het uitvoeren van code.
Conclusie
Op tekst gebaseerde games zijn afhankelijk van teksttekens en een opdrachtregelinterface voor interactie met de speler. Ze hebben geen grafische afbeeldingen, geluiden of animaties. De gebruiker voert de opdracht in via het consolevenster. Het gebruiksvriendelijke, op tekst gebaseerde boter-kaas-en-eieren-spel is gebouwd met behulp van C++. Er worden verschillende commando's gebruikt om een spel te maken dat zowel met een computer als met een andere medespeler gespeeld kan worden.