
Tic-Tac-Toe es un juego clásico, antiguo y divertido que ha entretenido a generaciones. En Tic-Tac-Toe, dos jugadores compiten en 9 cuadrados marcados con un patrón de almohadillas. Cada jugador se turna para colocar un símbolo (O o X) en un cuadrado vacío. En este artículo, exploraremos cómo crear un juego de tres en raya usando el lenguaje de programación C++. El siguiente ejemplo le guiará en la creación de un juego de tres en raya sencillo pero atractivo, y abarca conceptos básicos, desglose del código y consideraciones para crear una experiencia de juego interactiva.
Crea un juego de tres en raya usando C++
El siguiente ejemplo proporciona los conceptos básicos para crear este juego interactivo de tres en raya para dos jugadores. Demuestra un enfoque fácil de usar para la programación en C++ y proporciona un código fuente bien documentado, creando el desafío de revivir tu infancia con amigos en un nuevo formato digital. Echemos un vistazo al siguiente código.
Ejemplo: Tic-Tac-Toe básico basado en consola sin utilizar una matriz 2D
En este ejemplo, crearemos un juego de tres en raya en C++ usando matrices 2D, funciones y condiciones if-else. El juego permite que dos jugadores se turnen para introducir piezas de ajedrez y determinar el estado del juego determinando el resultado. Vea el código que se proporciona a continuación:
Usar espacio de nombres estándar;
blanco tablero de dibujo(personaje junta[3][3]);
bool esMoveValid(personaje junta[3][3], entero Fila, entero depresión);
bool esBoardFull(personaje junta[3][3]);
personaje Comprueba el ganador(personaje junta[3][3]);
entero principal() {
personaje junta[3][3] = {{'', '', ''}, {'', '', ''}, {'', '', ''}};
entero Fila, depresión;
personaje jugador actual = 'X';
a pesar de (real) {
tablero de dibujo(junta);
kut «jugador» jugador actual Es el turno de “. Ingrese fila (1-3) y columna (1-3):”;
acre >> Fila >> depresión;
Fila–;
depresión–;
si (Movimiento válido(junta, Fila, depresión)) {
junta[row][col] = jugador actual;
personaje ganador = Comprueba el ganador(junta);
si (ganador != '') {
tablero de dibujo(junta);
kut «jugador» ganador «¡Es el ganador!\norte«;
descansar;
}
si (tablero esta lleno(junta)) {
tablero de dibujo(junta);
kut «¡Es un empate!\norte«;
descansar;
}
jugador actual = (jugador actual == 'X') ? 'Oh' : 'X';
} Otros {
kut «Mover no válido. Seleccione otra celda.\norte«;
} }
devolver ;
}
blanco tablero de dibujo(personaje junta[3][3]) {
kut “b|\ t1\ t|\ t2\ t|\ t3\ t|\norte«;
kut «____________________\norte«;
para (entero arroz = ; arroz 3; arroz++) {
kut arroz + 1 «|»;
para (entero t = ; t 3; t++) {
kut «» junta[m][t];
si (t 2) kut » \ t|\ t«;
}
kut «\ t|\norte«;
si (arroz 2) kut «____________________\norte«;
}
kut «\norte«; }
bool esMoveValid(personaje junta[3][3], entero Fila, entero depresión) {
devolver (Fila >= && Fila 3 && depresión >= && depresión 3 && junta[row][col] == '');
}
bool esBoardFull(personaje junta[3][3]) {
para (entero arroz = ; arroz 3; arroz++) {
para (entero t = ; t 3; t++) {
si (junta[m][t] == '') {
devolver Incorrecto;
} } }
devolver real; }
personaje Comprueba el ganador(personaje junta[3][3]) {
para (entero arroz = ; arroz 3; arroz++) {
si (junta[m][] == junta[m][1] && junta[m][1] == junta[m][2] && junta[m][] != '') {
devolver junta[m][];
}
si (junta[][m] == junta[1][m] && junta[1][m] == junta[2][m] && junta[][m] != '') {
devolver junta[][m];
} }
si (junta[][] == junta[1][1] && junta[1][1] == junta[2][2] && junta[][] != '') {
devolver junta[][];
}
si (junta[][2] == junta[1][1] && junta[1][1] == junta[2][] && junta[][2] != '') {
devolver junta[][2];
}
devolver '';
}
Aquí hay un desglose de sus características:
«#incluir
Hay cuatro prototipos de funciones en el programa: drawBoard(), isMoveValid(), isBoardFull() y checkWinner(). Una declaración de función se llama prototipo de función. Aunque aparece después de la función principal en el programa, todavía se utiliza. La funcionalidad principal consiste en el bucle del juego y la lógica para gestionar los turnos y movimientos de los jugadores. En la función principal, el tablero de juego se inicializa con espacios.
personaje junta[3][3] = {{'', '', ''}, {'', '', ''}, {'', '', ''}};
Después de eso, defina dos variables de fila y columna para almacenar la entrada de movimiento del jugador. «char currentPlayer = 'X';» Define que el jugador «X» vaya primero.
Ahora, el bucle del juego while (verdadero) comienza y continúa hasta que hay un ganador o un empate. Este bucle » while » llama a «drawBoard();» para mostrar el tablero. Después de mostrar el tablero en la consola, se le pide al usuario que seleccione las celdas para marcar en la siguiente declaración de código:
kut «jugador» jugador actual Gire a «.Ingrese filas y columnas (1-3):»;
Los jugadores ingresan sus acciones en «cin >> fila >> col;»
Después de seleccionar una celda para marcar, el programa primero verificará la validez de la entrada llamando a la función isMoveValid() para asegurarse de que la celda aún no se haya completado.
junta[row][col] = jugador actual;
Esta declaración coloca el marcador del jugador en el tablero.
si (ganador != '') {
tablero de dibujo(junta);
kut «jugador» ganador «¡Ganado!\norte«;
Estas declaraciones buscan un ganador cada vez que un jugador marca una entrada en el tablero. Si hay un ganador, se anunciará el nombre del ganador y el programa saldrá del bucle del juego.
si (tablero esta lleno(junta)) {
Esta declaración comprueba si hay un empate. Se produce una condición de empate cuando el tablero está lleno y no hay un ganador. En este caso, en la pantalla aparece impreso «¡Empate!».
jugador actual = (jugador actual == 'X') ? 'Oh' : 'X';
Esta declaración cambia de jugador, dándole a cada jugador la oportunidad de tomar un turno.
kut «Mover no válido. Seleccione otra celda.\norte«;
Si el movimiento no es válido, se le pedirá al usuario que ingrese nuevamente y seleccione cualquier otra celda.
Después de la función «principal», se inicia la definición de la función del prototipo de función previamente declarado. La primera función definida aquí es drawBoard(), que dibuja el tablero de tres en raya en la consola. La función drawBoard() imprime el estado actual del tablero, incluidas las líneas de la cuadrícula.
La siguiente función definida aquí es isMoveValid(). Esta función se utiliza para determinar si se permiten movimientos dentro del tablero y en celdas vacías. La función isBoardFull() se utiliza para comprobar si el tablero está lleno. Ésta es la condición para un empate cuando no hay un ganador. isBoardFull() comprueba si todas las posiciones del tablero están ocupadas; si no hay un ganador, significa empate. Si hay un ganador, puedes usar la función checkWinner() para decidir. checkWinner() comprueba todas las filas potencialmente ganadoras para el mismo token de jugador («X» u «O») y devuelve el token del jugador ganador si lo encuentra, o el carácter de espacio » » si aún no hay un ganador. El siguiente es el resultado del programa. Muestra cada turno de cada jugador.
Primero, el tablero está despejado; se le solicita al jugador que seleccione una celda para marcar con una «X». Aquí, el jugador «X» ingresa 2 y 2. Consulte el siguiente tablero de marcadores:
Ahora es el turno del jugador O. Se le pedirá al jugador que seleccione qué celdas marcar. El jugador «O» elige 1 para la fila y 1 para la columna. La celda seleccionada está marcada como jugador «O», como se muestra en el siguiente fragmento de salida:
Todos los turnos seguirán el mismo patrón para cada jugador. Es el turno del jugador X. El jugador elige 1 como fila y 2 como columna. Vea la instantánea de salida que se proporciona a continuación:
Ahora es el turno del jugador «O». El jugador elige 1 para la fila y 3 para la columna.
La siguiente ronda la vuelve a jugar el jugador «X». El jugador elige 3 como fila y 1 como columna.
El jugador «O» elige 3 como fila y 2 como columna.
El jugador «X» selecciona la segunda fila y la tercera columna.
El jugador «O» ahora selecciona la segunda fila y la primera columna.
El jugador «X» elige esta vez la tercera fila y la tercera columna.
Ningún jugador puede dibujar líneas horizontales, verticales o diagonales, por lo que es un empate. No hay ningún ganador para la matriz de entrada seleccionada.
En general, el código consta de un bucle de juego principal que maneja el estado del juego y la entrada del usuario, así como varias funciones de utilidad para dibujar el tablero, validar movimientos, verificar el tablero completo y determinar si hay un ganador.
en conclusión
Desarrollar un juego de tres en raya en C++ es un excelente ejercicio práctico para mejorar tus habilidades de programación. Este artículo explica exactamente cómo crear un juego de tres en raya en C++. Este artículo proporciona orientación paso a paso sobre matrices bidimensionales, funciones y condiciones if-else para ayudarle a comprender la mecánica del juego, la interacción del usuario y la estructura de código eficiente. Los recorridos detallados del código y las explicaciones de las funciones críticas para el juego principal permiten a los lectores obtener información valiosa sobre las prácticas de programación de C++ y las complejidades del desarrollo de juegos simples.