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

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

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.
'-
‘.
- 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 devuelvatrue
.
- Itere sobre el tablero y devuelva
- 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.