SISTEMAS

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

Vamos a crear un simple juego de tres en raya en Python. Te ayudará a construir la lógica del juego y comprender cómo estructurar el código.

Los juegos son uno de entretenimiento humano. Podemos encontrar distintos tipos de juegos en la web, móvil, escritorio, etc. No estamos aquí para hacer estos juegos pesados. Crearemos un juego CLI tres en raya usando Python.

Si eres nuevo en el tres en raya, juega de forma intuitiva aquí comprender. No te preocupes, lo veremos aunque no lo entiendas.

tres en raya

Este tutorial se divide en tres secciones distintas. En la primera parte, aprenderá a jugar tres en raya. Después de eso, veremos un algoritmo que puede ayudarnos a encontrar la lógica del juego. Finalmente, veremos el código estructurado y su interpretación.

Si ya sabes jugar al tres en raya, puedes saltarte la primera parte.

Entonces, sin más preámbulos, vayamos a nuestra primera parte.

jugar tres en raya

Un juego tendrá dos jugadores. Dos símbolos representan a cada jugador.El logotipo general utilizado en el juego es X y Finalmente, habrá un tablero 9 Caja.

Vea visualmente el tablero de tres en raya.

tablero de tres en raya

La jugabilidad es la siguiente.

  • Primero, un usuario coloca su logotipo en un cuadro vacío disponible.
  • A continuación, el segundo usuario coloca su logotipo en un cuadro vacío disponible.
  • El objetivo del jugador es colocar sus respectivas banderas exactamente en filas o columnas o en diagonal.
  • El juego continúa hasta que el jugador gana el juego, o llena todas las casillas sin ganar el juego y termina en empate.

Echemos un vistazo a algunos juegos visualmente.

ganar tres en raya
ganar tres en raya

jugador X Gana el juego en el juego anterior.Todas las casillas se rellenan en diagonal. X firmar. Por lo tanto, el jugador correspondiente gana el juego.

compartido 8 Formas de organizar el mismo logotipo y ganar el juego. Veamos los 8 arreglos que pueden ganar el juego.

Arreglo ganador de Tic Tac Toe
Arreglo ganador de Tic Tac Toe

Al final, el empate llena el tablero sin arreglos ganadores. Espero que ahora sepas cómo jugar tres en raya.

Ahora, tu tiempo de juego ha terminado.puedes irte ahora aquí y jugarlo para entender completamente el juego. Si ya lo tienes, déjalo.

Ahora, es hora de mover la parte 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 2D e inicialice cada elemento para que esté vacío.
    • Puede usar cualquier símbolo que desee para representar nulo. Aquí, usaremos guiones. '-'.
  • Escriba una función para verificar si el tablero está lleno.
    • Atraviesa el tablero y regresa. false si el tablero contiene una bandera vacía, de lo contrario regresa true.
  • Escribe una función para comprobar si el jugador ha ganado.
    • Tenemos que comprobar todas las posibilidades que comentamos en el apartado anterior.
    • Verifique todas las filas, columnas y ambas diagonales.
  • Escriba una función para mostrar el tablero de ajedrez, ya que mostraremos el tablero de ajedrez al usuario varias veces mientras juega.
  • Escribe una función para iniciar el juego.
    • El primer turno de un jugador se selecciona aleatoriamente.
    • Escriba un ciclo infinito que se rompa cuando termine el juego (ya sea una victoria o un empate).
      • Muestre al usuario el tablero para elegir dónde moverse a continuación.
      • Pida al usuario que ingrese los números de fila y columna.
      • Actualice la escena con el logotipo del jugador correspondiente.
      • Comprueba si el jugador actual ha ganado el juego.
      • Si el jugador actual gana el juego, imprime el mensaje de victoria y rompe el bucle infinito.
      • A continuación, verifique si el tablero está lleno.
      • Si el tablero está lleno, imprime un mensaje de dibujo y rompe el bucle infinito.
    • Finalmente, se presenta al usuario la vista final del tablero.

Probablemente puedas imaginar lo que está pasando. No te preocupes, incluso si no lo entiendes completamente. Una vez que vea el código, será más claro para usted.

Entonces, saltemos a la parte del código. Supongo que ya tiene Python instalado en su PC para probar el código.

código

Explore el código a continuación.

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

Vea 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 para ayudarlo a comprender la estructura de su código.

  • Usamos una clase para poner todos los métodos en un solo lugar. También puede ser fácilmente un paquete reutilizable en otro código.
  • A continuación, definimos una función diferente para cada responsabilidad, aunque sea una tarea pequeña. Ayuda a mantener el código fácilmente.
  • Si queremos actualizar el juego, los dos métodos anteriores pueden ayudarnos a actualizar la aplicación sin esfuerzo.

Siéntase libre de ajustar la estructura y mejorarla de acuerdo con su proyecto. La estructura del código no está restringida.

ultimas palabras

¡alegría! 😎 Creas el juego completamente desde cero. No es uno de esos juegos visuales que jugamos todos los días. Pero te ayuda a escribir tu lógica y mantener una estructura limpia en tu código. Siga pautas similares para crear algunos juegos divertidos como este. Si te remontas a tu infancia, puedes encontrar juegos similares.

¡Feliz codificación! 👩‍💻

A continuación, explore cómo usar el módulo unittest de Python para crear juegos de adivinanzas y pruebas unitarias.

Artículo Recomendado:  ¿Quieres leer libros populares pero no tienes tiempo?intenta guiñar

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *