Vamos a crear un juego simple de Tic Tac Toe en Python. Le ayudará a desarrollar la lógica del juego y comprender cómo estructurar el código.
El juego es uno de los entretenimientos que tenemos los humanos. Podemos encontrar diferentes tipos de juegos en la web, móvil, escritorio, etc. No estamos aquí para hacer uno de esos juegos pesados ahora. Vamos a crear un juego CLI tres en raya usando Python.
Si no está familiarizado con Tic Tac Toe, juegue visualmente aquí comprender. No te preocupes, aunque no lo entiendas, lo vamos a ver.
Tabla de contenido
tres en raya
El tutorial se divide en tres secciones diferentes. En la primera sección, aprenderá a jugar el juego de tres en raya. Después de eso, veremos un algoritmo que nos ayudará a encontrar la lógica del juego. Finalmente, veremos el código estructurado y su explicación.
Puede omitir la primera sección si ya sabe cómo jugar Tic Tac Toe.
Entonces, sin más preámbulos, profundicemos en nuestra primera sección.
jugando tres en raya
Habrá dos jugadores en un juego. Dos signos representan a cada jugador. Los signos generales utilizados en el juego son X y O. Finalmente, habrá un tablero con 9 casillas.
Vea el tablero de tres en raya visualmente.
Tablero de tres en raya
La jugabilidad será la siguiente.
- Primero, un usuario colocará su signo en una de las casillas vacías disponibles.
- A continuación, el segundo usuario colocará su signo en una de las casillas vacías disponibles.
- El objetivo de los jugadores es colocar sus respectivos signos completamente en filas o columnas, o en diagonal.
- El juego continúa hasta que un jugador gana el juego o termina en empate llenando todas las casillas sin un partido ganador.
Veamos algunos gameplays visualmente.
Juego de victoria de tres en raya
El jugador X gana el juego en el juego anterior. Todos los cuadros se rellenan en diagonal con signos X. Entonces, el jugador respectivo gana el juego.
Hay un total de 8 formas de colocar el mismo signo y ganar el juego. Veamos todos los 8 arreglos que pueden ganar el juego.
Arreglos ganadores de Tic Tac Toe
Y finalmente, un empate llena el tablero sin ningún arreglo ganador. Espero que ahora entiendas cómo hacer Tic Tac Toe.
Ahora, es hora de jugar para ti. Tu puedes ir aquí y jugarlo para entender el juego completamente. Déjalo si ya lo tienes.
Ahora, es hora de mover la sección del algoritmo.
Algoritmo
Ahora discutiremos el algoritmo para escribir el código. Este algoritmo lo ayudará a escribir código en cualquier lenguaje de programación de su elección. Veamos cómo se hace.
- Cree un tablero usando una matriz bidimensional e inicialice cada elemento como vacío.
- Puede representar vacío usando cualquier símbolo que desee. Aquí, vamos a utilizar un guión. ‘-‘.
- Escribe una función para comprobar si el tablero está lleno o no.
- Iterar sobre el tablero y devolver falso si el tablero contiene un signo vacío o devolver verdadero.
- Escribe una función para comprobar si un jugador ha ganado o no.
- Tenemos que comprobar todas las posibilidades que comentamos en el apartado anterior.
- Verifique todas las filas, columnas y dos diagonales.
- Escriba una función para mostrar el tablero, ya que mostraremos el tablero varias veces a los usuarios mientras juegan.
- Escribe una función para iniciar el juego.
- Selecciona el primer turno del jugador al azar.
- Escriba un ciclo infinito que se rompa cuando el juego termine (gane o empate).
- Muestre el tablero al usuario para seleccionar el lugar para el próximo movimiento.
- Solicite al usuario que ingrese el número de fila y columna.
- Actualiza el spot con el respectivo cartel del jugador.
- Comprueba si el jugador actual ganó el juego o no.
- Si el jugador actual ganó el juego, imprima un mensaje ganador y rompa el bucle infinito.
- A continuación, compruebe si el tablero está lleno o no.
- Si el tablero está lleno, imprima el mensaje de sorteo y rompa el ciclo infinito.
- Finalmente, muestre al usuario la vista final del tablero.
Es posible que pueda visualizar lo que está sucediendo. No te preocupes, incluso si no lo entendiste completamente. Obtendrá más claridad una vez que vea el código.
Entonces, saltemos a la sección de código. Supongo que tiene Python instalado en su PC para probar el código.
Código
Ir a través del siguiente código.
import random
class TicTacToe:
def __init__(self):
self.board = []
def create_board(self):
for i in range(3):
row = []
for j in range(3):
row.append('-')
self.board.append(row)
def get_random_first_player(self):
return random.randint(0, 1)
def fix_spot(self, row, col, player):
self.board[row][col] = player
def is_player_win(self, player):
win = None
n = len(self.board)
# checking rows
for i in range(n):
win = True
for j in range(n):
if self.board[i][j] != player:
win = False
break
if win:
return win
# checking columns
for i in range(n):
win = True
for j in range(n):
if self.board[j][i] != player:
win = False
break
if win:
return win
# checking diagonals
win = True
for i in range(n):
if self.board[i][i] != player:
win = False
break
if win:
return win
win = True
for i in range(n):
if self.board[i][n - 1 - i] != player:
win = False
break
if win:
return win
return False
for row in self.board:
for item in row:
if item == '-':
return False
return True
def is_board_filled(self):
for row in self.board:
for item in row:
if item == '-':
return False
return True
def swap_player_turn(self, player):
return 'X' if player == 'O' else 'O'
def show_board(self):
for row in self.board:
for item in row:
print(item, end=" ")
print()
def start(self):
self.create_board()
player="X" if self.get_random_first_player() == 1 else 'O'
while True:
print(f"Player {player} turn")
self.show_board()
# taking user input
row, col = list(
map(int, input("Enter row and column numbers to fix spot: ").split()))
print()
# fixing the spot
self.fix_spot(row - 1, col - 1, player)
# checking whether current player is won or not
if self.is_player_win(player):
print(f"Player {player} wins the game!")
break
# checking whether the game is draw or not
if self.is_board_filled():
print("Match Draw!")
break
# swapping the turn
player = self.swap_player_turn(player)
# showing the final view of board
print()
self.show_board()
# starting the game
tic_tac_toe = TicTacToe()
tic_tac_toe.start()
Echa un vistazo a la salida de muestra del código.
$ python tic_tac_toe.py Player X turn - - - - - - - - - Enter row and column numbers to fix spot: 1 1 Player O turn X - - - - - - - - Enter row and column numbers to fix spot: 2 1 Player X turn X - - O - - - - - Enter row and column numbers to fix spot: 1 2 Player O turn X X - O - - - - - Enter row and column numbers to fix spot: 1 3 Player X turn X X O O - - - - - Enter row and column numbers to fix spot: 2 2 Player O turn X X O O X - - - - Enter row and column numbers to fix spot: 3 3 Player X turn X X O O X - - - O Enter row and column numbers to fix spot: 3 2 Player X wins the game! X X O O X - - X O
Algunos puntos importantes que lo ayudan a comprender la estructura del código.
- Hemos usado una clase para tener todos los métodos en un solo lugar. También puede ser fácilmente un paquete reutilizable en algún otro código.
- A continuación, hemos definido diferentes funciones para cada responsabilidad, aunque sea una tarea pequeña. Ayuda a mantener el código con facilidad.
- Los dos enfoques anteriores nos ayudan a actualizar la aplicación sin esfuerzo si queremos actualizar el juego.
Siéntase libre de adaptar la estructura y mejorarla en función de su proyecto. La estructuración del código no está limitada.
Ultimas palabras
¡Viva! 😎 Has creado un juego completamente desde cero. No es uno de los juegos visuales que jugamos a diario. Pero te ayuda a escribir lógica y mantener una estructura limpia en el código. Siga pautas similares para crear algunos juegos interesantes como este. Puedes encontrar juegos similares si te remontas algunos años a tu infancia.
¡Feliz codificación! 👩💻
A continuación, explore cómo crear un juego de adivinanzas y pruebas unitarias con el módulo unittest de Python.
¿Te gustó leer el artículo? ¿Qué tal compartir con el mundo?