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()