Maak een boter-kaas-en-eieren-spel in C++
Het volgende voorbeeld geeft de basisprincipes voor het maken van dit interactieve boter-kaas-en-eierenspel voor twee spelers. Het toont een eenvoudige en gemakkelijke benadering van het programmeren met C++ en biedt een goed gedocumenteerde broncode om de uitdagingen uit je kindertijd met vrienden opnieuw te beleven in een nieuw, digitaal formaat. Laten we de volgende code bekijken.
Voorbeeld: Basic-console-gebaseerd boter-kaas-en-eieren zonder gebruik van de 2D-array
In dit voorbeeld gebruiken we een 2D-array, functies en if-else-voorwaarden om het boter-kaas-en-eierenspel in C++ te maken. In dit spel mogen twee spelers om de beurt hun zetten invoeren, en het bepaalt de spelstatus door te controleren op een winnaar of een gelijkspel. Zie de volgende gegeven code:
#include
namespace std; gebruiken ;
leegte tekenbord ( verkoold bord [ 3 ] [ 3 ] ) ;
bool isMoveValid ( verkoold bord [ 3 ] [ 3 ] , int rij , int kol ) ;
bool isBoardFull ( verkoold bord [ 3 ] [ 3 ] ) ;
verkoold checkWinnaar ( verkoold bord [ 3 ] [ 3 ] ) ;
int voornaamst ( ) {
verkoold bord [ 3 ] [ 3 ] = { { '' , '' , '' } , { '' , '' , '' } , { '' , '' , '' } } ;
int rij , kol ;
verkoold huidige speler = 'X' ;
terwijl ( WAAR ) {
tekenbord ( bord ) ;
uit << 'Speler ' << huidige speler << ' is aan de beurt. Voer rij (1-3) en kolom (1-3) in: ' ;
aan het eten >> rij >> kol ;
rij --;
kol --;
als ( isMoveValid ( bord , rij , kol ) ) {
bord [ rij ] [ kol ] = huidige speler ;
verkoold winnaar = checkWinnaar ( bord ) ;
als ( winnaar != '' ) {
tekenbord ( bord ) ;
uit << 'Speler ' << winnaar << 'is een winnaar! \N ' ;
pauze ;
}
als ( isBordVol ( bord ) ) {
tekenbord ( bord ) ;
uit << 'Het is een gelijkspel! \N ' ;
pauze ;
}
huidige speler = ( huidige speler == 'X' ) ? 'O' : 'X' ;
} anders {
uit << 'Ongeldige zet. Kies een andere cel. \N ' ;
} }
opbrengst 0 ;
}
leegte tekenbord ( verkoold bord [ 3 ] [ 3 ] ) {
uit << 'b| \T 1 \T | \T 2 \T | \T 3 \T | \N ' ;
uit << '______________________ \N ' ;
voor ( int M = 0 ; M < 3 ; M ++ ) {
uit << M + 1 << '| ' ;
voor ( int T = 0 ; T < 3 ; T ++ ) {
uit << '' << bord [ M ] [ T ] ;
als ( T < 2 ) uit << ' \T | \T ' ;
}
uit << ' \T | \N ' ;
als ( M < 2 ) uit << '______________________ \N ' ;
}
uit << ' \N ' ; }
bool isMoveValid ( verkoold bord [ 3 ] [ 3 ] , int rij , int kol ) {
opbrengst ( rij >= 0 && rij < 3 && kol >= 0 && kol < 3 && bord [ rij ] [ kol ] == '' ) ;
}
bool isBoardFull ( verkoold bord [ 3 ] [ 3 ] ) {
voor ( int M = 0 ; M < 3 ; M ++ ) {
voor ( int T = 0 ; T < 3 ; T ++ ) {
als ( bord [ M ] [ T ] == '' ) {
opbrengst vals ;
} } }
opbrengst WAAR ; }
verkoold checkWinnaar ( verkoold bord [ 3 ] [ 3 ] ) {
voor ( int M = 0 ; M < 3 ; M ++ ) {
als ( bord [ M ] [ 0 ] == bord [ M ] [ 1 ] && bord [ M ] [ 1 ] == bord [ M ] [ 2 ] && bord [ M ] [ 0 ] != '' ) {
opbrengst bord [ M ] [ 0 ] ;
}
als ( bord [ 0 ] [ M ] == bord [ 1 ] [ M ] && bord [ 1 ] [ M ] == bord [ 2 ] [ M ] && bord [ 0 ] [ M ] != '' ) {
opbrengst bord [ 0 ] [ M ] ;
} }
als ( bord [ 0 ] [ 0 ] == bord [ 1 ] [ 1 ] && bord [ 1 ] [ 1 ] == bord [ 2 ] [ 2 ] && bord [ 0 ] [ 0 ] != '' ) {
opbrengst bord [ 0 ] [ 0 ] ;
}
als ( bord [ 0 ] [ 2 ] == bord [ 1 ] [ 1 ] && bord [ 1 ] [ 1 ] == bord [ 2 ] [ 0 ] && bord [ 0 ] [ 2 ] != '' ) {
opbrengst bord [ 0 ] [ 2 ] ;
}
opbrengst '' ;
}
Hier is een overzicht van de functionaliteit:
De “#include
Er zijn vier functieprototypen in dit programma: drawBoard(), isMoveValid(), isBoardFull() en checkWinner(). De functiedeclaratie staat bekend als een functieprototype. Hoewel het na de hoofdfunctie in het programma komt, zal het worden gebruikt. De hoofdfunctie bevat de spellus en logica om de beurten en bewegingen van de spelers te beheren. Binnen de hoofdfunctie wordt het spelbord geïnitialiseerd met spaties.
verkoold bord [ 3 ] [ 3 ] = { { '' , '' , '' } , { '' , '' , '' } , { '' , '' , '' } } ;
Hierna worden twee rij- en colvariabelen gedefinieerd om de zetinvoer van de speler op te slaan. De “char currentPlayer = ‘X’;” definieert dat de “X”-speler als eerste gaat.
Nu begint de while (echte) spellus, en deze loopt totdat er een winnaar of een gelijkspel is. Deze “while”-lus roept de “drawBoard();” om het bord weer te geven. Nadat het bord op de console is weergegeven, wordt de gebruiker gevraagd een cel te kiezen die hij in de volgende code-instructie wil markeren:
uit << 'Speler ' << huidige speler << ' is aan de beurt. Voer rij en kolom in (1-3): ' ;
De speler voert zijn zet in “cin >> row >> col;”.
Bij het selecteren van een cel om te markeren, verifieert het programma eerst de geldigheid van de invoer, waarbij ervoor wordt gezorgd dat de cel niet al is gevuld door de functie isMoveValid() aan te roepen.
bord [ rij ] [ kol ] = huidige speler ;Deze verklaring plaatst het spelersteken op het bord.
verkoold winnaar = checkWinnaar ( bord ) ;als ( winnaar != '' ) {
tekenbord ( bord ) ;
uit << 'Speler ' << winnaar << ' wint! \N ' ;
Deze uitspraken controleren of er een winnaar is telkens wanneer een speler een item op het bord markeert. Als er een winnaar is, wordt de naam van de winnaar aangekondigd en verlaat het programma de spellus.
als ( isBordVol ( bord ) ) {Deze verklaring controleert op een gelijkspel. Er is sprake van een gelijkspel als het bord vol is en er geen winnaar is. In dit geval: 'Het is een gelijkspel!' wordt op het scherm afgedrukt.
huidige speler = ( huidige speler == 'X' ) ? 'O' : 'X' ;Deze verklaring schakelt de spelers om, zodat elke speler de kans krijgt om zijn beurt te spelen.
uit << 'Ongeldige zet. Kies een andere cel. \N ' ;Als de zet niet geldig is, wordt de gebruiker gevraagd opnieuw in te voeren en een andere cel te kiezen.
Na de “hoofd”-functie beginnen de functiedefinities voor de functie-prototypes die eerder zijn gedeclareerd. De eerste functie die hier wordt gedefinieerd is drawBoard() die wordt gebruikt om het boter-kaas-en-eierenbord naar de console te tekenen. De functie drawBoard() drukt de huidige status van het bord af, inclusief rasterlijnen.
De volgende functie die hier wordt gedefinieerd is isMoveValid(). Deze functie wordt gebruikt om te bepalen of een zet zowel binnen het bord als op een lege cel is toegestaan. De functie isBoardFull() wordt gebruikt om te controleren of het bord nog vol is. Dit is een voorwaarde voor een gelijkspel wanneer er geen winnaar is. De isBoardFull() controleert of alle posities op het bord gevuld zijn, wat duidt op een gelijkspel als er geen winnaar is. Als er een winnaar is, kan deze worden vastgesteld met behulp van de functie checkWinner(). De checkWinner() controleert alle potentiële winnende lijnen op het merkteken van dezelfde speler (“X” of “O”) en retourneert het merkteken van de winnende speler als dit wordt gevonden, of een spatie “ “ als er nog geen winnaar is. Het volgende is de uitvoer van het programma. Het toont elke beurt van elke speler.
Ten eerste is het bord duidelijk; speler “X” wordt gevraagd de cel te kiezen die moet worden gemarkeerd. Hier vult speler “X” 2 en 2 in. De cellen van rij 2 en kolom 2 zijn gemarkeerd. Raadpleeg het gemarkeerde bord hieronder:
Nu is het de beurt aan speler O. De speler wordt gevraagd een cel te kiezen die moet worden gemarkeerd. Speler “O” kiest 1 voor de rij en 1 voor de kolom. De gekozen cel is gemarkeerd voor speler “O”, zoals weergegeven in het volgende uitvoerfragment:
Alle beurten voor elke speler volgen hetzelfde patroon. Het is de beurt van speler X en de speler kiest 1 voor de rij en 2 voor de kolom. Raadpleeg de volgende gegeven uitvoermomentopnamen:
Nu is de beurt aan speler “O”. De speler kiest 1 voor de rij en 3 voor de kolom.
De volgende beurt is weer voor speler “X”. De speler kiest 3 voor de rij en 1 voor de kolom.
Speler “O” kiest 3 voor de rij en 2 voor de kolom.
Speler “X” selecteert de tweede rij en de derde kolom.
Speler “O” selecteert nu de tweede rij en de eerste kolom.
Speler “X” kiest deze keer de derde rij en de derde kolom.
Geen enkele speler kan een lijn horizontaal, verticaal of diagonaal maken, dus het is een gelijkspel. Er is geen winnaar voor de gekozen reeks ingangen.
Over het geheel genomen omvat de code een hoofdspellus die verantwoordelijk is voor het afhandelen van de spelstatus en gebruikersinvoer, samen met verschillende hulpprogramma's die worden gebruikt om het bord te tekenen, de zetten te valideren, te controleren of het bord vol is en te bepalen of er een winnaar is. .
Conclusie
Het ontwikkelen van een boter-kaas-en-eierenspel met C++ is een uitstekende praktische oefening om uw programmeervaardigheden te versterken. In het artikel wordt nauwkeurig uitgelegd hoe je boter-kaas-en-eieren maakt in C++. De stapsgewijze begeleiding in dit artikel omvatte een 2D-array, functies en if-else-voorwaarden waarmee de lezers de spelmechanismen, gebruikersinteracties en efficiënte codestructurering konden begrijpen. De gedetailleerde uitleg van de code en de uitleg van functies die cruciaal zijn voor de kerngameplay voorzien de lezers van onschatbare inzichten in zowel de C++-programmeerpraktijken als de fijne kneepjes van een eenvoudige game-ontwikkeling.