¿Cómo crear un juego de tres en raya en Python?

Vamos a crear un sencillo juego del tres en raya en Python. Le ayudará a construir la lógica del juego y a entender cómo estructurar el código

El juego es uno de los entretenimientos que tiene el ser humano. Podemos encontrar diferentes tipos de juegos en la web, móvil, escritorio, etc. Ahora no estamos aquí para crear uno de esos juegos pesados. Vamos a crear un juego de tres en raya CLI utilizando Python

Si no está familiarizado con el tres en raya, juéguelo visualmente aquí para entenderlo. No se preocupe, aunque no lo entienda, vamos a verlo

Tres en raya

El tutorial se divide en tres secciones diferentes. En la primera sección, conocerá cómo se juega al tres en raya. Después, veremos un algoritmo que nos ayudará a idear la lógica del juego. Por último, veremos el código estructurado y su explicación

Puede saltarse la primera sección si ya sabe cómo jugar al tres en raya

Así que, sin más preámbulos, vamos a sumergirnos en nuestra primera sección

Jugar a tres en raya

En una partida habrá dos jugadores. Dos signos representan a cada jugador. Los signos generales utilizados en el juego son X y O. Por último, habrá un tablero con 9 casillas

Vea visualmente el tablero de tres en raya

El modo de juego será el siguiente

En primer lugar, 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 fila, en columna o en diagonal.
El juego continúa hasta que un jugador gana la partida o ésta termina en empate al rellenar todas las casillas sin que haya ninguna coincidencia ganadora.

Veamos algunos gameplays visualmente

Juego Tic Tac Toe Win — Juego de ganar al tres en raya

El jugador X gana la partida en el modo de juego anterior. Todas las casillas se llenan en diagonal con signos X . Por lo tanto, el jugador correspondiente gana la partida

Hay un total de 8 formas de disponer del mismo signo y ganar la partida. Veamos los 8 arreglos que pueden ganar la partida

Arreglos ganadores de tres en raya — Arreglos ganadores del tres en raya

Y por último, un empate llena el tablero sin ningún arreglo ganador. Espero que ahora entienda cómo se juega al tres en raya

Ahora, es hora de jugar para usted. Puede ir aquí y jugar para entender completamente la jugabilidad. Déjelo si ya lo ha entendido

Ahora, es el momento de pasar a la sección del algoritmo

Algoritmo

Ahora hablaremos del algoritmo para escribir el código. Este algoritmo le ayudará a escribir el código en cualquier language of programación de su elección. Veamos cómo se hace

Cree un tablero utilizando una matriz bidimensional e inicialice cada elemento como vacío
- Puede representar vacío utilizando cualquier símbolo que desee. Aquí vamos a utilizar un guión. '-‘.
Escriba una función para comprobar si el tablero está lleno o no
- Itere sobre el tablero y devuelva false si el tablero contiene un signo vacío o en caso contrario devuelva true.
Escriba una función para comprobar si un jugador ha ganado o no
- Tenemos que comprobar todas las posibilidades de las que hemos hablado en la sección anterior.
- Compruebe 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.
Escriba una función para iniciar el juego
- Seleccione el primer turno del jugador de forma aleatoria.
- Escriba un bucle infinito que se rompa cuando termine la partida (gane o empate)
  - Muestre el tablero al usuario para que seleccione el lugar de la siguiente jugada.
  - Pida al usuario que introduzca el número de fila y columna.
  - Actualice el punto con el signo del jugador correspondiente.
  - Compruebe si el jugador actual ha ganado la partida o no.
  - Si el jugador actual ganó la partida, imprima un mensaje de victoria y rompa el bucle infinito.
  - A continuación, compruebe si el tablero está lleno o no.
  - Si el tablero está lleno, entonces imprima el mensaje de empate y rompa el bucle infinito.
- Por último, muestre al usuario la vista final del tablero.

Puede que sea capaz de visualizar lo que está ocurriendo. No se preocupe, aunque no lo haya entendido del todo. Obtendrá más claridad una vez que vea el código

Así pues, pasemos a la sección de código. Asumo que tiene Python instalado en su PC para probar el código

Código

Repita el código siguiente

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)

 # comprobar filas
 for i in range(n):
 win = True
 for j in range(n):
 if self.board<x><x><x><x>[i]</x></x></x></x><x>[j]</x>!= jugador:
 win = Falso
 break
 if win:
 return win

 # comprobación de columnas
 for i in range(n):
 win = Verdadero
 for j in range(n):
 if self.board<x>[j]</x><x><x><x><x>[</x></x></x></x> i] != jugador:
 win = Falso
 break
 if win:
 return win

 # comprobación de diagonales
 win = Verdadero
 for i in range(n):
 if self.board<x><x><x><x>[i]</x></x></x></x><x><x><x><x>[i]</x></x></x></x>!= player:
 win = False
 break
 if win:
 return win

 win = True
 for i in range(n):
 if self.board<x><x><x><x>[i]</x></x></x></x>[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 "Jugador {player} turno")

 self.show_board()

 # tomando la entrada del usuario
 fila, col = lista(
 map(int, input("Introduzca los números de fila y columna para fijar el punto: ").split()))
 print()

 # fijando el punto
 self.fix_spot(fila - 1, col - 1, jugador)

 # comprobando si el jugador actual ha ganado o no
 if self.is_player_win(jugador):
 print(f "¡Jugador {jugador} gana la partida!")
 break

 # comprobar si la partida está empatada o no
 if self.is_board_filled():
 print("¡Empate empatado!")
 break

 # intercambiar el turno
 player = self.swap_player_turn(player)

 # mostrando la vista final del tablero
 print()
 self.show_board()


# comenzando la partida

tic_tac_toe

= TicTacToe()

tic_tac_toe

.start()

Eche un vistazo a la salida de ejemplo del código

python tic_tac_toe.py
Jugador X turno
- - -
- - -
- - -
Introduzca los números de fila y columna para fijar el punto: 1 1

Jugador O turno
X - -
- -
- - -
Introduzca los números de fila y columna para fijar el punto: 2 1

Jugador X turno
X - -
O - - -
- - -
Introducir números de fila y columna para fijar spot: 1 2

Jugador O turno
X X -
O - -
- - -
Introducir números de fila y columna para fijar spot: 1 3

Jugador X turno
X X O
O - -
- - -
Introduzca los números de fila y columna para fijar el punto: 2 2

Jugador O turno
X X O
O X -
- - -
Introduzca los números de fila y columna para fijar el punto: 3 3

Jugador X turno
X X O
O X -
- - O
Introduzca los números de fila y columna para fijar el punto: 3 2

¡El jugador X gana la partida!

X X O
O X -
- X O

Algunos puntos importantes que le ayudarán a comprender la estructura del código

Hemos utilizado una clase para tener todos los métodos en un solo lugar. Puede ser fácilmente un paquete reutilizable en algún otro código también.
A continuación, hemos definido diferentes funciones para cada responsabilidad, aunque se trate de una tarea pequeña. Esto 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 tiene límites

Palabras finales

¡Hurra! 😎 Ha creado un juego completamente desde cero. No es uno de los juegos visuales a los que jugamos a diario. Pero le ayuda a escribir la lógica y mantener una estructura limpia en el código. Siga pautas similares para crear algunos juegos interesantes como éste. Puede encontrar juegos similares si retrocede algunos años hasta su infancia

¡Feliz codificación! 👩‍💻

A continuación, explore cómo crear un juego de adivinar números y Pruebas Unitarias con el Módulo unittest de Python.

Hafeezul Kareem Shaik

Autor