Juego de tres en raya en C++
- Juego de tres en raya en C++
- Paso 1: Cree una función que dibuje una cuadrícula de 3 por 3
- Paso 2: solicite al usuario que ingrese números de fila y columna
- Paso 3: compruebe si la posición ingresada por el usuario está ocupada
- Paso 4: crea una función para verificar el ganador del juego
Este tutorial discutirá la creación del juego de tres en raya usando instrucciones condicionales y bucles en C++.
Juego de tres en raya en C++
Tic tac toe es un juego de dos jugadores en el que cada jugador marca un lugar dentro de una cuadrícula de 3 por 3, y el jugador que coloca con éxito tres marcas en una línea recta horizontal, vertical o diagonal será el ganador del juego. . A continuación se muestra una imagen de ejemplo del juego.
Podemos ver que el jugador X es el ganador del juego de tres en raya porque los tres marcadores del jugador X están en una línea diagonal recta. Para crear el mismo juego en C++, tenemos que usar el mismo algoritmo para jugar con lápiz y papel.
Usando el bolígrafo, dibujamos la cuadrícula de 3 por 3 en el papel y luego cada jugador gira para colocar un marcador dentro de la cuadrícula en el espacio desocupado. Cuando un jugador logra colocar tres marcadores en línea recta, ese jugador ganará el juego y el juego habrá terminado.
Si ninguno de los jugadores coloca tres marcadores en línea recta o todos los lugares dentro de la cuadrícula están ocupados, el juego terminará con un empate. Podemos usar el mismo algoritmo para crear el juego de tres en raya en C++.
En el primer paso, tenemos que crear una función dibujando una cuadrícula de 3 por 3. En el segundo paso, debemos tomar la entrada del usuario en forma de números de fila y columna y verificar si la entrada es válida.
En el tercer paso, tenemos que verificar si la posición ingresada por el usuario está ocupada o no, y si no está ocupada, colocaremos el marcador del jugador dentro de la grilla en la posición ingresada por el usuario, y si la el lugar está ocupado, le pediremos al jugador que ingrese a otra posición. Si todas las posiciones están ocupadas, daremos por terminado el juego y anunciaremos que hay empate.
En el cuarto paso, comprobaremos si tres marcadores de cualquiera de los jugadores están en línea recta o no. Si los marcadores de un jugador están en línea recta, finalizaremos el juego y anunciaremos el nombre del jugador que ganó el juego, y si los marcadores no están en línea recta, volveremos al segundo paso y repetiremos.
Paso 1: Cree una función que dibuje una cuadrícula de 3 por 3
Ahora comencemos a crear el juego desde el primer paso en el que tenemos que dibujar un tablero de 3 por 3. Podemos dibujar un tablero usando una combinación de caracteres de tubería | y puntee los caracteres - del teclado.
Podemos usar los caracteres de guión - para dibujar la línea horizontal y el carácter de tubería | para dibujar la línea vertical presente en una cuadrícula, y podemos usar números para marcar el número de fila y columna de la cuadrícula. Por ejemplo, usemos la función cout() de C++ para dibujar la cuadrícula de 3 por 3.
Vea el código a continuación.
#include <iomanip>
#include <iostream>
using namespace std;
void drawGameBoard(char Gameboard[][3]);
int main() {
char Gameboard[3][3] = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}};
drawGameBoard(Gameboard);
return 0;
}
void drawGameBoard(char Gameboard[][3]) {
cout << " 1 2 3" << endl;
cout << " -------------" << endl;
cout << " 1"
<< " | " << Gameboard[0][0] << " | " << Gameboard[0][1] << " | "
<< Gameboard[0][2] << " | " << endl;
cout << " -------------" << endl;
cout << " 2"
<< " | " << Gameboard[1][0] << " | " << Gameboard[1][1] << " | "
<< Gameboard[1][2] << " | " << endl;
cout << " -------------" << endl;
cout << " 3"
<< " | " << Gameboard[2][0] << " | " << Gameboard[2][1] << " | "
<< Gameboard[2][2] << " | " << endl;
cout << " -------------" << endl;
}
Producción :
1 2 3
-------------
1 | | | |
-------------
2 | | | |
-------------
3 | | | |
-------------
El código anterior usa la declaración endl para mover el cursor a la nueva línea. En el resultado anterior, los números se reproducen verticalmente para representar el número de fila y los números horizontales representan el número de columna.
Paso 2: solicite al usuario que ingrese números de fila y columna
En el segundo paso, podemos pedirle al usuario que ingrese la fila y el número de columna en el que el usuario desea colocar su marcador. Usaremos una declaración condicional para verificar la entrada del usuario, y si el número de fila o columna no está en el rango de 1 a 3, mostraremos un error y le pediremos al usuario que ingrese la entrada nuevamente.
Usaremos un ciclo para tomar la entrada del usuario, y el ciclo continuará hasta que el usuario ingrese un número de fila y columna válido. Por ejemplo, usemos un bucle while y una declaración if-else para recibir información del usuario.
Vea el código a continuación.
#include <iomanip>
#include <iostream>
using namespace std;
void drawGameBoard(char Gameboard[][3]);
int main() {
int Boardrow;
int Boardcolumn;
bool is_Boardrow;
bool is_Boardcolumn;
char Gameboard[3][3] = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}};
drawGameBoard(Gameboard);
is_Boardrow = false;
while (!is_Boardrow) {
cout << "BoardRow: ";
cin >> Boardrow;
if (Boardrow == 1 || Boardrow == 2 || Boardrow == 3) {
is_Boardrow = true;
} else {
cout << endl << "Invalid Boardrow!" << endl;
}
}
is_Boardcolumn = false;
while (!is_Boardcolumn) {
cout << "BoardColumn: ";
cin >> Boardcolumn;
if (Boardcolumn == 1 || Boardcolumn == 2 || Boardcolumn == 3) {
is_Boardcolumn = true;
} else {
cout << endl << "Invalid Boardcolumn!" << endl;
}
}
return 0;
}
void drawGameBoard(char Gameboard[][3]) {
cout << " 1 2 3" << endl;
cout << " -------------" << endl;
cout << " 1"
<< " | " << Gameboard[0][0] << " | " << Gameboard[0][1] << " | "
<< Gameboard[0][2] << " | " << endl;
cout << " -------------" << endl;
cout << " 2"
<< " | " << Gameboard[1][0] << " | " << Gameboard[1][1] << " | "
<< Gameboard[1][2] << " | " << endl;
cout << " -------------" << endl;
cout << " 3"
<< " | " << Gameboard[2][0] << " | " << Gameboard[2][1] << " | "
<< Gameboard[2][2] << " | " << endl;
cout << " -------------" << endl;
}
Producción :
1 2 3
-------------
1 | | | |
-------------
2 | | | |
-------------
3 | | | |
-------------
BoardRow: 5
Invalid Boardrow!
BoardRow: 1
BoardColumn: 6
Invalid Boardcolumn!
BoardColumn: 2
En el código anterior, usamos dos enteros, Boardrow y Boardcolumn, para almacenar la entrada del usuario. Usamos dos variables booleanas, is_boardRow y is_boardColumn, para almacenar el estado de la entrada.
Estableceremos las dos variables booleanas en false, y el bucle se repetirá y le pedirá al usuario que ingrese el número de fila y columna, y cuando el número ingresado sea válido, el booleano se establecerá en true, y el el bucle se romperá. Hemos utilizado dos bucles, uno para el número de fila y otro para el número de columna.
El resultado anterior muestra que cuando ingresamos un número de fila o columna no válido, el código muestra un número de fila o columna no válido y le pedirá al usuario que ingrese la entrada nuevamente.
Paso 3: compruebe si la posición ingresada por el usuario está ocupada
En el tercer paso, debemos colocar el marcador de los jugadores en la posición que ingresó el usuario, pero antes de eso, debemos verificar si la posición ingresada está ocupada.
Si la posición está ocupada, le pediremos al usuario que ingrese otra posición, y si la posición no está ocupada, colocaremos el marcador del jugador dentro del tablero en la posición ingresada.
Tendremos que cambiar el jugador después de que un jugador coloque con éxito un marcador en el tablero o cuadrícula del juego. Por ejemplo, usemos un bucle y declaraciones de condición para colocar el marcador en el tablero.
Vea el código a continuación.
#include <iomanip>
#include <iostream>
using namespace std;
void drawGameBoard(char Gameboard[][3]);
char checkGameWinner3by3(char Gameboard[][3]);
int main() {
char Gameboard[3][3] = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}};
char Gameplayer = 'X';
char Gamewinner = ' ';
int Boardrow;
int Boardcolumn;
bool is_Validmove;
bool is_Boardrow;
bool is_Boardcolumn;
cout << "************ TIC TAC TOE Game ************\n";
while (Gamewinner == ' ') {
is_Validmove = false;
is_Boardrow = false;
is_Boardcolumn = false;
drawGameBoard(Gameboard);
cout << "GamePlayer ";
if (Gameplayer == 'X') {
cout << 'X';
} else {
cout << 'O';
}
cout << "'s turn:" << endl;
is_Validmove = false;
while (!is_Validmove) {
is_Boardrow = false;
while (!is_Boardrow) {
cout << "BoardRow: ";
cin >> Boardrow;
if (Boardrow == 1 || Boardrow == 2 || Boardrow == 3) {
is_Boardrow = true;
} else {
cout << endl << "Invalid Boardrow!" << endl;
}
}
is_Boardcolumn = false;
while (!is_Boardcolumn) {
cout << "BoardColumn: ";
cin >> Boardcolumn;
if (Boardcolumn == 1 || Boardcolumn == 2 || Boardcolumn == 3) {
is_Boardcolumn = true;
} else {
cout << endl << "Invalid Boardcolumn!" << endl;
}
}
if (Gameboard[Boardrow - 1][Boardcolumn - 1] == ' ') {
Gameboard[Boardrow - 1][Boardcolumn - 1] = Gameplayer;
is_Validmove = true;
if (Gameplayer == 'X') {
Gameplayer = 'O';
} else {
Gameplayer = 'X';
}
} else {
cout << "The selected space is occupied!" << endl;
cout << "Select a different space:" << endl << endl;
drawGameBoard(Gameboard);
}
}
cout << endl;
}
system("pause");
return 0;
}
void drawGameBoard(char Gameboard[][3]) {
cout << " 1 2 3" << endl;
cout << " -------------" << endl;
cout << " 1"
<< " | " << Gameboard[0][0] << " | " << Gameboard[0][1] << " | "
<< Gameboard[0][2] << " | " << endl;
cout << " -------------" << endl;
cout << " 2"
<< " | " << Gameboard[1][0] << " | " << Gameboard[1][1] << " | "
<< Gameboard[1][2] << " | " << endl;
cout << " -------------" << endl;
cout << " 3"
<< " | " << Gameboard[2][0] << " | " << Gameboard[2][1] << " | "
<< Gameboard[2][2] << " | " << endl;
cout << " -------------" << endl;
}
Producción :
************ TIC TAC TOE Game ************
1 2 3
-------------
1 | | | |
-------------
2 | | | |
-------------
3 | | | |
-------------
GamePlayer X's turn:
BoardRow: 1
BoardColumn: 1
1 2 3
-------------
1 | X | | |
-------------
2 | | | |
-------------
3 | | | |
-------------
GamePlayer O's turn:
BoardRow: 2
BoardColumn: 2
1 2 3
-------------
1 | X | | |
-------------
2 | | O | |
-------------
3 | | | |
-------------
GamePlayer X's turn:
BoardRow:
En el código anterior, usamos otra variable booleana, is_validMove, para guardar el estado de la posición ingresada. El booleano se establecerá en false, y el bucle while se repetirá; el booleano se establece en “true”, y lo estableceremos como “true” si el usuario ingresa a una posición que aún no está ocupada.
Hemos usado otra variable, Gamewinner, que se establece en una cadena vacía, y se usará en el siguiente paso para declarar al ganador y detener el juego.
Debajo del ciclo while, que toma la entrada del usuario, usamos una declaración if-else para verificar la posición ingresada dentro de la matriz “Tablero de juego”, y si la posición está libre, agregaremos el marcador del jugador y estableceremos el booleano is_validmove a true, y cambiaremos el jugador, y si el espacio no está libre, mostraremos que el espacio está ocupado y le pediremos al usuario que ingrese otro espacio o posición y después de eso, haremos dibujar el tablero de juego.
Podemos ver en el resultado anterior que los marcadores de jugador se colocan dentro del tablero de juego.
Paso 4: crea una función para verificar el ganador del juego
En el último paso, haremos una función para verificar el ganador del juego. Para comprobar el ganador del juego, debemos comprobar cada fila, columna y entrada diagonal de la cuadrícula o tablero de juego.
Si alguna de las filas, columnas o entradas diagonales del tablero tiene tres marcadores iguales, devolveremos ese marcador, y si ninguna de ellas tiene tres marcadores, devolveremos una cadena vacía.
Guardaremos la salida de la función de ganador del juego dentro de la variable Gamewinner, y el bucle principal se detendrá si hay un ganador del juego; de lo contrario, continuará.
Si hay un ganador, lo anunciaremos y terminaremos el juego; de lo contrario, el juego será un empate. Por ejemplo, vamos a crear la función de ganador del juego utilizando bucles for y sentencias condicionales.
Vea el código a continuación.
#include <iomanip>
#include <iostream>
using namespace std;
void drawGameBoard(char Gameboard[][3]);
char checkGameWinner3by3(char Gameboard[][3]);
int main() {
char Gameboard[3][3] = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}};
char Gameplayer = 'X';
char Gamewinner = ' ';
int Boardrow;
int Boardcolumn;
bool is_Validmove;
bool is_Boardrow;
bool is_Boardcolumn;
cout << "************ TIC TAC TOE Game ************\n";
while (Gamewinner == ' ') {
is_Validmove = false;
is_Boardrow = false;
is_Boardcolumn = false;
drawGameBoard(Gameboard);
cout << "GamePlayer ";
if (Gameplayer == 'X') {
cout << 'X';
} else {
cout << 'O';
}
cout << "'s turn:" << endl;
is_Validmove = false;
while (!is_Validmove) {
is_Boardrow = false;
while (!is_Boardrow) {
cout << "BoardRow: ";
cin >> Boardrow;
if (Boardrow == 1 || Boardrow == 2 || Boardrow == 3) {
is_Boardrow = true;
} else {
cout << endl << "Invalid Boardrow!" << endl;
}
}
is_Boardcolumn = false;
while (!is_Boardcolumn) {
cout << "BoardColumn: ";
cin >> Boardcolumn;
if (Boardcolumn == 1 || Boardcolumn == 2 || Boardcolumn == 3) {
is_Boardcolumn = true;
} else {
cout << endl << "Invalid Boardcolumn!" << endl;
}
}
if (Gameboard[Boardrow - 1][Boardcolumn - 1] == ' ') {
Gameboard[Boardrow - 1][Boardcolumn - 1] = Gameplayer;
is_Validmove = true;
if (Gameplayer == 'X') {
Gameplayer = 'O';
} else {
Gameplayer = 'X';
}
} else {
cout << "The selected space is occupied!" << endl;
cout << "Select a different space:" << endl << endl;
drawGameBoard(Gameboard);
}
}
cout << endl;
Gamewinner = checkGameWinner3by3(Gameboard);
if (Gamewinner == 'X' || Gamewinner == 'O') {
drawGameBoard(Gameboard);
cout << "Congratulations! GamePlayer ";
if (Gamewinner == 'X') {
cout << 'X';
} else {
cout << 'O';
}
cout << " is the Gamewinner!" << endl;
} else if (Gamewinner == 'T') {
drawGameBoard(Gameboard);
cout << "It's a tie!" << endl;
}
}
system("pause");
return 0;
}
void drawGameBoard(char Gameboard[][3]) {
cout << " 1 2 3" << endl;
cout << " -------------" << endl;
cout << " 1"
<< " | " << Gameboard[0][0] << " | " << Gameboard[0][1] << " | "
<< Gameboard[0][2] << " | " << endl;
cout << " -------------" << endl;
cout << " 2"
<< " | " << Gameboard[1][0] << " | " << Gameboard[1][1] << " | "
<< Gameboard[1][2] << " | " << endl;
cout << " -------------" << endl;
cout << " 3"
<< " | " << Gameboard[2][0] << " | " << Gameboard[2][1] << " | "
<< Gameboard[2][2] << " | " << endl;
cout << " -------------" << endl;
}
char checkGameWinner3by3(char Gameboard[][3]) {
for (int i = 0; i < 3; i++) {
if (Gameboard[i][0] == Gameboard[i][1] &&
Gameboard[i][0] == Gameboard[i][2]) {
return Gameboard[i][0];
}
}
for (int i = 0; i < 3; i++) {
if (Gameboard[0][i] == Gameboard[1][i] &&
Gameboard[0][i] == Gameboard[2][i]) {
return Gameboard[0][i];
}
}
if (Gameboard[0][0] == Gameboard[1][1] &&
Gameboard[1][1] == Gameboard[2][2]) {
return Gameboard[0][0];
}
if (Gameboard[0][2] == Gameboard[1][1] &&
Gameboard[1][1] == Gameboard[2][0]) {
return Gameboard[0][2];
}
return ' ';
}
Producción :
************ TIC TAC TOE Game ************
1 2 3
-------------
1 | | | |
-------------
2 | | | |
-------------
3 | | | |
-------------
GamePlayer X's turn:
BoardRow: 1
BoardColumn: 1
1 2 3
-------------
1 | X | | |
-------------
2 | | | |
-------------
3 | | | |
-------------
GamePlayer O's turn:
BoardRow: 2
BoardColumn: 1
1 2 3
-------------
1 | X | | |
-------------
2 | O | | |
-------------
3 | | | |
-------------
GamePlayer X's turn:
BoardRow: 2
BoardColumn: 2
1 2 3
-------------
1 | X | | |
-------------
2 | O | X | |
-------------
3 | | | |
-------------
GamePlayer O's turn:
BoardRow: 3
BoardColumn: 1
1 2 3
-------------
1 | X | | |
-------------
2 | O | X | |
-------------
3 | O | | |
-------------
GamePlayer X's turn:
BoardRow: 3
BoardColumn: 3
1 2 3
-------------
1 | X | | |
-------------
2 | O | X | |
-------------
3 | O | | X |
-------------
Congratulations! GamePlayer X is the Gamewinner!
En el código podemos ver la función checkGameWinner3by3(), que acepta el tablero como entrada y contiene dos bucles for y dos sentencias if. Los bucles for se usan para verificar las filas y columnas, y las declaraciones if se usan para verificar las entradas diagonales.
