blackjack_ev.py

"""
Módulo: blackjack_ev.py
Descripción: Simulación de Monte Carlo para calcular el Valor Esperado (EV) 
y el Retorno al Jugador (RTP) en Blackjack aplicando Estrategia Básica.
"""

import numpy as np
import pandas as pd

class SimuladorBlackjack:
    def __init__(self, num_decks=6, num_simulaciones=10000):
        self.num_decks = num_decks
        self.num_simulaciones = num_simulaciones
        self.resultados = []

    def _crear_zapato(self):
        """Crea el 'zapato' combinando múltiples barajas estándar."""
        # Las cartas 10, J, Q, K valen 10. El As vale 11 inicialmente.
        carta_base = [2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10, 11]
        zapato = carta_base * 4 * self.num_decks
        np.random.shuffle(zapato)
        return zapato

    def _calcular_valor(self, mano):
        """Calcula el valor óptimo de una mano manejando el As (1 u 11)."""
        total = sum(mano)
        ases = mano.count(11)
        while total > 21 and ases > 0:
            total -= 10
            ases -= 1
        return total

    def _estrategia_basica(self, suma_jugador, carta_crupier):
        """
        Estrategia básica simplificada para decidir Hit (H) o Stand (S).
        - Si la suma es menor o igual a 11: Pide carta (H).
        - Si la suma es 17 o más: Se planta (S).
        - Si es 12-16: Se planta si el crupier muestra una carta baja (2-6), si no, pide.
        """
        if suma_jugador <= 11:
            return 'H'
        elif suma_jugador >= 17:
            return 'S'
        else:
            if carta_crupier in [2, 3, 4, 5, 6]:
                return 'S' # El crupier es propenso a pasarse
            else:
                return 'H'

    def simular_mano(self, zapato):
        """Simula una mano individual de Blackjack."""
        if len(zapato) < 15: # Renovar zapato si quedan pocas cartas
            zapato = self._crear_zapato()

        mano_jugador = [zapato.pop(), zapato.pop()]
        mano_crupier = [zapato.pop(), zapato.pop()]

        # Turno del jugador
        while True:
            val_jugador = self._calcular_valor(mano_jugador)
            if val_jugador >= 21:
                break
            accion = self._estrategia_basica(val_jugador, mano_crupier[0])
            if accion == 'H':
                mano_jugador.append(zapato.pop())
            else:
                break

        val_jugador = self._calcular_valor(mano_jugador)
        if val_jugador > 21:
            return -1, zapato # Jugador se pasa (Pierde)

        # Turno del crupier (regla fija: pide hasta 17 o más)
        while self._calcular_valor(mano_crupier) < 17:
            mano_crupier.append(zapato.pop())

        val_crupier = self._calcular_valor(mano_crupier)

        if val_crupier > 21:
            return 1, zapato # Crupier se pasa (Gana jugador)
        elif val_jugador > val_crupier:
            return 1, zapato
        elif val_jugador < val_crupier:
            return -1, zapato
        else:
            return 0, zapato # Empate (Push)

    def ejecutar_simulacion(self):
        """Ejecuta la simulación masiva de Monte Carlo."""
        print(f"Iniciando simulación de {self.num_simulaciones} manos de Blackjack...")
        zapato = self._crear_zapato()
        
        resultados = []
        for _ in range(self.num_simulaciones):
            resultado, zapato = self.simular_mano(zapato)
            resultados.append(resultado)

        # Análisis con Pandas
        df = pd.DataFrame(resultados, columns=["Resultado"])
        conteo = df["Resultado"].value_counts()
        
        victorias = conteo.get(1, 0)
        derrotas = conteo.get(-1, 0)
        empates = conteo.get(0, 0)
        
        # Cálculo de métricas
        ev = (victorias - derrotas) / self.num_simulaciones
        rtp = ((victorias + (empates * 0.5)) / self.num_simulaciones) * 100

        resumen = {
            "Total Manos": self.num_simulaciones,
            "Victorias": victorias,
            "Derrotas": derrotas,
            "Empates": empates,
            "Valor Esperado (EV)": round(ev, 4),
            "Retorno al Jugador (RTP %)": round(rtp, 2)
        }
        
        return resumen

if __name__ == "__main__":
    sim = SimuladorBlackjack(num_simulaciones=50000)
    metricas = sim.ejecutar_simulacion()
    print("\n--- RESULTADOS DE LA SIMULACIÓN DE BLACKJACK ---")
    for k, v in metricas.items():
        print(f"{k}: {v}")