domingo, 22 de febrero de 2026

Prueba 1

 import random

from enum import Enum

from dataclasses import dataclass

from typing import List, Tuple, Optional

import time


class Suit(Enum):

    HEARTS = "♥"

    DIAMONDS = "♦"

    CLUBS = "♣"

    SPADES = "♠"


class Rank(Enum):

    TWO = 2

    THREE = 3

    FOUR = 4

    FIVE = 5

    SIX = 6

    SEVEN = 7

    EIGHT = 8

    NINE = 9

    TEN = 10

    JACK = 11

    QUEEN = 12

    KING = 13

    ACE = 14


@dataclass

class Card:

    suit: Suit

    rank: Rank

    

    def __str__(self):

        rank_str = {11: 'J', 12: 'Q', 13: 'K', 14: 'A'}.get(self.rank.value, str(self.rank.value))

        return f"{rank_str}{self.suit.value}"

    

    def __repr__(self):

        return self.__str__()


class HandRank(Enum):

    HIGH_CARD = 1

    ONE_PAIR = 2

    TWO_PAIR = 3

    THREE_OF_A_KIND = 4

    STRAIGHT = 5

    FLUSH = 6

    FULL_HOUSE = 7

    FOUR_OF_A_KIND = 8

    STRAIGHT_FLUSH = 9

    ROYAL_FLUSH = 10


class Deck:

    def __init__(self):

        self.cards: List[Card] = []

        self.reset()

    

    def reset(self):

        self.cards = [Card(suit, rank) for suit in Suit for rank in Rank]

        random.shuffle(self.cards)

    

    def deal(self, num: int = 1) -> List[Card]:

        dealt = self.cards[:num]

        self.cards = self.cards[num:]

        return dealt


class HandEvaluator:

    @staticmethod

    def evaluate(cards: List[Card]) -> Tuple[HandRank, List[int]]:

        """

        Evalúa una mano de 7 cartas (2 hole + 5 community) y retorna el ranking y valores para desempate

        """

        if len(cards) < 5:

            raise ValueError("Se necesitan al menos 5 cartas")

        

        # Obtener la mejor mano de 5 cartas de las 7 disponibles

        best_rank = HandRank.HIGH_CARD

        best_kickers = [0, 0, 0, 0, 0]

        

        from itertools import combinations

        for combo in combinations(cards, 5):

            rank, kickers = HandEvaluator._evaluate_five_cards(list(combo))

            if rank.value > best_rank.value or (rank.value == best_rank.value and kickers > best_kickers):

                best_rank = rank

                best_kickers = kickers

        

        return best_rank, best_kickers

    

    @staticmethod

    def _evaluate_five_cards(cards: List[Card]) -> Tuple[HandRank, List[int]]:

        ranks = sorted([c.rank.value for c in cards], reverse=True)

        suits = [c.suit for c in cards]

        

        is_flush = len(set(suits)) == 1

        is_straight = HandEvaluator._is_straight(ranks)

        

        # Royal Flush / Straight Flush

        if is_flush and is_straight:

            if ranks[0] == 14:  # Ace high

                return HandRank.ROYAL_FLUSH, [14]

            return HandRank.STRAIGHT_FLUSH, [ranks[0]]

        

        # Four of a Kind

        quads = HandEvaluator._find_groups(ranks, 4)

        if quads:

            kicker = max(r for r in ranks if r != quads[0])

            return HandRank.FOUR_OF_A_KIND, [quads[0], kicker]

        

        # Full House

        trips = HandEvaluator._find_groups(ranks, 3)

        pairs = HandEvaluator._find_groups(ranks, 2)

        if trips and pairs:

            return HandRank.FULL_HOUSE, [trips[0], pairs[0]]

        

        # Flush

        if is_flush:

            return HandRank.FLUSH, ranks

        

        # Straight

        if is_straight:

            return HandRank.STRAIGHT, [ranks[0]]

        

        # Three of a Kind

        if trips:

            kickers = sorted([r for r in ranks if r != trips[0]], reverse=True)[:2]

            return HandRank.THREE_OF_A_KIND, [trips[0]] + kickers

        

        # Two Pair

        if len(pairs) >= 2:

            top_pairs = sorted(pairs, reverse=True)[:2]

            kicker = max(r for r in ranks if r not in top_pairs)

            return HandRank.TWO_PAIR, top_pairs + [kicker]

        

        # One Pair

        if pairs:

            kickers = sorted([r for r in ranks if r != pairs[0]], reverse=True)[:3]

            return HandRank.ONE_PAIR, [pairs[0]] + kickers

        

        # High Card

        return HandRank.HIGH_CARD, ranks

    

    @staticmethod

    def _is_straight(ranks: List[int]) -> bool:

        unique_ranks = sorted(list(set(ranks)), reverse=True)

        if len(unique_ranks) < 5:

            return False

        

        # Straight normal

        for i in range(len(unique_ranks) - 4):

            if unique_ranks[i] - unique_ranks[i+4] == 4:

                return True

        

        # Straight con As bajo (A-2-3-4-5)

        if set([14, 2, 3, 4, 5]).issubset(set(ranks)):

            return True

        

        return False

    

    @staticmethod

    def _find_groups(ranks: List[int], count: int) -> List[int]:

        from collections import Counter

        rank_counts = Counter(ranks)

        return [rank for rank, c in rank_counts.items() if c == count]


class Player:

    def __init__(self, name: str, chips: int = 1000):

        self.name = name

        self.chips = chips

        self.hole_cards: List[Card] = []

        self.current_bet = 0

        self.folded = False

        self.all_in = False

    

    def reset(self):

        self.hole_cards = []

        self.current_bet = 0

        self.folded = False

        self.all_in = False

    

    def bet(self, amount: int) -> int:

        amount = min(amount, self.chips)

        self.chips -= amount

        self.current_bet += amount

        if self.chips == 0:

            self.all_in = True

        return amount

    

    def __str__(self):

        return f"{self.name} (${self.chips})"


class TexasHoldem:

    def __init__(self):

        self.deck = Deck()

        self.players: List[Player] = []

        self.community_cards: List[Card] = []

        self.pot = 0

        self.current_bet = 0

        self.dealer_index = 0

    

    def add_player(self, name: str, chips: int = 1000):

        self.players.append(Player(name, chips))

    

    def play_round(self):

        print("\n" + "="*50)

        print("NUEVA MANO DE TEXAS HOLD'EM")

        print("="*50)

        

        # Reset

        self.deck.reset()

        self.community_cards = []

        self.pot = 0

        self.current_bet = 0

        

        for player in self.players:

            player.reset()

        

        # Ciegas

        small_blind_idx = (self.dealer_index + 1) % len(self.players)

        big_blind_idx = (self.dealer_index + 2) % len(self.players)

        

        sb_amount = 10

        bb_amount = 20

        

        sb_player = self.players[small_blind_idx]

        bb_player = self.players[big_blind_idx]

        

        self.pot += sb_player.bet(sb_amount)

        self.pot += bb_player.bet(bb_amount)

        self.current_bet = bb_amount

        

        print(f"\nCiegas: {sb_player.name} paga {sb_amount}, {bb_player.name} paga {bb_amount}")

        

        # Repartir cartas

        for player in self.players:

            player.hole_cards = self.deck.deal(2)

        

        # Mostrar cartas del jugador humano

        human = self.players[0]

        print(f"\nTus cartas: {' '.join(str(c) for c in human.hole_cards)}")

        

        # Pre-flop

        print("\n--- PRE-FLOP ---")

        self._betting_round(big_blind_idx)

        

        if self._count_active_players() > 1:

            # Flop

            print("\n--- FLOP ---")

            self.community_cards.extend(self.deck.deal(3))

            self._show_community()

            self.current_bet = 0

            for p in self.players:

                p.current_bet = 0

            self._betting_round(self.dealer_index)

        

        if self._count_active_players() > 1:

            # Turn

            print("\n--- TURN ---")

            self.community_cards.extend(self.deck.deal(1))

            self._show_community()

            self.current_bet = 0

            for p in self.players:

                p.current_bet = 0

            self._betting_round(self.dealer_index)

        

        if self._count_active_players() > 1:

            # River

            print("\n--- RIVER ---")

            self.community_cards.extend(self.deck.deal(1))

            self._show_community()

            self.current_bet = 0

            for p in self.players:

                p.current_bet = 0

            self._betting_round(self.dealer_index)

        

        # Showdown

        self._showdown()

        

        # Rotar dealer

        self.dealer_index = (self.dealer_index + 1) % len(self.players)

    

    def _show_community(self):

        print(f"Cartas comunitarias: {' '.join(str(c) for c in self.community_cards)}")

    

    def _betting_round(self, start_index: int):

        active_players = [p for p in self.players if not p.folded and not p.all_in]

        if len(active_players) <= 1:

            return

        

        current_idx = (start_index + 1) % len(self.players)

        last_raiser = None

        

        while True:

            player = self.players[current_idx]

            

            if not player.folded and not player.all_in and player.chips > 0:

                if player.name == "Jugador":

                    action = self._get_player_action(player)

                else:

                    action = self._get_ai_action(player)

                

                if action == "fold":

                    player.folded = True

                    print(f"{player.name} se retira")

                elif action == "call":

                    call_amount = self.current_bet - player.current_bet

                    actual_call = player.bet(call_amount)

                    self.pot += actual_call

                    print(f"{player.name} iguala (${actual_call})")

                elif action.startswith("raise"):

                    raise_amount = int(action.split()[1])

                    total_bet = self.current_bet + raise_amount - player.current_bet

                    actual_raise = player.bet(total_bet)

                    self.pot += actual_raise

                    self.current_bet += raise_amount

                    last_raiser = current_idx

                    print(f"{player.name} sube a ${self.current_bet}")

                elif action == "check":

                    print(f"{player.name} pasa")

            

            # Verificar si la ronda de apuestas termina

            next_idx = (current_idx + 1) % len(self.players)

            

            # Condiciones de fin: todos han igualado o se retiraron

            all_matched = all(

                p.folded or p.all_in or p.current_bet == self.current_bet or p.chips == 0

                for p in self.players

            )

            

            if all_matched and (last_raiser is None or next_idx == (last_raiser + 1) % len(self.players)):

                break

            

            current_idx = next_idx

            

            # Evitar bucle infinito si solo queda un jugador activo

            if self._count_active_players() <= 1:

                break

    

    def _get_player_action(self, player: Player) -> str:

        to_call = self.current_bet - player.current_bet

        

        while True:

            print(f"\nTu turno. Fichas: ${player.chips}")

            print(f"Apuesta actual: ${self.current_bet}, Bote: ${self.pot}")

            

            if to_call > 0:

                print(f"Necesitas ${to_call} para igualar")

                action = input("¿Qué haces? (fold/call/raise [cantidad]): ").lower().strip()

            else:

                action = input("¿Qué haces? (fold/check/raise [cantidad]): ").lower().strip()

            

            if action == "fold":

                return "fold"

            elif action == "call" and to_call > 0:

                if player.chips >= to_call:

                    return "call"

                else:

                    print("No tienes suficientes fichas")

            elif action == "check" and to_call == 0:

                return "check"

            elif action.startswith("raise"):

                try:

                    parts = action.split()

                    if len(parts) == 2:

                        amount = int(parts[1])

                        if amount >= 20 and player.chips >= to_call + amount:

                            return f"raise {amount}"

                        else:

                            print("Subida inválida (mínimo 20 o fichas insuficientes)")

                    else:

                        print("Formato: raise [cantidad]")

                except ValueError:

                    print("Cantidad inválida")

            else:

                print("Acción no válida")

    

    def _get_ai_action(self, player: Player) -> str:

        to_call = self.current_bet - player.current_bet

        

        # IA simple basada en fuerza de mano pre-flop o aleatorio post-flop

        if len(self.community_cards) == 0:

            # Evaluar mano inicial simple

            ranks = [c.rank.value for c in player.hole_cards]

            suited = player.hole_cards[0].suit == player.hole_cards[1].suit

            pair = ranks[0] == ranks[1]

            

            strength = max(ranks) + (10 if pair else 0) + (5 if suited else 0)

        else:

            # Evaluar mano completa

            all_cards = player.hole_cards + self.community_cards

            hand_rank, _ = HandEvaluator.evaluate(all_cards)

            strength = hand_rank.value * 10

        

        time.sleep(1)  # Simular pensamiento

        

        if to_call == 0:

            if strength > 25:

                return "raise 40"

            return "check"

        else:

            if strength < 15 and to_call > 20:

                return "fold"

            elif strength > 30 and player.chips > to_call + 40:

                return "raise 40"

            elif player.chips >= to_call:

                return "call"

            else:

                return "fold"

    

    def _count_active_players(self) -> int:

        return sum(1 for p in self.players if not p.folded)

    

    def _showdown(self):

        print("\n" + "="*50)

        print("SHOWDOWN")

        print("="*50)

        

        active_players = [p for p in self.players if not p.folded]

        

        if len(active_players) == 1:

            winner = active_players[0]

            winner.chips += self.pot

            print(f"{winner.name} gana ${self.pot} (todos los demás se retiraron)")

            return

        

        # Evaluar manos

        best_hand = None

        best_rank = None

        best_kickers = None

        winners = []

        

        for player in active_players:

            all_cards = player.hole_cards + self.community_cards

            rank, kickers = HandEvaluator.evaluate(all_cards)

            

            print(f"\n{player.name}: {' '.join(str(c) for c in player.hole_cards)}")

            print(f"  Mejor mano: {rank.name}")

            

            if best_rank is None or rank.value > best_rank.value or (rank.value == best_rank.value and kickers > best_kickers):

                best_rank = rank

                best_kickers = kickers

                winners = [player]

            elif rank.value == best_rank.value and kickers == best_kickers:

                winners.append(player)

        

        # Repartir bote

        win_amount = self.pot // len(winners)

        remainder = self.pot % len(winners)

        

        for i, winner in enumerate(winners):

            amount = win_amount + (1 if i < remainder else 0)

            winner.chips += amount

            print(f"\n>>> {winner.name} gana ${amount} con {best_rank.name} <<<")

        

        # Mostrar estado final

        print("\nEstado de jugadores:")

        for p in self.players:

            print(f"  {p.name}: ${p.chips}")


def main():

    print("¡Bienvenido al Poker Texas Hold'em!")

    print("Comandos: fold (retirarse), call (igualar), check (pasar), raise [cantidad] (subir)")

    

    game = TexasHoldem()

    game.add_player("Jugador", 1000)

    game.add_player("CPU 1", 1000)

    game.add_player("CPU 2", 1000)

    

    while True:

        # Verificar si el jugador humano sigue en juego

        human = game.players[0]

        if human.chips <= 0:

            print("\n¡Te has quedado sin fichas! Game Over.")

            break

        

        # Verificar si hay suficientes jugadores con fichas

        active_count = sum(1 for p in game.players if p.chips > 0)

        if active_count < 2:

            print("\nNo hay suficientes jugadores para continuar.")

            break

        

        game.play_round()

        

        print("\n" + "-"*50)

        cont = input("¿Jugar otra mano? (s/n): ").lower().strip()

        if cont != 's':

            break

    

    print("\n¡Gracias por jugar!")

    print("Resultados finales:")

    for p in game.players:

        print(f"  {p.name}: ${p.chips}")


if __name__ == "__main__":

    main()


No hay comentarios:

Publicar un comentario