Caso Práctico: Juego cuatro en raya¶

Enunciado y contexto del ejercicio¶

¡En este ejercicio práctico vamos a implementar nuestro primer videojuego en Python!

Concretamente el juego que vamos a programar es el cuatro en raya, que consiste en introducir fichas en un tablero para tratar de conseguir cuatro fichas seguidas en vertical, horizontal o diagonal. A continuación se muestra una imagen del juego.

¡Completa todos los apartados que se muestran a continuación para conseguir implementar estas funciones!

1. Define e implementa el tablero del juego¶

Lo primero que tenemos que hacer es implementar el tablero del juego, para ello, pensad en todas las estructuras que hemos visto hasta ahora y en la mejor forma de representar este tablero de manera sencilla.

Implementa una función que genere un tablero nuevo. El tablero no debe ser complejo, para representarlo, utiliza una lista con varias listas anidadas.

Una vez implementado el tablero, deberías obtener algo similar a lo siguiente:

Pista: Te recomiendo que la definición de la función sea similar a la siguiente:

def crear_tablero(filas, columnas):
    <sentencias para crear el tablero>
    return tablero
In [1]:
def crear_tablero(filas, columnas):
    """crea el tablero de juego
    paramtros posicionales
    filas -- int que representa el numero de filas
    columnas -- int que representa el numero de columnas"""
    tablero = [None]*filas
    for f in range(filas):
        tablero[f] = ['.']*columnas
    return tablero
In [2]:
tablero = crear_tablero(6,7)
In [3]:
tablero
Out[3]:
[['.', '.', '.', '.', '.', '.', '.'],
 ['.', '.', '.', '.', '.', '.', '.'],
 ['.', '.', '.', '.', '.', '.', '.'],
 ['.', '.', '.', '.', '.', '.', '.'],
 ['.', '.', '.', '.', '.', '.', '.'],
 ['.', '.', '.', '.', '.', '.', '.']]
Una vez implementada la función para crear el tablero, implementa otra función que permita imprimir el tablero por pantalla de manera que el resultado sea similar al que se muestra en la imagen anterior.

Pista: Te recomiendo que la definición de la función sea similar a la siguiente:

def mostrar_tablero(tablero):
    <sentencias para mostrar el tablero por pantalla>
In [4]:
def mostrar_tablero(tablero):
    """muestra el tablero"""
    #mostrar cabecera
    for num in range(len(tablero[0])):
        print(num, end='  ')
    #sacar por pantalla el tablero
    for fila in tablero:
        print("")
        for casilla in fila:
            print(casilla, end="  ")
In [5]:
mostrar_tablero(tablero)

0  1  2  3  4  5  6  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .

2. Introducir fichas en el tablero¶

¡Genial! Ya tienes el tablero implementado, lo siguiente que debes hacer es implementar las funciones que se requieren para que los usuarios puedan introducir fichas en el tablero.

Implementa una función que permita introducir una nueva ficha en el tablero. Para ello, ten en cuenta varias condiciones importantes, como, por ejemplo, que la columna no se encuentre fuera del rango o que la columna no se encuentre llena de fichas.

El resultado de introducir las fichas en el tablero debe ser similar al que se muestra en la siguiente imagen:

Pista: Te recomiendo que la definición de la función sea similar a la siguiente:

def introducir_ficha(tablero, columna, color):
    <sentencias para introducir una ficha en el tablero>
    return tablero
In [6]:
def introducir_ficha(tablero, columna, color):
    """esta funcion introduce una ficha en el tablero indicado"""
    if columna >= len(tablero[0]) or columna < 0:
        print("ERROR: Número de columna fuera de rango")
        return
    elif tablero[0][columna] != '.':
        print("ERROR: la columna esta llena de fichas")
        return
    else:
        for fila in range(len(tablero)-1, -1, -1):
            if tablero[fila][columna]=='.':
                tablero[fila][columna]=color
                return tablero
In [7]:
list(range(8, -1, -1))
Out[7]:
[8, 7, 6, 5, 4, 3, 2, 1, 0]
In [8]:
tablero = introducir_ficha(tablero, 5, 'A')
In [9]:
mostrar_tablero(tablero)

0  1  2  3  4  5  6  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  A  .

3. Comprobar si se realiza cuatro en raya¶

Ya tenemos nuestro tablero implementado y podemos meter fichas en él, sin embargo, nos falta uno de los comportamientos más importantes de este juego, la comprobación de si un usuario ha realizado cuatro en raya.

Implementa cuatro funciones que permitan verificar si se ha realizado cuatro en raya en horizaonal, vertical o diagonal.

Pista: Te recomiendo que la definición de la función para revisar cuatro en raya en horizontal (filas) sea similar a la siguiente:

def revisar_filas(tablero, color):
    <sentencias para verificar cuatro en raya en horizontal>
    return True o False
In [10]:
def revisar_filas(tablero, color):
    #obtener el numero de filas
    num_filas = len(tablero)
    num_columnas = len(tablero[0])
    # recorrer las filas en busca de 4 en raya
    for r in range(num_filas):
        for c in range(num_columnas - 3):
            if tablero[r][c] == color and tablero[r][c+1] == color and tablero[r][c+2] == color and tablero[r][c+3] == color:
                return True

Pista: Te recomiendo que la definición de la función para revisar cuatro en raya en vertical (columnas) sea similar a la siguiente:

def revisar_columnas(tablero, color):
    <sentencias para verificar cuatro en raya en vertical>
    return True o False
In [11]:
def revisar_columnas(tablero, color):
     #obtener el numero de filas y columnas
    num_filas = len(tablero)
    num_columnas = len(tablero[0])
    # recorrer las filas en busca de 4 en raya
    for c in range(num_columnas):
        for r in range(num_filas - 3):
            if tablero[r][c] == color and tablero[r+1][c] == color and tablero[r+2][c] == color and tablero[r+3][c] == color:
                return True

Pista: Te recomiendo que la definición de la función para revisar cuatro en raya en la diagonal derecha sea similar a la siguiente:

def revisar_diagonal_derecha(tablero, color):
    <sentencias para verificar cuatro en raya en diagonal derecha>
    return True o False
In [12]:
def revisar_diagonal_derecha(tablero, color):
     #obtener el numero de filas y columnas
    num_filas = len(tablero)
    num_columnas = len(tablero[0])
    # recorrer las filas en busca de 4 en raya
    for c in range(num_columnas -3):
        for r in range(num_filas -1,2,-1):
            if tablero[r][c] == color and tablero[r-1][c+1] == color and tablero[r-2][c+2] == color and tablero[r-3][c+3] == color:
                return True

Pista: Te recomiendo que la definición de la función para revisar cuatro en raya en la diagonal izquierda sea similar a la siguiente:

def revisar_diagonal_izquierda(tablero, color):
    <sentencias para verificar cuatro en raya en diagonal izquierda>
    return True o False
In [13]:
def revisar_diagonal_izquierda(tablero, color):
     #obtener el numero de filas y columnas
    num_filas = len(tablero)
    num_columnas = len(tablero[0])
    # recorrer las filas en busca de 4 en raya
    for c in range(num_columnas -1,2,-1):
        for r in range(num_filas -1,2,-1):
            if tablero[r][c] == color and tablero[r-1][c-1] == color and tablero[r-2][c-2] == color and tablero[r-3][c-3] == color:
                return True
Implementa una función que agrupe las cuatro funciones anteriores.

Pista: Te recomiendo que la definición de la función para revisar cuatro en raya en la diagonal izquierda sea similar a la siguiente:

def comprobar_ganador(tablero, color):
    <sentencias para verificar si se ha realizado cuatro en raya en todas las posiciones>
    return True o False
In [14]:
def comprobar_ganador(tablero, color):
    """comprueba si se ha producido 4 en raya"""
    
    return revisar_filas(tablero, color) or revisar_columnas(tablero, color) or revisar_diagonal_derecha(tablero, color) or revisar_diagonal_izquierda(tablero, color)

Realiza algunas pruebas para comprobar si tus funciones de comprobación del ganador funcionan correctamente.

In [15]:
mostrar_tablero(tablero)

0  1  2  3  4  5  6  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  A  .
In [16]:
comprobar_ganador(tablero,'A')
In [17]:
introducir_ficha(tablero, 0, 'A')
mostrar_tablero(tablero)
comprobar_ganador(tablero, 'A')

0  1  2  3  4  5  6  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
A  .  .  .  .  A  .

4. Crear el menu de juego¶

¡Enhorabuena! Ya has implementado la parte más dificil del juego, lo único que debes hacer ahora es poner todo lo anterior en común e implementar el menu de juego para que los usuarios puedan introducir fichas por turnos hasta que uno de ellos gane.

Implementa un menu de juego que solicite a los usuarios que introduzcan una ficha por turnos. Ten en cuenta que esta acción debe repetirse hasta que uno de los dos usuarios gane el juego o se acaben las casillas disponibles para introducir fichas.

Pista: Recuerda que la sentencia while True nos permitía ejecutar un conjunto de sentencias de código en Python hasta que rompiesemos la ejecución utilizando algún mecanismo como la palabra reservada break.

Pista 2: Utiliza la sentencia que se muestra a continuación para limpiar la pantall cada vez que muestres el tablero.

In [18]:
from IPython.display import clear_output
In [23]:
tablero = crear_tablero(6,7)
turno = 'R'
sig_turno = 'A'
while True:
    turno = sig_turno
    mostrar_tablero(tablero)
    if turno == 'R':
        columna = int(input("Turno del ROJO: "))
        sig_turno = 'A'
    elif turno == 'A':
        columna = int(input("Turno del AMARILLO: "))    
        sig_turno = 'R'
    introducir_ficha(tablero, columna, turno)    
    clear_output(wait=False)
    if comprobar_ganador(tablero, turno):
        print("Ganador el jugador ", turno, "\n\n")
        mostrar_tablero(tablero)
        break

Ganador el jugador  A 


0  1  2  3  4  5  6  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
A  .  .  .  .  .  .  
A  .  .  .  .  R  .  
A  .  .  .  .  R  .  
A  .  .  .  .  R  .
In [ ]:
In [ ]:
In [ ]: