# Caso práctico: 4 in Row

## 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.

### <mark style="color:blue;">1. Define e implementa el tablero del juego</mark>

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:

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

{% hint style="info" %}
**Pista:** Te recomiendo que la definición de la función sea similar a la siguiente:
{% endhint %}

```python
def crear_tablero(filas, columnas):
    <sentencias para crear el tablero>
    return tablero
```

```python
def crear_tablero(filas, columnas):
    tablero = [None]*filas
    for f in range(filas):
        tablero[f] = ["."]*columnas
    return tablero
    
tablero = crear_tablero(6,7)

tablero
[['.', '.', '.', '.', '.', '.', '.'],
 ['.', '.', '.', '.', '.', '.', '.'],
 ['.', '.', '.', '.', '.', '.', '.'],
 ['.', '.', '.', '.', '.', '.', '.'],
 ['.', '.', '.', '.', '.', '.', '.'],
 ['.', '.', '.', '.', '.', '.', '.']]
```

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.

{% hint style="info" %}
**Pista:** Te recomiendo que la definición de la función sea similar a la siguiente:
{% endhint %}

```python
def mostrar_tablero(tablero):
    <sentencias para mostrar el tablero por pantalla>
```

```python
def mostrar_tablero(tablero):
    # Sacamos por pantalla la cabecera
    for num in range(len(tablero[0])):
        print(num, end="  ")
    #Sacamos por pantalla el tablero
    for fila in tablero:
        print("")
        for casilla in fila:
            print(casilla, end="  ")
            
mostrar_tablero(tablero)
0  1  2  3  4  5  6  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
```

### <mark style="color:blue;">2. Introducir fichas en el tablero</mark>

¡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 siguiente:

```
0  1  2  3  4  5  6  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  O  .  .  .  .  
.  .  X  .  .  .  .  
.  .  O  X  .  .  .  
.  X  O  O  X  O  .  
```

{% hint style="info" %}
**Pista:** Te recomiendo que la definición de la función sea similar a la siguiente:
{% endhint %}

```python
def introducir_ficha(tablero, columna, color):
    <sentencias para introducir una ficha en el tablero>
    return tablero
```

```python
def introducir_ficha(tablero, columna, color):
    # Error al introducir una columna errónea
    if columna >= len(tablero[0]) or columna < 0:
        print("ERROR: Número de columna fuera del rango")
        return
    # Error si la columna está llena
    elif tablero[0][columna] != '.':
        print("ERROR: La columna está llena de fichas")
        return
    else:
        # Empieza a recorrer desde abajo del tablero
        for fila in range(len(tablero)-1, -1, -1):
            # Cambia el punto por el color o ficha
            if tablero[fila][columna] == '.':
                tablero[fila][columna] = color
                return tablero
                
introducir_ficha(tablero, 5, "O")
[['.', '.', '.', '.', '.', '.', '.'],
 ['.', '.', '.', '.', '.', '.', '.'],
 ['.', '.', 'O', '.', '.', '.', '.'],
 ['.', '.', 'X', '.', '.', '.', '.'],
 ['.', '.', 'O', 'X', '.', '.', '.'],
 ['.', 'X', 'O', 'O', 'X', 'O', '.']]
 
mostrar_tablero(tablero)
0  1  2  3  4  5  6  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  O  .  .  .  .  
.  .  X  .  .  .  .  
.  .  O  X  .  .  .  
.  X  O  O  X  O  .  
```

### <mark style="color:blue;">3. Comprobar si se realiza cuatro en raya</mark>

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 horizontal, vertical o diagonal.

#### 3.1. Revisar filas

{% hint style="info" %}
**Pista:** Te recomiendo que la definición de la función para revisar cuatro en raya en horizontal (filas) sea similar a la siguiente:
{% endhint %}

```python
def revisar_filas(tablero, color):
    <sentencias para verificar cuatro en raya en horizontal>
    return True o False
```

```python
def revisar_filas(tablero, color):
    # Obtenemos el número de filas y columnas
    num_filas = len(tablero)
    num_columnas = len(tablero[0])
    # Recorremos 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
```

#### 3.2. Revisar columnas

{% hint style="info" %}
**Pista:** Te recomiendo que la definición de la función para revisar cuatro en raya en vertical (columnas) sea similar a la siguiente:
{% endhint %}

```python
def revisar_columnas(tablero, color):
    <sentencias para verificar cuatro en raya en vertical>
    return True o False
```

```python
def revisar_columnas(tablero, color):
    # Obtenemos el número de filas y columnas
    num_filas = len(tablero)
    num_columnas = len(tablero[0])
    # Recorremos las columnas 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
```

#### 3.3. Revisar diagonal derecha

{% hint style="info" %}
**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:
{% endhint %}

```python
def revisar_diagonal_derecha(tablero, color):
    <sentencias para verificar cuatro en raya en diagonal derecha>
    return True o False
```

```python
def revisar_diagonal_derecha(tablero, color):
    # Obtenemos el número de filas y columnas
    num_filas = len(tablero)
    num_columnas = len(tablero[0])
    # Recorremos las columnas 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
```

#### 3.4. Revisar diagonal izquierda

{% hint style="info" %}
**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:
{% endhint %}

```python
def revisar_diagonal_izquierda(tablero, color):
    <sentencias para verificar cuatro en raya en diagonal izquierda>
    return True o False
```

```python
def revisar_diagonal_izquierda(tablero, color):
    # Obtenemos el número de filas y columnas
    num_filas = len(tablero)
    num_columnas = len(tablero[0])
    # Recorremos las columnas 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
```

#### 3.5. Implementa una función que agrupe las cuatro funciones anteriores.

{% hint style="info" %}
**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:
{% endhint %}

```python
def comprobar_ganador(tablero, color):
    <sentencias para verificar si se ha realizado cuatro en raya en todas las posiciones>
    return True o False
```

```python
def comprobar_ganador(tablero, color):
    """Comprueba si se ha producido un 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.

```python
mostrar_tablero(tablero)
0  1  2  3  4  5  6  
.  .  .  X  .  .  .  
.  .  .  X  .  .  .  
.  .  .  X  .  .  .  
.  .  .  X  .  .  .  
.  .  .  X  .  .  .  
.  .  .  X  .  .  .  

comprobar_ganador(tablero, "X")
True
```

### <mark style="color:blue;">4. Crear el menu de juego</mark>

¡Enhorabuena! Ya has implementado la parte más difícil 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.

{% hint style="info" %}
**Pista:** Recuerda que la sentencia `while True` nos permitía ejecutar un conjunto de sentencias de código en Python hasta que rompiésemos la ejecución utilizando algún mecanismo como la palabra reservada `break`.
{% endhint %}

{% hint style="info" %}
**Pista 2**: Utiliza la sentencia que se muestra a continuación para limpiar la pantalla cada vez que muestres el tablero.
{% endhint %}

```python
from IPython.display import clear_output
clear_output(wait=False)
```

```python
from IPython.display import clear_output

tablero = crear_tablero(6,7)
turno = 'X'
sig_turno = 'O'

while True:
    turno = sig_turno
    mostrar_tablero(tablero)
    if turno == 'X':
        columna = int(input('Turno del jugador X: '))
        sig_turno = 'O'
    elif turno == 'O':
        columna = int(input('Turno del jugador O: '))
        sig_turno = 'X'
    introducir_ficha(tablero, columna, turno)
    clear_output(wait=False)
    if comprobar_ganador(tablero, turno):
        print('Ha ganado el jugador ', turno, "\n\n")
        mostrar_tablero(tablero)
        break
        
0  1  2  3  4  5  6  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
.  .  .  .  .  .  .  
Turno del jugador O: 
```

## Juego completo

{% embed url="https://github.com/afsh4ck/4inrow/blob/main/4inrow.py" %}
