Reto día 11/100 con Python
Tags: python, beginners, 100daysofcode, codenewbie
Published: 2021-01-27 22:15:11

Saludos a todos los que estén leyendo este post. Antes de empezar quiero solicitarles el favor que si ven que lo que yo esté realizando se puede hacer de otra manera más efectiva me dejen su retroalimentación por favor. Además aclarar que aunque el post menciona el día 11 de los cien que dura el reto, va a resultar que termine desarrollándolo por partes y me demore unos días en finalizarlo ya que no me queda mucho tiempo para hacer estrictamente todo en un solo día. Por lo tanto voy a ir editando este post, agregando más contenido en el mismo a medida que vaya avanzando.

[Repositorio Github](https://github.com/WilsonGLan/Reto_100_dias.git)

# **Juego de Black Jack**

Bueno las condiciones o reglas del juego son las siguientes:

1. La baraja tiene un tamaño ilimitado.
2. No hay jokers.
3. La Jota / Reina / Rey cuentan como 10.
4. El As puede contar como 11 o 1.
5. Usa la siguiente lista como baraja de cartas:
   ```
cards = [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10]
```
6. Las cartas de la lista tienen la misma probabilidad de ser robadas.
7. Las cartas no se quitan de la baraja a medida que se roban.
8. La computadora es el distribuidor.

## **Consejos y pasos**

* Crear una función llamada deal_card() que use la lista a continuación y retorna una carta. El 11 es un As:
cards = [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10]

Solución:

Se entiende que de la lista se debe entregar un número de carta aleatorio, lo que quiere decir que se debe tener en cuenta una función de random por lo que lo primero es importar el módulo **random**. 

Al crear la función se debe aplicar un return para que cada vez que se utilice la función, ella entregue un número aleatorio. 

```python
import random as r

def deal_card():
    cards = [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10]
    return r.choice(cards)
```
* Pasar al usuario y al computador 2 cartas cada uno usando la función deal_card() y ```append()```. Para retener las cartas se deben usar dos listas, una por cada jugador.
```
user_cards = []
computer_cards = []
```
Solución:

Tal como se mencionó arriba primero se declaran las dos variables de tipo lista vacía. Luego debo realizar un ciclo o iteración que se ejecute dos veces, donde por cada iteración almacene en las variables uno de los números de la lista cards de forma aleatoria. Esto con el fin de que apenas comience el juego cada jugador tenga en su mano dos cartas.
```python
user_cards = []
computer_cards = []

#Con este script se almacena en cada lista dos cartas.
for i in range(2):
    user_cards.append(deal_card())
    computer_cards.append(deal_card())
```
###### **Nota**: Al final del ejercicio colocaré el código completo uniendo cada uno de los pasos que se están realizando.

* Crear una función llamada calculate_score() que toma una lista como entrada y retorna el puntaje. Esta función sirve para calcular el puntaje de cada jugador. Uso la función ```sum()``` de python para poder sumar de manera simple los elementos de la lista.

```python
score_user = 0
score_computer = 0

def calculate_score(hand):
    score = 0
    if sum(hand) > 21 and 11 in hand:
        hand.remove(11)
        hand.append(1)
        score = sum(hand)
    elif sum(hand) == 21 and len(hand) == 2:
        score = 0
    else:
        score = sum(hand)
    return score

score_user = calculate_score(user_cards)
score_computer = calculate_score(computer_cards)
```
Lo que primero debe hacer es revisar si el jugador ha sumado en sus cartas un puntaje mayor a 21 y si tiene un As entre las cartas, ya que esta carta puede ser tratada como un 11 o un 1, si el puntaje supera al 21 debe ser tratada como un 1 para poder seguir jugando. Si el puntaje es exactamente 21 y el número de cartas en su mano es de dos, quiere decir que obtuvo un BlackJack, en ese caso convertimos el puntaje en 0, así se representará el BlackJack. Por último si las anteriores condiciones no fueron cumplidas solo se sumará la mano retornando el valor total.

* Los puntajes de cada jugador se deben guardar en variables y luego mostrar en pantalla la primera mano con sus puntajes, solo que la que tiene el computador se observará solo una carta. Si ninguno de los jugadores tiene BlackJack o no ha superado el puntaje a 21 entonces se deberá preguntar al usuario si desea otra carta y seguira haciendolo hasta que el jugador decida parar. Cada vez que el jugador acepte otra carta entonces el computador entregará al azar otra carta.

```python
user_cards = []
computer_cards = []
game_over = False

while not game_over:
    cl.clean_screen()
    score_user = calculate_score(user_cards)
    score_computer = calculate_score(computer_cards)
    print(a.logo)
    print(f"    Your Cards: {user_cards}, current score {score_user} ")
    print(f"    Computer first card: {computer_cards[0]}")

    if score_user == 0 or score_computer == 0 or score_user > 21:
        game_over = True
    else:
        end_game = input("Other Card? Type 'y' or 'n' to pass\t")
        if end_game == 'y':
            user_cards.append(deal_card())
        else:
            game_over = True
``` 
* Cuando le corresponda al computador jugar, este debe obtener más cartas solo hasta que tenga un puntaje de 17 o menos.

``` python
while score_computer != 0 and score_computer <= 17:
    computer_cards.append(deal_card())
    score_computer = calculate_score(computer_cards)
```
* Después de obtener los dos puntajes, se deben comparar para saber quien es el ganador

``` python
def compare(score_user, score_computer):
    if score_user == score_computer:
        message = """
        ============================================
        =       DRAW                               =
        ============================================
        """
        return message
    elif score_computer == 0:
        message = """
        ============================================
        =       You Lose, opponent has BlackJack   =
        ============================================
        """
        return message
    elif score_user == 0:
        message = """
        ============================================
        =       You win, with a BlackJack          =
        ============================================
        """
        return message
    elif score_user > 21:
        message = """
        ============================================
        =       You went over. You lose            =
        ============================================
        """
        return message
    elif score_computer > 21:
        message = """
        ============================================
        =       Opponent went over. You win        =
        ============================================
        """
        return message
    elif score_user > score_computer:
        message = """
        ============================================
        =       You win                            =
        ============================================
        """
        return message
    else:
        message = """
        ============================================
        =       You lose                           =
        ============================================
        """
        return message
```
* El juego debe permitir al jugador elegir, después de obtener el jugador, si quiere volver a jugar o, por el contrario, terminar el juego.

```python
while input("Do you want to play a game BlackJack? Type 'y' or 'n': ") == 'y':
    play_game()
```
Como se observa, dentro del ciclo se llama a la función play_game(). Esta función contendrá a los ciclos while arriba mencionados y la ejecución de la función compare().


La unión de todo el código se puede revisar y/o descargar del repositorio [Reto 100 dias](https://github.com/WilsonGLan/Reto_100_dias.git) en la carpeta dia_11.