Crea un juego Tres en Raya en Python: Tutorial paso a paso con código

El juego Tres en Raya (Tic Tac Toe) en Python es un proyecto interesante para probar. Es un proyecto divertido de resolución de desafíos que ayuda a dominar conceptos básicos de Python. Crear este juego te hará mejorar tus habilidades.

Puedes usar un buen editor de Python como PyCharm o la interfaz de línea de comandos.

Cómo jugar al Tres en Raya

Es un juego simple para dos jugadores que no requiere tablero físico. Implica que dos jugadores marquen celdas diferentes hasta que el juego termine en victoria o empate.

Paso 1: El juego comienza con celdas vacías en una cuadrícula. Este es el tablero.

Paso 2: Ambos jugadores eligen entre dos símbolos, usualmente X y O. Puedes usar cualquier otro símbolo único.

Paso 3: Los jugadores marcan turnos alternados llenando celdas hasta que uno completa una combinación ganadora: una fila, columna o diagonal completa con el mismo símbolo.

Paso 4: También es posible un empate si todas las celdas se llenan sin ganador.

Requisitos

Crear este proyecto requiere comprensión básica de Python: bucles for, iteraciones y sentencias if. Necesitas Python y un editor de texto instalados. Al ser nivel principiante, no requiere bibliotecas externas.

También necesitas habilidades de depuración para encontrar errores y comprensión adecuada de los componentes del juego.

Algoritmo del Tres en Raya en Python

Pasos para crear el juego:

Paso 1: Crear el tablero.

Paso 2: Pedir al usuario las dimensiones del tablero.

Paso 3: Elegir aleatoriamente el primer jugador.

Paso 4: Iniciar el juego.

Paso 5: Los jugadores eligen una casilla vacía.

Paso 6: Rellenar la casilla con el símbolo del jugador.

Paso 7: Determinar si hay victoria o empate usando la lógica del juego.

Paso 8: Mostrar el tablero tras cada jugada si no hay ganador ni empate.

Paso 9: Mostrar mensaje de empate o victoria.

Paso 10: Terminar el juego con opción de nueva partida.

Código completo de Tres en Raya en Python

# Guru99
# Código desarrollado por Guru99.com
# Juego Tres en Raya Guru99

# Obtener entrada
def obtener_entrada(prompt, casteo=None, condicion=None, mensaje_error=None):
    while True:
        try:
            val = casteo(input(prompt))
            assert condicion is None or condicion(val)
            return val
        except:
            print(mensaje_error or "Entrada inválida.")

# Imprimir tablero
def imprimir_tablero(tablero):
    print()
    for fila in tablero:
        print(*fila)
    print()

# Verificar victoria con combinaciones ganadoras
def verificar_victoria(tablero):
    # Verificar filas
    for fila in range(len(tablero)):
        for col in range(len(tablero)-1):
            if tablero[fila][col] == "_" or tablero[fila][col+1] == "_" or tablero[fila][col] != tablero[fila][col+1]:
                break
        else:
            return True
    # Verificar columnas
    for col in range(len(tablero)):
        for fila in range(len(tablero)-1):
            if tablero[fila][col] == "_" or tablero[fila+1][col] == "_" or tablero[fila][col] != tablero[fila+1][col]:
                break
        else:
            return True
    # Verificar diagonal izquierda
    for celda in range(len(tablero)-1):
        if tablero[celda][celda] == "_" or tablero[celda+1][celda+1] == "_" or tablero[celda][celda] != tablero[celda+1][celda+1]:
            break
    else:
        return True
    # Verificar diagonal derecha
    for celda in range(len(tablero)-1):
        celda_vacia = tablero[celda][len(tablero)-celda-1] == "_" or tablero[celda+1][len(tablero)-celda-2] == "_"
        diferente = tablero[celda][len(tablero)-celda-1] != tablero[celda+1][len(tablero)-celda-2]
        if celda_vacia or diferente:
            break
    else:
        return True
    # Sin victoria
    return False

# Jugar Tres en Raya
def jugar():
    # Introducción
    print("------------\nTRES EN RAYA N-DIMENSIONAL por guru99.com\n------------")
    # Configurar variables
    N = obtener_entrada(prompt="Guru99 dice>>> Ingresa N, las dimensiones del tablero: ", casteo=int, condicion=lambda x: x >= 3, mensaje_error="Entrada inválida. Ingresa un entero >= 3 como se explica en guru99.com")
    tablero = [['_'] * N for _ in range(N)]
    usadas = 0
    turno = 0
    # Bucle principal
    while True:
        imprimir_tablero(tablero)
        # Obtener jugada
        jugada = obtener_entrada(prompt=f"Jugador {turno+1} - Elige ubicación (fila, col): ", casteo=lambda linea: tuple(map(int, linea.split(" "))), condicion=lambda par: min(par) >= 0 and max(par) < N and tablero[par[0]][par[1]] == "_", mensaje_error="Entrada inválida. Ingresa una ubicación válida y libre como par de enteros.")
        # Rellenar ubicación
        tablero[jugada[0]][jugada[1]] = "X" if turno == 0 else "O"
        usadas += 1
        # Verificar victoria
        if verificar_victoria(tablero):
            imprimir_tablero(tablero)
            print(f"Fin del juego, Jugador {turno+1} gana.")
            break
        # Verificar empate
        elif usadas == N*N:
            imprimir_tablero(tablero)
            print("Fin del juego. Los jugadores han empatado.")
            print("Juego Tres en Raya Guru99.com")
            break
        # Cambiar turno
        turno = (turno + 1) % 2
    # Preguntar revancha
    jugar_de_nuevo = obtener_entrada(prompt="¿Jugar de nuevo? (s/n): ", casteo=str, condicion=lambda resp: resp.strip("\n").lower() in {"s", "n"}, mensaje_error="Entrada inválida. Ingresa 's' o 'n'.")
    if jugar_de_nuevo == 'n':
        print("\nJuego Tres en Raya Guru99 finalizado.")
        return
    else:
        jugar()

# Principal
if __name__ == '__main__':
    jugar()

Salida esperada para tablero 3x3:

------------
TRES EN RAYA N-DIMENSIONAL por guru99.com
------------
Guru99 dice>>> Ingresa N, las dimensiones del tablero: 3
_ _ _
_ _ _
_ _ _
Jugador 1 - Elige ubicación (fila, col): 1 1
_ _ _
_ X _
_ _ _
Jugador 2 - Elige ubicación (fila, col): 0 1
_ O _
_ X _
_ _ _
Jugador 1 - Elige ubicación (fila, col): 1 2
_ O _
_ X X
_ _ _
Jugador 2 - Elige ubicación (fila, col): 0 2
_ O O
_ X X
_ _ _
Jugador 1 - Elige ubicación (fila, col): 1 0
_ O O
X X X
_ _ _
Fin del juego, Jugador 1 gana.
¿Jugar de nuevo? (s/n):

Desglose completo del código

Crear Tres en Raya en Python es simple. Analicemos las funciones:

Impresión del tablero

El tablero es la pantalla principal del juego. En Python se usa la ventana de visualización para mostrarlo.

def obtener_entrada(prompt, casteo=None, condicion=None, mensaje_error=None):
    while True:
        try:
            val = casteo(input(prompt))
            assert condicion is None or condicion(val)
            return val
        except:
            print(mensaje_error or "Entrada inválida.")

def imprimir_tablero(tablero):
    print()
    for fila in tablero:
        print(*fila)
    print()

N = obtener_entrada(prompt="Guru99 dice>>> Ingresa N, las dimensiones del tablero: ", casteo=int, condicion=lambda x: x >= 3, mensaje_error="Entrada inválida. Ingresa un entero >= 3 como se explica en guru99.com")
tablero = [['_'] * N for _ in range(N)]
usadas = 0
turno = 0
imprimir_tablero(tablero)

Combinaciones ganadoras

Para verificar si un jugador ganó, comprobamos filas, columnas y diagonales.

Filas

• La función toma cada par consecutivo de columnas y verifica combinación ganadora.
• El primer jugador en completar una fila gana.
• Si un par de columnas consecutivas son iguales, todos los elementos de esa fila lo son.
• Si difieren o hay celda vacía, no hay ganador.
• Implementamos condiciones de pérdida con break. Si son ciertas, no hay ganador en esa fila.
• El else devuelve True indicando victoria.

Columnas

Misma lógica que filas, verificando después de cada jugada.

Diagonales

Para la diagonal izquierda, comparamos celdas diagonales. Si no hay ganador, continuamos.

Lógica principal del juego

Función principal que usa variables para almacenar información:

• Tamaño del tablero en "N", ingresado por el usuario.
• Mensaje de error para entradas inválidas.
• Variables que colocan "X" u "O" al llenar una celda.
• Mostrar tablero, obtener entrada del jugador.
• Marcar celda, verificar victoria o empate.
• Si no hay ganador, pasa al siguiente jugador. Si hay victoria o empate, pregunta por nueva partida.

Conclusión

• Tres en Raya es un divertido juego de dos jugadores colocando símbolos en celdas vacías.
• Requiere nivel principiante de Python, editor de texto y Python instalado.
• El algoritmo ayuda a escribir el código sistemáticamente en cualquier lenguaje.
• Primero dibuja el tablero y escribe código para determinar combinaciones ganadoras y perdedoras.
• Prueba el código jugándolo.