¿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, incluso si usted no lo entiende, 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 ayuda 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 al tres en raya

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

Vea visualmente el tablero de tres en raya.

Tic Tac Toe Board — 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 juegos visualmente.

Tic Tac Toe Win Gameplay — 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 el mismo signo y ganar la partida. Veamos los 8 arreglos que pueden ganar la partida.

Tic Tac Toe Winning Arrangements — 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 jugarlo para entender completamente el modo de juego. Déjelo si ya lo ha entendido.

Ahora, es el momento de pasar a la sección de algoritmos.

Algoritmo

Ahora discutiremos el algoritmo para escribir el código. Este algoritmo le ayudará a escribir el código en cualquier lenguaje de 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 que hemos discutido 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 aleatoriamente.
- Escriba un bucle infinito que se rompa cuando termine la partida (gane o empate).
  - Muestre el tablero al usuario para que seleccione el lugar del siguiente movimiento.
  - 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

Repase el siguiente código.

importar aleatorio


clase TicTacToe:

    def __init__(self):
        self.board = []

    def crear_tablero(self):
        for i in range(3):
            fila = []
            para j en rango(3):
                row.append('-')
            self.board.append(fila)

    def obtener_aleatorio_primer_jugador(self):
        return random.randint(0, 1)

    def fijar_punto(self, fila, col, jugador):
        self.tablero[fila][col] = jugador

    def is_player_win(self, jugador):
        win = None

        n = len(auto.tablero)

        # comprobar filas
        para i en rango(n)
            win = True
            para j en range(n)
                if self.board<x><x><x><x>[i]</x></x></x></x><x>[j]</x>!= jugador:
                    victoria = Falso
                    break
            si gana
                return win

        # comprobación de columnas
        para i en rango(n)
            win = True
            para j en rango(n):
                if self.board<x>[j]</x><x><x><x><x>[i]</x></x></x></x>!= jugador:
                    victoria = Falso
                    break
            si gana
                return win

        # comprobar diagonales
        win = True
        para i en rango(n)
            if self.board<x><x><x><x>[i]</x></x></x></x><x><x><x><x>[i]</x></x></x></x>!= jugador:
                win = Falso
                break
        si gana
            return win

        win = True
        para i en rango(n)
            if self.board<x><x><x><x>[i]</x></x></x></x>[n - 1 - i] != jugador:
                victoria = Falso
                break
        si gana
            return win
        return False

        para fila en tablero propio
            para item en fila
                if item == '-':
                    return False
        return True

    def is_board_filled(self):
        for fila en self.tablero
            para item en fila
                if item == '-':
                    return False
        return True

    def intercambio_jugador_turno(self, jugador):
        return 'X' if jugador == 'O' else 'O'

    def mostrar_tablero(self):
        for fila en self.tablero
            for item in fila:
                print(item, end=" ")
            print()

    def inicio(self):
        self.crear_tabla()

        jugador = 'X' if self.get_random_first_player() == 1 else 'O'
        while Verdadero
            print(f "Jugador {jugador} turno")

            self.mostrar_tablero()

            # 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()

            # fijar el punto
            self.fijar_punto(fila - 1, col - 1, jugador)

            # comprobar si el jugador actual ha ganado o no
            if self.es_jugador_ganador(jugador):
                print(f "¡El jugador {player} gana la partida!")
                break

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

            # intercambiar el turno
            jugador = self.intercambio_jugador_turno(jugador)

        # mostrando la vista final del tablero
        imprimir()
        self.mostrar_tablero()


# iniciar el juego
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

Turno del jugador O
X - -
- - -
- - -
Introduzca los números de fila y columna para fijar el punto: 2 1

Turno del jugador X
X - -
O - -
- - -
Introduzca los números de fila y columna para fijar el punto: 1 2

Turno del jugador O
X X -
O - -
- - -
Introduzca los números de fila y columna para fijar el punto: 1 3

Turno del jugador X
X X O
O - -
- - -
Introduzca los números de fila y columna para fijar el punto: 2 2

Turno del jugador O
X X O
O X -
- - -
Introduzca los números de fila y columna para fijar el punto: 3 3

Turno del jugador X
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 está limitada.

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
Colaborador
- LinkedIn
Hafeez es desarrollador y disfruta compartiendo sus conocimientos sobre Python y los lenguajes de desarrollo emergentes.