class DeckTests(unittest.TestCase): def setUp(self): self.deck = Deck() def test_init(self): self.assertTrue(isinstance(self.deck.cards, list)) self.assertEqual(len(self.deck.cards), 52) def test_repr(self): self.assertEqual(repr(self.deck), 'Deck of 52 cards') def test_count(self): self.assertEqual(self.deck.count(), 52) self.deck.cards.pop() self.assertEqual(self.deck.count(), 51) def test_deal_sufficient_cards(self): cards = self.deck._deal(10) self.assertEqual(len(cards), 10) self.assertEqual(self.deck.count(), 42) def test_deal_insufficient_cards(self): cards = self.deck._deal(100) self.assertEqual(len(cards), 52) self.assertEqual(self.deck.count(), 0) def test_deal_no_cards(self): self.deck._deal(self.deck.count()) with self.assertRaises(ValueError): self.deck._deal(1) def test_deal_card(self): card = self.deck.cards[-1] dealt_card = self.deck.deal_card() self.assertEqual(card, dealt_card) self.assertEqual(self.deck.count(), 51) def test_deal_hand(self): cards = self.deck.deal_hand(20) self.assertEqual(len(cards), 20) self.assertEqual(self.deck.count(), 32) def test_shuffle_full_deck(self): cards = self.deck.cards[:] self.deck.shuffle() self.assertNotEqual(cards, self.deck.cards) self.assertEqual(self.deck.count(), 52) def test_shuffle_not_full_deck(self): self.deck.deal(1) with self.assertRaises(ValueError): self.deck.shuffle()
class Env: def __init__(self, conf): self.players = conf['players'] self.players.append("local") self.floor = conf['floor'] self.nb_card = conf['nb_card'] self.nb_round = conf['nb_round'] random.shuffle(self.players) def reset(self): self.board = Board(self.floor) self.deck = Deck() self.deck.deal(len(self.players), self.nb_card)
class Blackjack(object): def __init__(self): self._deck = Deck() self._deck.shuffle() # Pass the player and dealer two cards each self._player = Player([self._deck.deal(), self._deck.deal()]) self._dealer = Dealer([self._deck.deal(), self._deck.deal()]) def play(self): print("Player:\n", self._player) print("Dealer:\n", self._dealer) # Player hits until user says NO while True: choice = input("Do you want a hit? [y/n]: ") if choice in ("Y", "y"): self._player.hit(self._deck.deal()) points = self._player.getPoints() print("Player:\n", self._player) if points >= 21: break else: break playerPoints = self._player.getPoints() if playerPoints > 21: print("You bust and lose") else: # Dealer's turn to hit self._dealer.hit(self._deck) print("Dealer:\n", self._dealer) dealerPoints = self._dealer.getPoints() # Determine the outcome if dealerPoints > 21: print(" Dealer busts and you win") elif dealerPoints > playerPoints: print("Dealer wins") elif dealerPoints < playerPoints and playerPoints <= 21: print("You win") elif dealerPoints == playerPoints: if self._player.hasBlackjack() and \ not self._dealer.hasBlackjack(): print("You win") elif not self._player.hasBlackjack() and \ self._dealer.hasBlackjack(): print("Dealer wins") else: print("There is a tie")
def play(self): poker_players = [] num_players = input("How many players? ") for i in range(int(num_players)): player_name = input("Name of poker player {}? ".format(i + 1)) poker_player = PokerPlayer(player_name) poker_players.append(poker_player) print("Dealing cards") deck = Deck() deck.shuffle() for i in range(7): for poker_player in poker_players: poker_player.add_card(deck.deal()) print(poker_player) if (i < 6): dealmore = input("Deal more card(y or n)? ") if (dealmore.lower() == 'n'): return for poker_player in poker_players: poker_player.review_all_fiver_hands() poker_score = poker_player.get_top_poker_score() print(poker_player.name.center(30, '-')) print(poker_score)
def __init__(self, players, verbose=False): """ players is a list of four players """ self.verbose = verbose if len(players) != 4: raise ValueError('There must be four players.') self.players = players # Invariant: the union of these lists makes up exactly one deck of cards deck = Deck() self._player_hands = tuple(deck.deal()) self._cards_taken = ([], [], [], [])
class CardDemo(Frame): def __init__(self): """Sets up the window and widgets.""" Frame.__init__(self) self.master.title("Card Demo") self.grid() self._deck = Deck() self._backImage = PhotoImage(file=Card.BACK_NAME) self._cardImage = None self._imageLabel = Label(self, image=self._backImage) self._imageLabel.grid(row=0, column=0, rowspan=3) self._textLabel = Label(self, text="") self._textLabel.grid(row=3, column=0) # DealButton self._dealButton = Button(self, text="Deal", command=self._deal) self._dealButton.grid(row=0, column=1) # ShuffleButton self._shuffleButton = Button(self, text="Shuffle", command=self._shuffle) self._shuffleButton.grid(row=1, column=1) # newButton self._newButton = Button(self, text="New Deck", command=self._new) self._newButton.grid(row=2, column=1) def _deal(self): """If the deck is not empty, deals and display the next card. Otherwise, returns the program to its initial state.""" card = self._deck.deal() if card != None: self._cardImage = PhotoImage(file=card.fileName) self._imageLabel["image"] = self._cardImage self._textLabel["text"] = str(card) else: self._new() def _shuffle(self): self._deck.shuffle() def _new(self): """Returns the program to its initial state.""" self._deck = Deck() self._cardImage = None self._imageLabel["image"] = self._backImage self._textLabel["text"] = ""
def reset(self): self.trick_nr = 0 self.current_player_idx = 0 self.trick = [] self.trick_cards = [] for _ in range(13): self.trick_cards.append([None, None, None, None]) self.player_scores = [0, 0, 0, 0] self.player_action_pos = [[0] * 13, [0] * 13, [0] * 13, [0] * 13] self.expose_info = [1, 1, 1, 1] self.take_pig_card = False self.is_heart_broken = False self.is_shootmoon = False for i in range(4): self.players[i].set_position(i) self.players[i].reset() deck = Deck() self._player_hands = list(deck.deal()) self._cards_taken = ([], [], [], []) self._b_cards_taken = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]] self._temp_score = [0, 0, 0, 0] self.lacking_cards = [] for _ in range(4): self.lacking_cards.append({ Suit.spades: False, Suit.hearts: False, Suit.diamonds: False, Suit.clubs: False })
class DeckTestCase(unittest.TestCase): def setUp(self): self.full_deck = Deck() self.empty_deck = Deck() while len(self.empty_deck.get_cards()) > 0: self.empty_deck.remove_random_card() @staticmethod def generate_full_deck(): cards = [] for val in range(2, 15): for suit in ["Hearts", "Diamonds", "Spades", "Clubs"]: cards.append((val, suit)) return cards @staticmethod def sort_by_suit(cards): cards.sort(key=lambda card: (card[1], card[0])) @staticmethod def equal_cards(cards1, cards2, after_sort=True): if len(cards1) != len(cards2): return False if after_sort: DeckTestCase.sort_by_suit(cards1) DeckTestCase.sort_by_suit(cards2) for i, card in enumerate(cards1): if card[0] != cards2[i][0] or card[1] != cards2[i][1]: return False return True def test_initializer(self): deck = Deck() self.assertEqual(52, len(deck.get_cards())) def test_print_cards(self): cards = DeckTestCase.generate_full_deck() _, output = StdoutCapture( lambda: self.full_deck.print_cards()).capture() self.assertTrue(str(52) in output) self.assertTrue(str(cards) in output) def test_get_cards(self): all_cards = DeckTestCase.generate_full_deck() cards = self.full_deck.get_cards() self.assertTrue(DeckTestCase.equal_cards(all_cards, cards)) def test_shuffle(self): old_cards = self.full_deck.get_cards().copy() self.full_deck.shuffle() new_cards = self.full_deck.get_cards() self.assertFalse( DeckTestCase.equal_cards(old_cards, new_cards, after_sort=False)) def test_remove_random_card_exists(self): cards = self.full_deck.get_cards().copy() card = self.full_deck.remove_random_card() self.assertTrue(card in cards) self.assertFalse(card in self.full_deck.get_cards()) def test_remove_random_card_nonexistent(self): card, output = StdoutCapture( lambda: self.empty_deck.remove_random_card()).capture() self.assertEqual(card, None) self.assertEqual("Deck is empty", output.strip()) def test_remove_top_card_exists(self): cards = self.full_deck.get_cards().copy() card = self.full_deck.remove_top_card() self.assertEqual(card, cards[0]) self.assertFalse(card in self.full_deck.get_cards()) def test_remove_top_card_nonexistent(self): card, output = StdoutCapture( lambda: self.empty_deck.remove_top_card()).capture() self.assertEqual(card, None) self.assertEqual("Deck is empty", output.strip()) def test_remove_card_exists(self): target_card = (2, "Spades") self.assertTrue(target_card in self.full_deck.get_cards()) self.full_deck.remove_card(target_card) self.assertFalse(target_card in self.full_deck.get_cards()) def test_remove_card_nonexistent(self): card, output = StdoutCapture(lambda: self.empty_deck.remove_card( (2, "Spades"))).capture() self.assertEqual(card, None) self.assertEqual("Deck is empty", output.strip()) def test_deal(self): player1 = Player("p1") player2 = Player("p2") self.assertEqual(52, len(self.full_deck.get_cards())) self.assertEqual(0, len(player1.get_cards())) self.assertEqual(0, len(player2.get_cards())) self.full_deck.deal([player1, player2], 2) self.assertEqual(48, len(self.full_deck.get_cards())) self.assertEqual(2, len(player1.get_cards())) self.assertEqual(2, len(player2.get_cards())) def test_collect(self): player1 = Player("p1") player2 = Player("p2") player1_cards = [(2, "Spades"), (2, "Hearts")] player2_cards = [(4, "Hearts")] for card in player1_cards: player1.add_card(card) for card in player2_cards: player2.add_card(card) self.assertEqual(0, len(self.empty_deck.get_cards())) self.assertEqual(2, len(player1.get_cards())) self.assertEqual(1, len(player2.get_cards())) self.empty_deck.collect([player1, player2]) self.assertEqual(3, len(self.empty_deck.get_cards())) for card in player1_cards: self.assertTrue(card in self.empty_deck.get_cards()) for card in player2_cards: self.assertTrue(card in self.empty_deck.get_cards()) def test_have_all_cards(self): full_deck = Deck() self.assertTrue(full_deck.have_all_cards()) full_deck.remove_random_card() self.assertFalse(full_deck.have_all_cards()) def test_push_to_table(self): table = Table() self.assertEqual(0, len(table.get_cards())) self.assertEqual(52, len(self.full_deck.get_cards())) self.full_deck.push_to_table(table, 3) self.assertEqual(3, len(table.get_cards())) self.assertEqual(49, len(self.full_deck.get_cards())) def test_print(self): _, output = StdoutCapture(lambda: print(self.empty_deck)).capture() self.assertEqual("Deck of cards", output.strip())
def new_game(self): deck = Deck() self.player_hands = list(deck.deal()) for i, player in enumerate(self.players): player.setIndex(i)
exit() # initialize chips amount player = chips() print("You have 100 chips") while player.amount > 0: new_deck = Deck() new_deck.shuffle() # First turn, place your bets bet = player_bet(player.amount) # initialize NPC and player Hand computer_hand = Hand() computer_hand.add_card(new_deck.deal()) computer_hand.add_card(new_deck.deal()) player_hand = Hand() player_hand.add_card(new_deck.deal()) player_hand.add_card(new_deck.deal()) print_hidden_card(player_hand, computer_hand) # player turn while player_hand.points <= 21: chose = input('Hit or stand?\n') if chose.lower() == 'hit': player_hand.add_card(new_deck.deal()) player_hand.adjust_for_ace()
class PokerGame: # Constructor # create instance of a poker game. # 2 Players, one human, one AI, 5000 chips each def __init__(self, num_players=2): self.deck = Deck() self.hands = [] self.community_cards = [] self.num_players = num_players self.pot = 0 self.bet_amt = 0 # shuffle function, just shuffles deck def shuffle(self): self.deck.shuffle() # reset the game state for a new hand def reset(self): self.shuffle() self.community_cards = [] self.hands = [] self.pot = 0 # deal in 2 card to all players # returns a list of hands def dealIn(self): for i in range(self.num_players): hand = [] hand.extend(self.deck.deal(2)) self.hands.append(hand) # debug, print hands # print(self.getStateStr()) # flop # deals 3 card to community card def flop(self): print("Flop!") self.community_cards = self.deck.deal(3) # debug, print table print(self.getStateStr()) # turn # deals 1 card to community card def turn(self): print("Turn!") self.community_cards.extend(self.deck.deal(1)) # debug, print table print(self.getStateStr()) # river # deals 1 card to community card def river(self): print("River!") self.community_cards.extend(self.deck.deal(1)) # debug, print table print(self.getStateStr()) # assign hand types a label def handLabel(self, hand_type): if hand_type == 0: return "High Card" elif hand_type == 1: return "Pair" elif hand_type == 2: return "Two Pair" elif hand_type == 3: return "Three of a Kind" elif hand_type == 4: return "Straight" elif hand_type == 5: return "Flush" elif hand_type == 6: return "Full House" elif hand_type == 7: return "Four of a Kind" elif hand_type == 8: return "Straight Flush" else: return "Royal Flush" # get str representation of hand # param: hand is a list with any number of card # return a str displaying each card in hand def cards2Str(self, hand): text = "" for c in hand: text += str(c) + " " return text # check if hand has a pair # return -1 if no, value of highest pair if yes def hasPair(self, hand): self.sortHand(hand) print(self.cards2Str(hand)) result = -1 for c in hand: for c2 in hand: if c.value == c2.value and c.suit != c2.suit: result = c.value return result # check if hand has 3 of a kind # return -1 if no, value of 3 if yes def has3ofKind(self, hand): self.sortHand(hand) print(self.cards2Str(hand)) result = -1 for c in hand: num = 0 for c2 in hand: if c2.value == c.value: num += 1 if num >= 3: result = c2.value return result # sort 7 card hand by card.value def sortHand(self, hand): hand.sort(key=lambda x: x.value) # getStateStr() # function prints all values related to current game state # returns str representation of state def getStateStr(self): text = "=== Current Hand State ===\n" text += "Community Cards: " + self.cards2Str( self.community_cards) + "\n" for h in self.hands: text += self.cards2Str(h) + "\n" text += "Pot: " + str(self.pot) + "\n" text += "=========================" return text # score() # scores the best 5 card hand given 7 card # param: hand to score # returns an int between 0 and 9 representing score def score(self, hand): score = 0 kicker = [] # Look for all hand types in hand # start with weakest and move up # check for pairs first pairs = {} prev = 0 # remember how many pairs you have, which pairs for card in hand: if prev == card.value: key = card.value if key in pairs: pairs[key] += 1 else: pairs[key] = 2 prev = card.value # remember number of pairs. nop = {} for k, v in pairs.items(): if v in nop: nop[v] += 1 else: nop[v] = 1 # find best possible combination if 4 in nop: score = 7 kicker = list(pairs) kicker = [key for key in kicker if pairs[key] == 4] key = kicker[0] #Gets a list of all the card remaining once the the 4 of a kind is removed temp = [card.value for card in hand if card.value != key] #Get the final card in the list which is the highest card left, used in #case of a tie card_value = temp.pop() kicker.append(card_value) return [score, kicker] elif 3 in nop: #Has At least 3 of A Kind if nop[3] == 2 or 2 in nop: #Has two 3 of a kind, or a pair and 3 of a kind (fullhouse) score = 6 #gets a list of all the pairs and reverses it kicker = list(pairs) kicker.reverse() temp = kicker #ensures the first kicker is the value of the highest 3 of a king kicker = [key for key in kicker if pairs[key] == 3] if ( len(kicker) > 1 ): # if there are two 3 of a kinds, take the higher as the first kicker kicker.pop() #removes the lower one from the kicker #removes the value of the kicker already in the list temp.remove(kicker[0]) #Gets the highest pair or 3 of kind and adds that to the kickers list card_value = temp[0] kicker.append(card_value) else: #Has Only 3 of A Kind score = 3 kicker = list(pairs) #Gets the value of the 3 of a king key = kicker[0] #Gets a list of all the card remaining once the three of a kind is removed temp = [card.value for card in hand if card.value != key] #Get the 2 last card in the list which are the 2 highest to be used in the #event of a tie card_value = temp.pop() kicker.append(card_value) card_value = temp.pop() kicker.append(card_value) elif 2 in nop: #Has at Least a Pair if nop[2] >= 2: #Has at least 2 or 3 pairs score = 2 kicker = list(pairs) #Gets the card value of all the pairs kicker.reverse() #reverses the key so highest pairs are used if (len(kicker) == 3 ): #if the user has 3 pairs takes only the highest 2 kicker.pop() key1 = kicker[0] key2 = kicker[1] #Gets a list of all the card remaining once the the 2 pairs are removed temp = [ card.value for card in hand if card.value != key1 and card.value != key2 ] #Gets the last card in the list which is the highest remaining card to be used in #the event of a tie if len(temp) != 0: card_value = temp.pop() else: card_value = 0 kicker.append(card_value) else: #Has only a pair score = 1 kicker = list(pairs) #Gets the value of the pair key = kicker[0] #Gets a list of all the card remaining once pair are removed temp = [card.value for card in hand if card.value != key] #Gets the last 3 card in the list which are the highest remaining card #which will be used in the event of a tie card_value = temp.pop() kicker.append(card_value) card_value = temp.pop() kicker.append(card_value) card_value = temp.pop() kicker.append(card_value) # Straight??? #Doesn't check for the ace low straight counter = 0 high = 0 straight = False #Checks to see if the hand contains an ace, and if so starts checking for the straight #using an ace low if (hand[6].value == 14): prev = 1 else: prev = None #Loops through the hand checking for the straight by comparing the current card to the #the previous one and tabulates the number of card found in a row #***It ignores pairs by skipping over card that are similar to the previous one for card in hand: if prev and card.value == (prev + 1): counter += 1 if counter == 4: #A straight has been recognized straight = True high = card.value elif prev and prev == card.value: #ignores pairs when checking for the straight pass else: counter = 0 prev = card.value #If a straight has been realized and the hand has a lower score than a straight if (straight or counter >= 4) and score < 4: straight = True score = 4 kicker = [ high ] #Records the highest card value in the straight in the event of a tie # Flush??? flush = False total = {} #Loops through the hand calculating the number of card of each symbol. #The symbol value is the key and for every occurrence the counter is incremented for card in hand: key = card.suit if key in total: total[key] += 1 else: total[key] = 1 #key represents the suit of a flush if it is within the hand key = -1 for k, v in total.items(): if v >= 5: key = int(k) #If a flush has been realized and the hand has a lower score than a flush if key != -1 and score < 5: flush = True score = 5 kicker = [card.value for card in hand if card.suit == key] #Straight/Royal Flush??? if flush and straight: #Doesn't check for the ace low straight counter = 0 high = 0 straight_flush = False #Checks to see if the hand contains an ace, and if so starts checking for the straight #using an ace low if (kicker[len(kicker) - 1] == 14): prev = 1 else: prev = None #Loops through the hand checking for the straight by comparing the current card to the #the previous one and tabulates the number of card found in a row #***It ignores pairs by skipping over card that are similar to the previous one for card in kicker: if prev and card == (prev + 1): counter += 1 if counter >= 4: #A straight has been recognized straight_flush = True high = card elif prev and prev == card: #ignores pairs when checking for the straight pass else: counter = 0 prev = card #If a straight has been realized and the hand has a lower score than a straight if straight_flush: if high == 14: score = 9 else: score = 8 kicker = [high] return [score, kicker] if flush: #if there is only a flush then determines the kickers kicker.reverse() #This ensures only the top 5 kickers are selected and not more. length = len(kicker) - 5 for i in range(0, length): kicker.pop( ) #Pops the last card of the list which is the lowest # High Card if score == 0: #If the score is 0 then high card is the best possible hand #It will keep track of only the card's value kicker = [int(card.value) for card in hand] #Reverses the list for easy comparison in the event of a tie kicker.reverse() #Since the hand is sorted it will pop the two lowest card position 0, 1 of the list kicker.pop() kicker.pop() #The reason we reverse then pop is because lists are inefficient at popping from #the beginning of the list, but fast at popping from the end therefore we reverse #the list and then pop the last two elements which will be the two lowest card #in the hand #Return the score, and the kicker to be used in the event of a tie return [score, kicker] # getWinner() # this function calculates the winner of the # hand given the current game state. # returns the index of the winning player # def getWinner(self): def scoreHand(self, community_cards, hands): for hand in hands: hand.extend(community_cards) # sort hands # hand.sort(key=lambda x: x.value) self.sortHand(hand) results = [] for hand in hands: overall = self.score(hand) results.append([overall[0], overall[1]]) # store results return results #determine winner of round def findWinner(self, results): # show hands TODO: update printing hands with best hand label print("Finding Winner...") for i in range(len(results)): text = "" text += self.cards2Str(self.hands[i]) + " " + self.handLabel( results[i][0]) print(text) # highest score if found high = 0 for r in results: if r[0] > high: high = r[0] # print(r) kicker = {} counter = 0 # kickers only compared if hands are tied (haha, hands are tied) for r in results: if r[0] == high: kicker[counter] = r[1] counter += 1 # if kickers of multiple players are here, there is a tie if (len(kicker) > 1): print("Tie. Kickers:") for k, v in kicker.items(): print(str(k) + " : " + str(v)) num_kickers = len(kicker[list(kicker).pop()]) for i in range(0, num_kickers): high = 0 for k, v in kicker.items(): if v[i] > high: high = v[i] # only hands with highest kicker matching compared kicker = {k: v for k, v in kicker.items() if v[i] == high} print("---Round " + str(i) + " ---") for k in kicker: print(k) # if only one kicker remains they win if (len(kicker) <= 1): return list(kicker).pop() else: # one winner found, no kickers needed return list(kicker).pop() # tie, return list of winners return list(kicker)
answer = input(question) return answer if __name__ == '__main__': while True: # Print an opening statement print('Welcome to play Black Jack! Get as close to 21 as you can without going over!\n\ Dealer hits until she reaches 17. Aces count as 1 or 11.') # Create & shuffle the deck, deal two cards to each player deck = Deck() deck.shuffle() player = Hand() player.add_card(deck.deal()) player.add_card(deck.deal()) dealer = Hand() dealer.add_card(deck.deal()) dealer.add_card(deck.deal()) # Set up the Player's chips player_chips = player_chips if 'player_chips' in globals() else Chips() # Prompt the Player for their bet take_bet(player_chips) # will modify player_chips.bet # Show cards (but keep one dealer card hidden) show_some(player, dealer) while playing: # recall this variable from our hit_or_stand function
class Round: LOGGER = logging.getLogger(name="Round") def __init__(self, seats, small_blind, min_denomination): self.LOGGER.debug("NEW ROUND") self.seats = seats self.small_blind = small_blind self.min_denomination = min_denomination self.cards = [] def play(self): self.shuffle_and_deal() self.put_in_blinds() starting_bet = self.small_blind * 2 remaining_seats = self.seats first_betting_round = PreFlop(self.seats, remaining_seats, self.cards, starting_bet) remaining_seats = first_betting_round.play() if len(remaining_seats) == 1: self.distribute_winnings(remaining_seats) return self.get_seat_statuses() self.deal_flop() self.LOGGER.debug("Flop {}".format(" ".join( str(card) for card in self.cards))) if self.players_can_bet(remaining_seats): second_betting_round = BettingRound(self.seats, remaining_seats, self.cards) remaining_seats = second_betting_round.play() if len(remaining_seats) == 1: self.distribute_winnings(remaining_seats) return self.get_seat_statuses() self.deal_turn() self.LOGGER.debug("Turn {}".format(" ".join( str(card) for card in self.cards))) if self.players_can_bet(remaining_seats): third_betting_round = BettingRound(self.seats, remaining_seats, self.cards) remaining_seats = third_betting_round.play() if len(remaining_seats) == 1: self.distribute_winnings(remaining_seats) return self.get_seat_statuses() self.deal_river() self.LOGGER.debug("River {}".format(" ".join( str(card) for card in self.cards))) if self.players_can_bet(remaining_seats): final_betting_round = BettingRound(self.seats, remaining_seats, self.cards) remaining_seats = final_betting_round.play() if len(remaining_seats) == 1: self.distribute_winnings(remaining_seats) return self.get_seat_statuses() winners = self.winners_from_remaining(remaining_seats) winner_string = ", ".join(str(winner.index) for winner in winners) self.LOGGER.debug("Winning player(s): {}".format(winner_string)) self.distribute_winnings(winners) return self.get_seat_statuses() def players_can_bet(self, remaining_seats): can_bet = sum(1 for seat in remaining_seats if seat.chips > 0) return can_bet > 1 def get_seat_statuses(self): still_in = deque(seat for seat in self.seats if seat.chips > 0) gone_out = [seat for seat in self.seats if seat.chips == 0] return still_in, gone_out def shuffle_and_deal(self): self.deck = Deck() self.deck.shuffle() for seat in self.seats: seat.set_card_1(self.deck.deal()) for seat in self.seats: seat.set_card_2(self.deck.deal()) def put_in_blinds(self): small_blind = self.small_blind big_blind = self.small_blind * 2 self.seats[1].bet_chips(small_blind) self.seats[2 % len(self.seats)].bet_chips(big_blind) def deal_flop(self): # burn card self.deck.deal() # deal three cards as the flop for _ in range(3): self.cards.append(self.deck.deal()) def deal_turn(self): # burn card self.deck.deal() # deal turn self.cards.append(self.deck.deal()) def deal_river(self): # burn card self.deck.deal() # deal turn self.cards.append(self.deck.deal()) def winners_from_remaining(self, remaining_seats): hands = [] for seat in remaining_seats: hand = get_best_hand(seat.get_cards(), self.cards) hands.append((seat, hand)) best_hand = max(hands, key=lambda seat_hand_pair: seat_hand_pair[1]) return [ seat_hand_pair[0] for seat_hand_pair in hands if seat_hand_pair[1] == best_hand[1] ] def distribute_winnings(self, winners): winners.sort(key=lambda seat: seat.pot) winners_by_deal_order = [ seat for seat in self.seats if seat in winners ] while len(winners) > 0: winner = winners[0] winnings = 0 winnings_cap = winner.pot # create a side pot for seat in self.seats: winnings += seat.get_chips_from_pot(winnings_cap) # split that side pot normalized_winnings = winnings // self.min_denomination quotient = (normalized_winnings // len(winners)) * \ self.min_denomination remainders = normalized_winnings % len(winners) for winner in winners: winner.take_winnings(quotient) for index in range(remainders): winners_by_deal_order[index].take_winnings( self.min_denomination) del winners[0] for seat in self.seats: seat.reclaim_remaining_pot()