def showdown(self, round_players): """ Evaluate the best hand """ board = create_board(self) high_scorer = self.dealer hand = create_hand(self.dealer) for card in self.dealer.player_cards(): suit, rank = card.identify_card() print(suit + rank) min_score = evaluate_player_hand( board, hand) #start with the dealer as the best hand for player in round_players: hand = create_hand( player) #Find the highest hand and use that as the high scorer score = evaluate_player_hand(board, hand) if score < min_score: min_score = score high_scorer = player print("Player " + str(high_scorer.player_number()) + " has won!") high_scorer.win(self.pot) evaluator = Evaluator() winning_class = evaluator.get_rank_class(min_score) print("The winning hand was " + evaluator.class_to_string(winning_class) + '.')
def index(): evaluator = Evaluator() deck = Deck() card = Card.new('Qh') board = deck.draw(5) player_names = ("player 1", "player 2", "player 3", "player 4", "player 5", "player 6", "player 7", "player 8") players = {} output = {} # this is procedural programming, not functional programming :( for p in player_names: hand = deck.draw(2) score = evaluator.evaluate(board, hand) text = evaluator.class_to_string(evaluator.get_rank_class(score)) players[p] = score output[p] = {'score': score, 'text': text} # What about a tie? tie = (len(players.values()) == len(set(players.values()))) winner = min( players, key=players.get) # always 1 result :( Don't forget to fix the TEST! # does the tie involve the winning hand though? # TODO https://stackoverflow.com/questions/17821079/how-to-check-if-two-keys-in-dictionary-hold-the-same-value output["winners"] = winner output["tie"] = tie output["card"] = Card.int_to_str(card) j = json.dumps(output) return j
def evaluateFromState(self, state, playerid): # print("state",state.player_states[playerid].hand) evaluator = Evaluator() hand = [] board = [] # p1_score = evaluator.evaluate(board, player1_hand) for i in state.player_states[playerid].hand: hand.append(Card.new(card_to_normal_str(i))) # print(card_to_normal_str(i)) # print(hand) for j in state.community_card: if j != -1: # print(card_to_normal_str(j)) board.append(Card.new(card_to_normal_str(j))) # print(board) if len(board) == 0: rank = evaluator.evaluate(hand, []) elif len(board) == 3: rank = evaluator.evaluate(hand, board[:3]) elif len(board) == 4: rank = evaluator.evaluate(hand, board[:4]) elif len(board) == 5: rank = evaluator.evaluate(hand, board[:5]) rank_class = evaluator.get_rank_class(rank) class_string = evaluator.class_to_string(rank_class) percentage = 1.0 - evaluator.get_five_card_rank_percentage( rank) # higher better here # print("Player hand = {}, percentage rank among all hands = {}".format(class_string, percentage)) return [rank, percentage]
def getWinners(gameId, players): evaluator = Evaluator() boardCards = [] rankings = {} _, board, _, _, _, _, _, _, _, _, _ = db.getGame(gameId) for i in board.split(":"): boardCards.append(pyDealerCardToDeucesCard(i)) for i in players: cards = i[3] rankings[i[0]] = evaluator.evaluate(boardCards, [ pyDealerCardToDeucesCard(cards.split(":")[0]), pyDealerCardToDeucesCard(cards.split(":")[1]) ]) v = list(rankings.values()) minValue = min(v) winners = [] for i in rankings: if rankings[i] == minValue: winners.append([ i, evaluator.class_to_string(evaluator.get_rank_class(minValue)) ]) return winners
def evaluateHands(self): # convert cards to correct format for treys library first_card_board = self.state.community_cards[0][ 'rank'] + self.state.community_cards[0]['suit'].lower() second_card_board = self.state.community_cards[1][ 'rank'] + self.state.community_cards[1]['suit'].lower() third_card_board = self.state.community_cards[2][ 'rank'] + self.state.community_cards[2]['suit'].lower() fourth_card_board = self.state.community_cards[3][ 'rank'] + self.state.community_cards[3]['suit'].lower() fifth_card_board = self.state.community_cards[4][ 'rank'] + self.state.community_cards[4]['suit'].lower() # then create a list of community cards board = [ Card.new(first_card_board), Card.new(second_card_board), Card.new(third_card_board), Card.new(fourth_card_board), Card.new(fifth_card_board) ] results = {} # do the same thing for each active player evaluator = Evaluator() winning_hand = 7463 players_in_hand = { k: v for k, v in self.state.players.items() if v.in_hand } for username, player in players_in_hand.items(): first_card = player.hole_cards[0]['rank'] + player.hole_cards[0][ 'suit'].lower() second_card = player.hole_cards[1]['rank'] + player.hole_cards[1][ 'suit'].lower() hand = [Card.new(first_card), Card.new(second_card)] player_result = {} player_result['score'] = evaluator.evaluate(board, hand) player_result['hand_class'] = evaluator.get_rank_class( player_result['score']) player_result['hand_class_string'] = evaluator.class_to_string( player_result['hand_class']) results[username] = player_result # results = {'player0': {'score': 1, 'hand_class': 8, 'hand_class_string': 'Pair'}, # 'player1': {'score': 1, 'hand_class': 8, 'hand_class_string': 'Pair'}, # 'player2': {'score': 2, 'hand_class': 8, 'hand_class_string': 'Pair'}, # 'player3': {'score': 1, 'hand_class': 8, 'hand_class_string': 'Pair'} # } return results
def evaluateCards(board, hand): board = [Card.new('Ah'), Card.new('Kd'), Card.new('Jc')] hand = [Card.new('Qs'), Card.new('Qh')] Card.print_pretty_cards(board + hand) evaluator = Evaluator() score = evaluator.evaluate(board, hand) handType = evaluator.get_rank_class(score) print("Player 1 hand rank = %d (%s)\n" % (score, evaluator.class_to_string(handType)))
async def calculate_plo(web_client, user_id, channel_id): active_players = player_list[channel_id] tab = tab_list[channel_id]["table"] evaluator = Evaluator() for name in active_players: high = await find_best_plo_hand(name.name, channel_id) print(high, name.name) rank = evaluator.get_rank_class(high) name.cardswords = evaluator.class_to_string(rank) name.score = high for name in active_players: pic = Card.print_pretty_cards(name.cards) await sendslack("<@%s> shows %s" % (name.name, pic), web_client, channel_id) for name in active_players: await sendslack( "<@%s> has %s" % (name.name, name.cardswords), web_client, channel_id ) if active_players[0].score < active_players[1].score: await sendslack( "<@%s> wins %d" % (active_players[0].name, tab.pot), web_client, channel_id ) active_players[0].money += tab.pot else: await sendslack( "<@%s> wins %d" % (active_players[1].name, tab.pot), web_client, channel_id ) active_players[1].money += tab.pot if len(active_players) > 1: if active_players[0].money != 0 and active_players[1].money != 0: if active_players[1].dealer: active_players += [active_players.pop(0)] tab.cards.clear() tab.turn = 0 tab.highbet = 0 tab.pot = 0 for name in active_players: name.cards.clear() name.tocall = 0 name.dealer = False name.bet = 0 name.reraise = 0 name.canclose = False await set_up_game(web_client, channel_id, plo=True)
def evaluateCards(board, hand): hand = [ Card.new("Qs"), Card.new("8c") ] board = [ Card.new("Ks"), Card.new("Ad"), Card.new("Jc"), Card.new("5d"), Card.new("7s"), ] Card.print_pretty_cards(board + hand) evaluator = Evaluator() score = evaluator.evaluate(board, hand) handType = evaluator.get_rank_class(score) print("Player 1 hand rank = %d (%s)\n" % (score, evaluator.class_to_string(handType)))
def test_my_hand(self): """ Input: Cards from my profile as a string Output: Descripting poker hand as a string """ # Player Arrange table_cards = str(Card.new('3s')) + ',' \ + str(Card.new('2s')) + ',' \ + str(Card.new('As')) + ',' \ + str(Card.new('Ks')) + ',' \ + str(Card.new('Qs')) player_cards = str(Card.new('Js')) + ',' + str(Card.new('Ts')) table = Table(cards_on_table=table_cards) player = Player(table=table, cards=player_cards) # Player Act player_result = player.my_hand() # Treys Arrange board = [ Card.new('3s'), Card.new('2s'), Card.new('As'), Card.new('Ks'), Card.new('Qs') ] gamer = [Card.new('Js'), Card.new('Ts')] # Treys Act evaluator = Evaluator() score = evaluator.evaluate(board, gamer) classs = evaluator.get_rank_class(score) treys_result = evaluator.class_to_string(classs) # Assertion self.assertEqual(player_result, treys_result) self.assertIsInstance(player_result, str)
def my_hand(self): """Return name of my best hand""" # Cards is on the table if self.table.cards_on_table != None: # 1. Get cards from table and from player # and convert them to list of int's cards_on_table = \ self.convert_from_string_to_list(self.table.cards_on_table) cards_on_table = list(map(int, cards_on_table)) my_cards = self.convert_from_string_to_list(self.cards) my_cards = list(map(int, my_cards)) # 2. Show my hand evaluator = Evaluator() score = evaluator.evaluate(cards_on_table, my_cards) classs = evaluator.get_rank_class(score) my_hand = evaluator.class_to_string(classs) return my_hand # No cards on table else: return ''
def evaluateCards(boardCards, handCards): # decrypt the two hand cards sent from the client + board cards n = 2 str(boardCards).lower() boardCardsSplit = [(boardCards[i:i + n]) for i in range(0, len(boardCards), n)] str(handCards).lower() handCardsSplit = [(handCards[i:i + n]) for i in range(0, len(handCards), n)] handCardsSplit[0] = handCardsSplit[0][1] + handCardsSplit[0][0] handCardsSplit[1] = handCardsSplit[1][1] + handCardsSplit[1][0] hand = [ Card.new(str(handCardsSplit[0].capitalize())), Card.new(str(handCardsSplit[1].capitalize())) ] board = [] i = 0 if len(list(boardCardsSplit)) == 3: board = [ Card.new(str(boardCardsSplit[0].capitalize())), Card.new(str(boardCardsSplit[1].capitalize())), Card.new(str(boardCardsSplit[2].capitalize())) ] else: if len(list(boardCardsSplit)) == 4: board = [ Card.new(str(boardCardsSplit[0].capitalize())), Card.new(str(boardCardsSplit[1].capitalize())), Card.new(str(boardCardsSplit[2].capitalize())), Card.new(str(boardCardsSplit[3].capitalize())) ] else: if len(list(boardCardsSplit)) == 5: board = [ Card.new(str(boardCardsSplit[0].capitalize())), Card.new(str(boardCardsSplit[1].capitalize())), Card.new(str(boardCardsSplit[2].capitalize())), Card.new(str(boardCardsSplit[3].capitalize())), Card.new(str(boardCardsSplit[4].capitalize())) ] deck = Deck() print(Card.print_pretty_cards(board + hand)) evaluator = Evaluator() bestScore = evaluator.evaluate(board, hand) handType = evaluator.get_rank_class(bestScore) print("Player 1 hand rank = %d (%s)\n" % (bestScore, evaluator.class_to_string(handType))) if (len(board) == 5): for i in range(len(board) + len(hand)): # Make copy of hand and board tempHand = [] tempBoard = [] for j in range(len(hand)): tempHand.append(hand[j]) for j in range(len(board)): tempBoard.append(board[j]) #First try removing one of the hand cards if (i < 2): tempHand.pop(i) tempHand.append(board[0]) tempBoard.pop(0) #Now we try removing board cards else: tempBoard.pop(i - 2) #Find the score score = evaluator.evaluate(tempBoard, tempHand) #If score is same as before, these cards have the best hand if (score == bestScore): # Make copy of best hand and board best6Hand = [] best6Board = [] for j in range(len(tempHand)): best6Hand.append(tempHand[j]) for j in range(len(tempBoard)): best6Board.append(tempBoard[j]) break else: best6Board = board best6Hand = hand print(Card.print_pretty_cards(best6Board + best6Hand)) if (len(best6Board) == 4 or len(board) == 4): #we repeat the process to have the best 5 cards for i in range(len(best6Board) + len(best6Hand)): #Make copy of hand and board tempHand = [] tempBoard = [] for j in range(len(best6Hand)): tempHand.append(best6Hand[j]) for j in range(len(best6Board)): tempBoard.append(best6Board[j]) if (i < 2): tempHand.pop(i) tempHand.append(best6Board[0]) tempBoard.pop(0) else: tempBoard.pop(i - 2) score = evaluator.evaluate(tempBoard, tempHand) if (score == bestScore): # Make copy of best hand and board best5Hand = [] best5Board = [] for j in range(len(tempHand)): best5Hand.append(tempHand[j]) for j in range(len(tempBoard)): best5Board.append(tempBoard[j]) break else: best5Board = best6Board best5Hand = best6Hand print(Card.print_pretty_cards(best5Board + best5Hand)) card1 = convertCardToString(best5Board.__getitem__(0)) card2 = convertCardToString(best5Board.__getitem__(1)) card3 = convertCardToString(best5Board.__getitem__(2)) card4 = convertCardToString(best5Hand.__getitem__(0)) card5 = convertCardToString(best5Hand.__getitem__(1)) handString = card1 + card2 + card3 + card4 + card5 print("Hand string: " + handString) stringToSend = str(handType) + " " + handString + " " + str(bestScore) print("String to send: " + stringToSend) return stringToSend
def run(rounds): reward_table = dict() reward_count = dict() round_number = 0 print("running heuristic:") print_progress(round_number, rounds, prefix='Progress:', suffix='Complete', bar_length=40) while round_number < rounds: deck = Deck() Player_1 = Player() Player_2 = Player() flop = deck.draw(3) #print("Flop Cards") # for cards in flop: #print(Card.int_to_pretty_str(cards)) player1_hand = deck.draw(2) #print("Player 1 Cards") # for cards in player1_hand: #print(Card.int_to_pretty_str(cards)) player2_hand = deck.draw(2) #print("Player 2 Cards") # for cards in player2_hand: #print(Card.int_to_pretty_str(cards)) evaluator = Evaluator() all_card_array_stage3 = np.zeros((4, 13)) all_card_array_stage1 = np.zeros((4, 13)) all_card_array_stage2 = np.zeros((4, 13)) def convert_pot_to_numpy(total_pot): pot_array = np.zeros((4, 13)) number_of_chips = int(total_pot / 25) if number_of_chips > 13: pot_array[1] = 1 left_over_chips = number_of_chips - 13 for i in range(0, left_over_chips): pot_array[2][i] = 1 else: for i in range(0, number_of_chips): pot_array[1][i] = 1 return pot_array def convert_to_numpy_array(Card_str, all_card_array): if Card_str[0] == "J": index_1 = 9 elif Card_str[0] == "Q": index_1 = 10 elif Card_str[0] == "K": index_1 = 11 elif Card_str[0] == "A": index_1 = 12 elif Card_str[0] == "T": index_1 = 8 else: index_1 = int(Card_str[0]) - 2 if Card_str[1] == "s": index_2 = 0 elif Card_str[1] == "c": index_2 = 1 elif Card_str[1] == "h": index_2 = 2 else: index_2 = 3 new_card_array = np.zeros((4, 13)) new_card_array[index_2][index_1] = 1 all_card_array[index_2][index_1] = 1 return new_card_array, all_card_array def get_possible_actions(player_action): if player_action == "Check/Call": return ["Fold", "Bet"] elif player_action == "Bet": return ["Fold", "Check/Call"] else: return ["Fold", "Bet", "Check/Call"] def betting(player1_turn_rank, player2_turn_rank, all_possible_actions): action_1, player1_new_bet = Player_1.make_bets( player1_turn_rank, all_possible_actions, 0) #print("Player 1",action_1) if action_1 == "Fold": return "Player2", 0, 0, 0, action_1 elif action_1 == "Bet": possible_actions = get_possible_actions(action_1) action_2, player2_new_bet = Player_2.make_bets( player2_turn_rank, possible_actions, player1_new_bet) #print("Player 2", action_2) if action_2 == "Fold": return "Player1", player1_new_bet, 0, player1_new_bet, action_1 else: return "", player1_new_bet, player1_new_bet, 2 * player1_new_bet, action_1 else: action_2, player2_new_bet = Player_2.make_bets( player2_turn_rank, all_possible_actions, 0) #print("Player 2", action_2) if action_2 == "Fold": return "Player1", 0, 0, 0, action_1 elif action_2 == "Check/Call": return "", 0, 0, 0, action_1 else: possible_actions = get_possible_actions(action_2) action_1, player1_new_bet = Player_1.make_bets( player1_turn_rank, possible_actions, player2_new_bet) #print("Player 1", action_1) if action_1 == "Fold": return "Player2", 0, player2_new_bet, player2_new_bet, action_1 else: return "", player2_new_bet, player2_new_bet, 2 * player2_new_bet, action_1 total_pot_size = 0 player1_bet = 0 player2_bet = 0 player1_turn1 = flop + player1_hand player2_turn1 = flop + player2_hand player1_turn1_rank = evaluator.class_to_string( evaluator.get_rank_class(evaluator._five(player1_turn1))) player2_turn1_rank = evaluator.class_to_string( evaluator.get_rank_class(evaluator._five(player2_turn1))) all_possible_action = ["Fold", "Bet", "Check/Call"] winner, player1_round1_bet, player2_round1_bet, round1_pot_size, player1_action_stage1 = betting( player1_turn1_rank, player2_turn1_rank, all_possible_action) player1_bet += player1_round1_bet player2_bet += player2_round1_bet total_pot_size += round1_pot_size Card1_stage1_array, all_card_array_stage1 = convert_to_numpy_array( Card.int_to_str(flop[0]), all_card_array_stage1) Card2_stage1_array, all_card_array_stage1 = convert_to_numpy_array( Card.int_to_str(flop[1]), all_card_array_stage1) Card3_stage1_array, all_card_array_stage1 = convert_to_numpy_array( Card.int_to_str(flop[2]), all_card_array_stage1) Card4_stage1_array = np.zeros((4, 13)) Card5_stage1_array = np.zeros((4, 13)) Card6_stage1_array, all_card_array_stage1 = convert_to_numpy_array( Card.int_to_str(player1_hand[0]), all_card_array_stage1) Card7_stage1_array, all_card_array_stage1 = convert_to_numpy_array( Card.int_to_str(player1_hand[1]), all_card_array_stage1) pot_array_stage1 = convert_pot_to_numpy(total_pot_size) state_array_stage1 = np.stack( (Card1_stage1_array, Card2_stage1_array, Card3_stage1_array, Card4_stage1_array, Card5_stage1_array, Card6_stage1_array, Card7_stage1_array, all_card_array_stage1, pot_array_stage1)) hash_key_stage1 = pickle.dumps(state_array_stage1) gain_loss_table_stage1 = np.zeros((3)) gain_loss_count_stage1 = np.zeros((3)) if winner == "Player1": #print(player1_action_stage1) if player1_action_stage1 == "Bet": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][2] += int(total_pot_size - player1_bet) reward_count[hash_key_stage1][2] += 1 else: gain_loss_count_stage1[2] += 1 gain_loss_table_stage1[2] += int(total_pot_size - player1_bet) elif player1_action_stage1 == "Check/Call": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][1] += int(total_pot_size - player1_bet) reward_count[hash_key_stage1][1] += 1 else: gain_loss_count_stage1[1] += 1 gain_loss_table_stage1[1] += int(total_pot_size - player1_bet) #print("Player 1 Wins: ",total_pot_size) #print("Player 1 Gain: ", total_pot_size-player1_bet) elif winner == "Player2": if hash_key_stage1 in reward_table.keys(): if player1_action_stage1 == "Fold": reward_table[hash_key_stage1][0] += -1 * int(player1_bet) reward_count[hash_key_stage1][0] += 1 else: if player1_action_stage1 == "Fold": gain_loss_table_stage1[0] = -1 * int(player1_bet) gain_loss_count_stage1[0] += 1 #print("Player 2 Wins: ",total_pot_size) #print("Player 2 Gain: ", total_pot_size-player2_bet) else: turn = deck.draw(1) #print("Turn ",Card.int_to_pretty_str(turn)) player1_turn2 = player1_turn1 + [turn] player2_turn2 = player2_turn1 + [turn] player1_turn2_rank = evaluator.class_to_string( evaluator.get_rank_class(evaluator._six(player1_turn2))) player2_turn2_rank = evaluator.class_to_string( evaluator.get_rank_class(evaluator._six(player2_turn2))) winner, player1_round2_bet, player2_round2_bet, round2_pot_size, player1_action_stage2 = betting( player1_turn2_rank, player2_turn2_rank, all_possible_action) player1_bet += player1_round2_bet player2_bet += player2_round2_bet total_pot_size += round2_pot_size Card1_stage2_array, all_card_array_stage2 = convert_to_numpy_array( Card.int_to_str(flop[0]), all_card_array_stage2) Card2_stage2_array, all_card_array_stage2 = convert_to_numpy_array( Card.int_to_str(flop[1]), all_card_array_stage2) Card3_stage2_array, all_card_array_stage2 = convert_to_numpy_array( Card.int_to_str(flop[2]), all_card_array_stage2) Card4_stage2_array, all_card_array_stage2 = convert_to_numpy_array( Card.int_to_str(turn), all_card_array_stage2) Card5_stage2_array = np.zeros((4, 13)) Card6_stage2_array, all_card_array_stage2 = convert_to_numpy_array( Card.int_to_str(player1_hand[0]), all_card_array_stage2) Card7_stage2_array, all_card_array_stage2 = convert_to_numpy_array( Card.int_to_str(player1_hand[1]), all_card_array_stage2) pot_array_stage2 = convert_pot_to_numpy(total_pot_size) state_array_stage2 = np.stack( (Card1_stage2_array, Card2_stage2_array, Card3_stage2_array, Card4_stage2_array, Card5_stage2_array, Card6_stage2_array, Card7_stage2_array, all_card_array_stage2, pot_array_stage2)) hash_key_stage2 = pickle.dumps(state_array_stage2) gain_loss_table_stage2 = np.zeros((3)) gain_loss_count_stage2 = np.zeros((3)) if winner == "Player1": #print(player1_action_stage2) if player1_action_stage2 == "Bet": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][2] += int( total_pot_size - player1_bet) reward_count[hash_key_stage2][2] += 1 else: gain_loss_count_stage2[2] += 1 gain_loss_table_stage2[2] += int(total_pot_size - player1_bet) elif player1_action_stage2 == "Check/Call": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][1] += int( total_pot_size - player1_bet) reward_count[hash_key_stage2][1] += 1 else: gain_loss_count_stage2[1] += 1 gain_loss_table_stage2[1] += int(total_pot_size - player1_bet) if player1_action_stage1 == "Bet": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][2] += int( total_pot_size - player1_bet) reward_count[hash_key_stage1][2] += 1 else: gain_loss_count_stage1[2] += 1 gain_loss_table_stage1[2] += int(total_pot_size - player1_bet) elif player1_action_stage1 == "Check/Call": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][1] += int( total_pot_size - player1_bet) reward_count[hash_key_stage1][1] += 1 else: gain_loss_count_stage1[1] += 1 gain_loss_table_stage1[1] += int(total_pot_size - player1_bet) #print("Player 1 Wins: ",total_pot_size) #print("Player 1 Gain: ",total_pot_size-player1_bet) elif winner == "Player2": if hash_key_stage2 in reward_table.keys(): if player1_action_stage2 == "Fold": reward_table[hash_key_stage2][0] += -1 * int( player1_bet) reward_count[hash_key_stage2][0] += 1 else: if player1_action_stage2 == "Fold": gain_loss_table_stage2[0] = -1 * int(player1_bet) gain_loss_count_stage2[0] += 1 if player1_action_stage1 == "Bet": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][2] += int( total_pot_size - player1_bet) reward_count[hash_key_stage1][2] += 1 else: gain_loss_count_stage1[2] += 1 gain_loss_table_stage1[2] += int(total_pot_size - player1_bet) elif player1_action_stage1 == "Check/Call": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][1] += -1 * int( player1_bet) reward_count[hash_key_stage1][1] += 1 else: gain_loss_count_stage1[1] += 1 gain_loss_table_stage1[1] += -1 * int(player1_bet) #print("Player 2 Wins: ",total_pot_size) #print("Player 2 Gain: ",total_pot_size-player2_bet) else: river = deck.draw(1) #print("River ",Card.int_to_pretty_str(river)) player1_turn3 = player1_turn2 + [river] player2_turn3 = player2_turn2 + [river] #Creating state array Card1 = Card.int_to_str(flop[0]) Card2 = Card.int_to_str(flop[1]) Card3 = Card.int_to_str(flop[2]) Card4 = Card.int_to_str(turn) Card5 = Card.int_to_str(river) Card6 = Card.int_to_str(player1_hand[0]) Card7 = Card.int_to_str(player1_hand[1]) Card1_stage3_array, all_card_array_stage3 = convert_to_numpy_array( Card1, all_card_array_stage3) Card2_stage3_array, all_card_array_stage3 = convert_to_numpy_array( Card2, all_card_array_stage3) Card3_stage3_array, all_card_array_stage3 = convert_to_numpy_array( Card3, all_card_array_stage3) Card4_stage3_array, all_card_array_stage3 = convert_to_numpy_array( Card4, all_card_array_stage3) Card5_stage3_array, all_card_array_stage3 = convert_to_numpy_array( Card5, all_card_array_stage3) Card6_stage3_array, all_card_array_stage3 = convert_to_numpy_array( Card6, all_card_array_stage3) Card7_stage3_array, all_card_array_stage3 = convert_to_numpy_array( Card7, all_card_array_stage3) player1_turn3_rank = evaluator.class_to_string( evaluator.get_rank_class(evaluator._seven(player1_turn3))) player2_turn3_rank = evaluator.class_to_string( evaluator.get_rank_class(evaluator._seven(player2_turn3))) winner, player1_round3_bet, player2_round3_bet, round3_pot_size, player1_action = betting( player1_turn3_rank, player2_turn3_rank, all_possible_action) player1_bet += player1_round3_bet player2_bet += player2_round3_bet total_pot_size += round3_pot_size total_pot_array = convert_pot_to_numpy(total_pot_size) state_array_stage3 = np.stack( (Card1_stage3_array, Card2_stage3_array, Card3_stage3_array, Card4_stage3_array, Card5_stage3_array, Card6_stage3_array, Card7_stage3_array, all_card_array_stage3, total_pot_array)) # #print(state_array) hash_key = pickle.dumps(state_array_stage3) gain_loss_table_stage3 = np.zeros((3)) gain_loss_count_stage3 = np.zeros((3)) if winner == "Player1": #print(player1_action) if hash_key in reward_table.keys(): if player1_action == "Check/Call": reward_table[hash_key][1] += int(total_pot_size - player1_bet) reward_count[hash_key][1] += 1 elif player1_action == "Bet": reward_table[hash_key][2] += int(total_pot_size - player1_bet) reward_count[hash_key][2] += 1 else: if player1_action == "Check/Call": gain_loss_table_stage3[1] = int(total_pot_size - player1_bet) gain_loss_count_stage3[1] += 1 elif player1_action == "Bet": gain_loss_table_stage3[2] = int(total_pot_size - player1_bet) gain_loss_count_stage3[2] += 1 if player1_action_stage2 == "Bet": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][2] += int( total_pot_size - player1_bet) reward_count[hash_key_stage2][2] += 1 else: gain_loss_count_stage2[2] += 1 gain_loss_table_stage2[2] += int(total_pot_size - player1_bet) elif player1_action_stage2 == "Check/Call": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][1] += int( total_pot_size - player1_bet) reward_count[hash_key_stage2][1] += 1 else: gain_loss_count_stage2[1] += 1 gain_loss_table_stage2[1] += int(total_pot_size - player1_bet) if player1_action_stage1 == "Bet": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][2] += int( total_pot_size - player1_bet) reward_count[hash_key_stage1][2] += 1 else: gain_loss_count_stage1[2] += 1 gain_loss_table_stage1[2] += int(total_pot_size - player1_bet) elif player1_action_stage1 == "Check/Call": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][1] += int( total_pot_size - player1_bet) reward_count[hash_key_stage1][1] += 1 else: gain_loss_count_stage1[1] += 1 gain_loss_table_stage1[1] += int(total_pot_size - player1_bet) #print("Player 1 Wins: ",total_pot_size) #print("Player 1 Gain: ",total_pot_size-player1_bet) elif winner == "Player2": if hash_key in reward_table.keys(): if player1_action == "Fold": reward_table[hash_key][0] += -1 * int(player1_bet) reward_count[hash_key][0] += 1 else: if player1_action == "Fold": gain_loss_table_stage3[0] = -1 * int(player1_bet) gain_loss_count_stage3[0] += 1 if player1_action_stage2 == "Bet": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][2] += -1 * int( player1_bet) reward_count[hash_key_stage2][2] += 1 else: gain_loss_count_stage2[2] += 1 gain_loss_table_stage2[2] += -1 * int(player1_bet) elif player1_action_stage2 == "Check/Call": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][1] += -1 * int( player1_bet) reward_count[hash_key_stage2][1] += 1 else: gain_loss_count_stage2[1] += 1 gain_loss_table_stage2[1] += -1 * int(player1_bet) if player1_action_stage1 == "Bet": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][2] += -1 * int( player1_bet) reward_count[hash_key_stage1][2] += 1 else: gain_loss_count_stage1[2] += 1 gain_loss_table_stage1[2] += -1 * int(player1_bet) elif player1_action_stage1 == "Check/Call": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][1] += -1 * int( player1_bet) reward_count[hash_key_stage1][1] += 1 else: gain_loss_count_stage1[1] += 1 gain_loss_table_stage1[1] += -1 * int(player1_bet) #print("Player 2 Wins: ",total_pot_size) #print("Player 2 Gain: ",total_pot_size-player2_bet) else: final_score_player1 = evaluator.get_rank_class( evaluator._seven(player1_turn3)) final_score_player2 = evaluator.get_rank_class( evaluator._seven(player2_turn3)) if final_score_player1 < final_score_player2: #print(player1_action) if hash_key in reward_table.keys(): if player1_action == "Check/Call": reward_table[hash_key][1] += int( total_pot_size - player1_bet) reward_count[hash_key][1] += 1 elif player1_action == "Bet": reward_table[hash_key][2] += int( total_pot_size - player1_bet) reward_count[hash_key][2] += 1 else: if player1_action == "Check/Call": gain_loss_table_stage3[1] = int( total_pot_size - player1_bet) gain_loss_count_stage3[1] += 1 elif player1_action == "Bet": gain_loss_table_stage3[2] = int( total_pot_size - player1_bet) gain_loss_count_stage3[2] += 1 if player1_action_stage2 == "Bet": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][2] += int( total_pot_size - player1_bet) reward_count[hash_key_stage2][2] += 1 else: gain_loss_count_stage2[2] += 1 gain_loss_table_stage2[2] += int( total_pot_size - player1_bet) elif player1_action_stage2 == "Check/Call": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][1] += int( total_pot_size - player1_bet) reward_count[hash_key_stage2][1] += 1 else: gain_loss_count_stage2[1] += 1 gain_loss_table_stage2[1] += int( total_pot_size - player1_bet) if player1_action_stage1 == "Bet": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][2] += int( total_pot_size - player1_bet) reward_count[hash_key_stage1][2] += 1 else: gain_loss_count_stage1[2] += 1 gain_loss_table_stage1[2] += int( total_pot_size - player1_bet) elif player1_action_stage1 == "Check/Call": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][1] += int( total_pot_size - player1_bet) reward_count[hash_key_stage1][1] += 1 else: gain_loss_count_stage1[1] += 1 gain_loss_table_stage1[1] += int( total_pot_size - player1_bet) #print("Player 1 Wins: ",total_pot_size) #print("Player 1 Gain: ",total_pot_size-player1_bet) else: if hash_key in reward_table.keys(): if player1_action == "Check/Call": reward_table[hash_key][1] += -1 * int( player1_bet) reward_count[hash_key][1] += 1 elif player1_action == "Bet": reward_table[hash_key][2] += -1 * int( player1_bet) reward_count[hash_key][2] += 1 else: if player1_action == "Check/Call": gain_loss_table_stage3[1] = -1 * int( player1_bet) gain_loss_count_stage3[1] += 1 elif player1_action == "Bet": gain_loss_table_stage3[2] = -1 * int( player1_bet) gain_loss_count_stage3[2] += 1 if player1_action_stage2 == "Bet": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][2] += -1 * int( player1_bet) reward_count[hash_key_stage2][2] += 1 else: gain_loss_count_stage2[2] += 1 gain_loss_table_stage2[2] += -1 * int( player1_bet) elif player1_action_stage2 == "Check/Call": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][1] += -1 * int( player1_bet) reward_count[hash_key_stage2][1] += 1 else: gain_loss_count_stage2[1] += 1 gain_loss_table_stage2[1] += -1 * int( player1_bet) if player1_action_stage1 == "Bet": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][2] += -1 * int( player1_bet) reward_count[hash_key_stage1][2] += 1 else: gain_loss_count_stage1[2] += 1 gain_loss_table_stage1[2] += -1 * int( player1_bet) elif player1_action_stage1 == "Check/Call": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][1] += -1 * int( player1_bet) reward_count[hash_key_stage1][1] += 1 else: gain_loss_count_stage1[1] += 1 gain_loss_table_stage1[1] += -1 * int( player1_bet) #print("Player 2 Wins: ",total_pot_size) #print("Player 2 Gain: ",total_pot_size-player2_bet) if hash_key not in reward_table.keys(): reward_table[hash_key] = gain_loss_table_stage3 reward_count[hash_key] = gain_loss_count_stage3 if hash_key_stage2 not in reward_table.keys(): reward_table[hash_key_stage2] = gain_loss_table_stage2 reward_count[hash_key_stage2] = gain_loss_count_stage2 if hash_key_stage1 not in reward_table.keys(): reward_table[hash_key_stage1] = gain_loss_table_stage1 reward_count[hash_key_stage1] = gain_loss_count_stage1 round_number += 1 print_progress(round_number, rounds, prefix='Progress:', suffix='Complete', bar_length=40) for key in reward_table.keys(): count_fold = reward_count[key][0] count_check = reward_count[key][1] count_bet = reward_count[key][2] if count_fold != 0: reward_table[key][0] = reward_table[key][0] / count_fold if count_check != 0: reward_table[key][1] = reward_table[key][1] / count_check if count_bet != 0: reward_table[key][2] = reward_table[key][2] / count_bet return reward_table
def run(rounds, model): reward_table = dict() reward_count = dict() print("running self-play") round_number = 0 print_progress(round_number, rounds, prefix='Progress:', suffix='Complete', bar_length=40) while round_number < rounds: deck = Deck() evaluator = Evaluator() flop = deck.draw(3) # for card in flop: # print(Card.int_to_pretty_str(card)) player1_hand = deck.draw(2) # for card in player1_hand: # print(Card.int_to_pretty_str(card)) player2_hand = deck.draw(3) turn = deck.draw(1) river = deck.draw(1) player1_complete_hand = flop + [turn] + [river] + player1_hand player2_complete_hand = flop + [turn] + [river] + player2_hand def get_action_position2(y_stage, other_player_action): if other_player_action == "Bet": out_of_bounds_index = 2 index = 0 max_gain_loss = y_stage[0] for i in range(1, len(y_stage)): if i != out_of_bounds_index: if max_gain_loss < y_stage[i]: index = i max_gain_loss = y_stage[i] if index == 0: return "Fold" elif index == 1: return "Check/Call" else: return "Bet" def get_action(y_stage): index = 0 max_gain_loss = y_stage[0][0] for i in range(1, len(y_stage[0])): if max_gain_loss < y_stage[0][i]: index = i max_gain_loss = y_stage[0][i] if index == 0: return "Fold" elif index == 1: return "Check/Call" else: return "Bet" def convert_pot_to_numpy(total_pot): pot_array = np.zeros((4, 13)) number_of_chips = int(total_pot / 25) if number_of_chips > 13: pot_array[1] = 1 left_over_chips = number_of_chips - 13 for i in range(0, left_over_chips): pot_array[2][i] = 1 else: for i in range(0, number_of_chips): pot_array[1][i] = 1 return pot_array def convert_to_numpy_array(Card_str, all_card_array_player1, all_card_array_player2): if Card_str[0] == "J": index_1 = 9 elif Card_str[0] == "Q": index_1 = 10 elif Card_str[0] == "K": index_1 = 11 elif Card_str[0] == "A": index_1 = 12 elif Card_str[0] == "T": index_1 = 8 else: index_1 = int(Card_str[0]) - 2 if Card_str[1] == "s": index_2 = 0 elif Card_str[1] == "c": index_2 = 1 elif Card_str[1] == "h": index_2 = 2 else: index_2 = 3 new_card_array = np.zeros((4, 13)) new_card_array[index_2][index_1] = 1 all_card_array_player1[index_2][index_1] = 1 all_card_array_player2[index_2][index_1] = 1 return new_card_array, all_card_array_player1, all_card_array_player2 def convert_to_numpy_array_playercards(Card_str, all_card_array): if Card_str[0] == "J": index_1 = 9 elif Card_str[0] == "Q": index_1 = 10 elif Card_str[0] == "K": index_1 = 11 elif Card_str[0] == "A": index_1 = 12 elif Card_str[0] == "T": index_1 = 8 else: index_1 = int(Card_str[0]) - 2 if Card_str[1] == "s": index_2 = 0 elif Card_str[1] == "c": index_2 = 1 elif Card_str[1] == "h": index_2 = 2 else: index_2 = 3 new_card_array = np.zeros((4, 13)) new_card_array[index_2][index_1] = 1 all_card_array[index_2][index_1] = 1 return new_card_array, all_card_array def betting(model1_player, model2_player, flop1_array, flop2_array, flop3_array, turn_array, river_array, Card1_array_player1, Card2_array_player1, Card1_array_player2, Card2_array_player2, all_card_array_player1, all_card_array_player2, stage_initial_potsize): pot_array_stage = convert_pot_to_numpy(stage_initial_potsize) state_array_player1 = np.stack( (flop1_array, flop2_array, flop3_array, turn_array, river_array, Card1_array_player1, Card2_array_player1, all_card_array_player1, pot_array_stage)) state_array_player1 = np.expand_dims(state_array_player1, 0) input_shape = [9, 17, 17] right_left_pad = input_shape[1] - state_array_player1.shape[2] left_pad = right_left_pad // 2 right_pad = left_pad + (right_left_pad % 2) top_bottom_pad = input_shape[2] - state_array_player1.shape[3] top_pad = top_bottom_pad // 2 bottom_pad = top_pad + (top_bottom_pad % 2) state_array_player1 = np.pad(state_array_player1, ((0, 0), (0, 0), (left_pad, right_pad), (top_pad, bottom_pad)), mode='constant') y_player1 = Model.predict(model1_player, x=state_array_player1) action_player1 = get_action(y_player1) if action_player1 == "Fold": return "Player 2", stage_initial_potsize, 0, 0, action_player1, "" elif action_player1 == "Check/Call": state_array_player2 = np.stack( (flop1_array, flop2_array, flop3_array, turn_array, river_array, Card1_array_player2, Card2_array_player2, all_card_array_player2, pot_array_stage)) state_array_player2 = np.expand_dims(state_array_player2, 0) right_left_pad = input_shape[1] - state_array_player2.shape[2] left_pad = right_left_pad // 2 right_pad = left_pad + (right_left_pad % 2) top_bottom_pad = input_shape[2] - state_array_player2.shape[3] top_pad = top_bottom_pad // 2 bottom_pad = top_pad + (top_bottom_pad % 2) state_array_player2 = np.pad(state_array_player2, ((0, 0), (0, 0), (left_pad, right_pad), (top_pad, bottom_pad)), mode='constant') y_player2 = Model.predict(model2_player, x=state_array_player2) action_player2 = get_action(y_player2) if action_player2 == "Fold": return "Player 1", stage_initial_potsize, 0, 0, action_player1, action_player2 elif action_player2 == "Check/Call": return "", stage_initial_potsize, 0, 0, action_player1, action_player2 else: stage_initial_potsize += 100 pot_array_stage = convert_pot_to_numpy( stage_initial_potsize) state_array_player1 = np.stack( (flop1_array, flop2_array, flop3_array, turn_array, river_array, Card1_array_player1, Card2_array_player1, all_card_array_player1, pot_array_stage)) state_array_player1 = np.expand_dims( state_array_player1, 0) right_left_pad = input_shape[ 1] - state_array_player1.shape[2] left_pad = right_left_pad // 2 right_pad = left_pad + (right_left_pad % 2) top_bottom_pad = input_shape[ 2] - state_array_player1.shape[3] top_pad = top_bottom_pad // 2 bottom_pad = top_pad + (top_bottom_pad % 2) state_array_player1 = np.pad(state_array_player1, ((0, 0), (0, 0), (left_pad, right_pad), (top_pad, bottom_pad)), mode='constant') y_player1 = Model.predict(model1_player, x=state_array_player1) action_player1 = get_action_position2(y_player1, "Bet") if action_player1 == "Fold": return "Player 2", stage_initial_potsize, 0, 100, action_player1, action_player2 else: return "", stage_initial_potsize + 100, 100, 100, action_player1, action_player2 else: stage_initial_potsize += 100 pot_array_stage = convert_pot_to_numpy(stage_initial_potsize) state_array_player2 = np.stack( (flop1_array, flop2_array, flop3_array, turn_array, river_array, Card1_array_player2, Card2_array_player2, all_card_array_player2, pot_array_stage)) state_array_player2 = np.expand_dims(state_array_player2, 0) right_left_pad = input_shape[1] - state_array_player2.shape[2] left_pad = right_left_pad // 2 right_pad = left_pad + (right_left_pad % 2) top_bottom_pad = input_shape[2] - state_array_player2.shape[3] top_pad = top_bottom_pad // 2 bottom_pad = top_pad + (top_bottom_pad % 2) state_array_player2 = np.pad(state_array_player2, ((0, 0), (0, 0), (left_pad, right_pad), (top_pad, bottom_pad)), mode='constant') y_player2 = Model.predict(model2_player, x=state_array_player2) # print(y_player2) action_player2 = get_action_position2(y_player2, "Bet") if action_player2 == "Fold": return "Player 1", stage_initial_potsize, 100, 0, action_player1, action_player2 else: return "", stage_initial_potsize + 100, 100, 100, action_player1, action_player2 model_player1 = model model_player2 = model player1_bet = 0 player2_bet = 0 total_pot_size = 0 all_card_array_player1 = np.zeros((4, 13)) all_card_array_player2 = np.zeros((4, 13)) flop1_array, all_card_array_player1, all_card_array_player2 = convert_to_numpy_array( Card.int_to_str(flop[0]), all_card_array_player1, all_card_array_player2) flop2_array, all_card_array_player1, all_card_array_player2 = convert_to_numpy_array( Card.int_to_str(flop[1]), all_card_array_player1, all_card_array_player2) flop3_array, all_card_array_player1, all_card_array_player2 = convert_to_numpy_array( Card.int_to_str(flop[2]), all_card_array_player1, all_card_array_player2) turn_array = np.zeros((4, 13)) river_array = np.zeros((4, 13)) Card6_array_player1, all_card_array_player1 = convert_to_numpy_array_playercards( Card.int_to_str(player1_hand[0]), all_card_array_player1) Card7_array_player1, all_card_array_player1 = convert_to_numpy_array_playercards( Card.int_to_str(player1_hand[1]), all_card_array_player1) Card6_array_player2, all_card_array_player2 = convert_to_numpy_array_playercards( Card.int_to_str(player2_hand[0]), all_card_array_player2) Card7_array_player2, all_card_array_player2 = convert_to_numpy_array_playercards( Card.int_to_str(player2_hand[1]), all_card_array_player2) pot_array_stage1 = convert_pot_to_numpy(total_pot_size) state_array_player1_stage1 = np.stack( (flop1_array, flop2_array, flop3_array, turn_array, river_array, Card6_array_player1, Card7_array_player1, all_card_array_player1, pot_array_stage1)) hash_key_stage1 = pickle.dumps(state_array_player1_stage1) gain_loss_stage1 = np.zeros((3)) gain_loss_stage1_count = np.zeros((3)) winner, pot_size, player1_new_bet, player2_new_bet, player1_action_stage1, player2_action = betting( model_player1, model_player2, flop1_array, flop2_array, flop3_array, turn_array, river_array, Card6_array_player1, Card7_array_player1, Card6_array_player2, Card7_array_player2, all_card_array_player1, all_card_array_player2, total_pot_size) total_pot_size += pot_size player1_bet += player1_new_bet player2_bet += player2_new_bet if winner == "Player 1": # print("Player 1 Wins!!",total_pot_size) # print("Player 1 Gain!!",int(total_pot_size-player1_bet)) if player1_action_stage1 == "Bet": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][2] += int(total_pot_size - player1_bet) reward_count[hash_key_stage1][2] += 1 else: gain_loss_stage1[2] += int(total_pot_size - player1_bet) gain_loss_stage1_count[2] += 1 elif player1_action_stage1 == "Check/Call": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][1] += int(total_pot_size - player1_bet) reward_count[hash_key_stage1][1] += 1 else: gain_loss_stage1[1] += int(total_pot_size - player1_bet) gain_loss_stage1_count[1] += 1 elif winner == "Player 2": # print("Player 2 Wins!!",total_pot_size) # print("Player 2 Gain!!",int(total_pot_size-player2_bet)) if player1_action_stage1 == "Fold": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][0] = -1 * int(player1_bet) reward_count[hash_key_stage1][0] += 1 else: gain_loss_stage1[0] = -1 * int(player1_bet) gain_loss_stage1_count[0] = 1 else: turn_array, all_card_array_player1, all_card_array_player2 = convert_to_numpy_array( Card.int_to_str(turn), all_card_array_player1, all_card_array_player2) pot_array_stage2 = convert_pot_to_numpy(total_pot_size) state_array_player1_stage2 = np.stack( (flop1_array, flop2_array, flop3_array, turn_array, river_array, Card6_array_player1, Card7_array_player1, all_card_array_player1, pot_array_stage2)) hash_key_stage2 = pickle.dumps(state_array_player1_stage2) gain_loss_stage2 = np.zeros((3)) gain_loss_stage2_count = np.zeros((3)) winner, pot_size, player1_new_bet, player2_new_bet, player1_action_stage2, player2_action = betting( model_player1, model_player2, flop1_array, flop2_array, flop3_array, turn_array, river_array, Card6_array_player1, Card7_array_player1, Card6_array_player2, Card7_array_player2, all_card_array_player1, all_card_array_player2, total_pot_size) total_pot_size += pot_size player1_bet += player1_new_bet player2_bet += player2_new_bet if winner == "Player 1": # print("Player 1 Wins!!", total_pot_size) # print("Player 1 Gain!!", int(total_pot_size - player1_bet)) if player1_action_stage2 == "Bet": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][2] += int( total_pot_size - player1_bet) reward_count[hash_key_stage2][2] += 1 else: gain_loss_stage2[2] = int(total_pot_size - player1_bet) gain_loss_stage2_count[2] = 1 elif player1_action_stage2 == "Check/Call": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][1] += int( total_pot_size - player1_bet) reward_count[hash_key_stage2][1] += 1 else: gain_loss_stage2[1] = int(total_pot_size - player1_bet) gain_loss_stage2_count[1] = 1 if player1_action_stage1 == "Bet": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][2] += int( total_pot_size - player1_bet) reward_count[hash_key_stage1][2] += 1 else: gain_loss_stage1[2] = int(total_pot_size - player1_bet) gain_loss_stage1_count[2] = 1 elif player1_action_stage1 == "Check/Call": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][1] += int( total_pot_size - player1_bet) reward_count[hash_key_stage1][1] += 1 else: gain_loss_stage1[1] = int(total_pot_size - player1_bet) gain_loss_stage1_count[1] = 1 elif winner == "Player 2": # print("Player 2 Wins!!", total_pot_size) # print("Player 2 Gain!!", int(total_pot_size - player2_bet)) if player1_action_stage2 == "Fold": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][0] = -1 * int( player1_bet) reward_count[hash_key_stage2][0] += 1 else: gain_loss_stage2[0] = -1 * int(player1_bet) gain_loss_stage2_count[0] += 1 if player1_action_stage1 == "Bet": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][2] += -1 * int( player1_bet) reward_count[hash_key_stage1][2] += 1 else: gain_loss_stage1[2] = -1 * int(player1_bet) gain_loss_stage1_count[2] = 1 elif player1_action_stage1 == "Check/Call": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][1] += -1 * int( player1_bet) reward_count[hash_key_stage1][1] += 1 else: gain_loss_stage1[1] = -1 * int(player1_bet) gain_loss_stage1_count[1] = 1 else: river_array, all_card_array_player1, all_card_array_player2 = convert_to_numpy_array( Card.int_to_str(river), all_card_array_player1, all_card_array_player2) winner, pot_size, player1_new_bet, player2_new_bet, player1_action_stage3, player2_action = betting( model_player1, model_player2, flop1_array, flop2_array, flop3_array, turn_array, river_array, Card6_array_player1, Card7_array_player1, Card6_array_player2, Card7_array_player2, all_card_array_player1, all_card_array_player2, total_pot_size) pot_array_stage3 = convert_pot_to_numpy(total_pot_size) state_array_player1_stage3 = np.stack( (flop1_array, flop2_array, flop3_array, turn_array, river_array, Card6_array_player1, Card7_array_player1, all_card_array_player1, pot_array_stage3)) hash_key_stage3 = pickle.dumps(state_array_player1_stage3) gain_loss_stage3 = np.zeros((3)) gain_loss_stage3_count = np.zeros((3)) total_pot_size += pot_size player1_bet += player1_new_bet player2_bet += player2_new_bet if winner == "Player 1": # print("Player 1 Wins!!", total_pot_size) # print("Player 1 Gain!!", int(total_pot_size - player1_bet)) if player1_action_stage3 == "Bet": if hash_key_stage3 in reward_table.keys(): reward_table[hash_key_stage3][2] += int( total_pot_size - player1_bet) reward_count[hash_key_stage3][2] += 1 else: gain_loss_stage3[2] = int(total_pot_size - player1_bet) gain_loss_stage3_count[2] = 1 elif player1_action_stage3 == "Check/Call": if hash_key_stage3 in reward_table.keys(): reward_table[hash_key_stage3][1] += int( total_pot_size - player1_bet) reward_count[hash_key_stage3][1] += 1 else: gain_loss_stage3[1] = int(total_pot_size - player1_bet) gain_loss_stage3_count[1] = 1 if player1_action_stage1 == "Bet": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][2] += int( total_pot_size - player1_bet) reward_count[hash_key_stage1][2] += 1 else: gain_loss_stage1[2] = int(total_pot_size - player1_bet) gain_loss_stage1_count[2] = 1 elif player1_action_stage1 == "Check/Call": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][1] += int( total_pot_size - player1_bet) reward_count[hash_key_stage1][1] += 1 else: gain_loss_stage1[1] = int(total_pot_size - player1_bet) gain_loss_stage1_count[1] = 1 if player1_action_stage2 == "Bet": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][2] += int( total_pot_size - player1_bet) reward_count[hash_key_stage2][2] += 1 else: gain_loss_stage2[2] = int(total_pot_size - player1_bet) gain_loss_stage2_count[2] = 1 elif player1_action_stage2 == "Check/Call": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][1] += int( total_pot_size - player1_bet) reward_count[hash_key_stage2][1] += 1 else: gain_loss_stage2[1] = int(total_pot_size - player1_bet) gain_loss_stage2_count[1] = 1 elif winner == "Player 2": # print("Player 2 Wins!!", total_pot_size) # print("Player 2 Gain!!", int(total_pot_size - player2_bet)) if player1_action_stage3 == "Fold": if hash_key_stage3 in reward_table.keys(): reward_table[hash_key_stage3][0] = -1 * int( player1_bet) reward_count[hash_key_stage3][0] += 1 else: gain_loss_stage3[0] = -1 * int(player1_bet) gain_loss_stage3_count[0] += 1 if player1_action_stage1 == "Bet": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][2] += -1 * int( player1_bet) reward_count[hash_key_stage1][2] += 1 else: gain_loss_stage1[2] = -1 * int(player1_bet) gain_loss_stage1_count[2] = 1 elif player1_action_stage1 == "Check/Call": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][1] += -1 * int( player1_bet) reward_count[hash_key_stage1][1] += 1 else: gain_loss_stage1[1] = -1 * int(player1_bet) gain_loss_stage1_count[1] = 1 if player1_action_stage2 == "Bet": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][2] += -1 * int( player1_bet) reward_count[hash_key_stage2][2] += 1 else: gain_loss_stage2[2] = -1 * int(player1_bet) gain_loss_stage2_count[2] = 1 elif player1_action_stage2 == "Check/Call": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][1] += -1 * int( player1_bet) reward_count[hash_key_stage2][1] += 1 else: gain_loss_stage2[1] = -1 * int(player1_bet) gain_loss_stage2_count[1] = 1 else: final_score_player1 = evaluator.get_rank_class( evaluator._seven(player1_complete_hand)) final_score_player2 = evaluator.get_rank_class( evaluator._seven(player2_complete_hand)) if final_score_player1 < final_score_player2: # print("Player 1 Wins!!",total_pot_size) # print("Player 1 Gain!!",int(total_pot_size - player1_bet)) if player1_action_stage3 == "Bet": if hash_key_stage3 in reward_table.keys(): reward_table[hash_key_stage3][2] += int( total_pot_size - player1_bet) reward_count[hash_key_stage3][2] += 1 else: gain_loss_stage3[2] = int(total_pot_size - player1_bet) gain_loss_stage3_count[2] = 1 elif player1_action_stage3 == "Check/Call": if hash_key_stage3 in reward_table.keys(): reward_table[hash_key_stage3][1] += int( total_pot_size - player1_bet) reward_count[hash_key_stage3][1] += 1 else: gain_loss_stage3[1] = int(total_pot_size - player1_bet) gain_loss_stage3_count[1] = 1 if player1_action_stage1 == "Bet": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][2] += int( total_pot_size - player1_bet) reward_count[hash_key_stage1][2] += 1 else: gain_loss_stage1[2] = int(total_pot_size - player1_bet) gain_loss_stage1_count[2] = 1 elif player1_action_stage1 == "Check/Call": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][1] += int( total_pot_size - player1_bet) reward_count[hash_key_stage1][1] += 1 else: gain_loss_stage1[1] = int(total_pot_size - player1_bet) gain_loss_stage1_count[1] = 1 if player1_action_stage2 == "Bet": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][2] += int( total_pot_size - player1_bet) reward_count[hash_key_stage2][2] += 1 else: gain_loss_stage2[2] = int(total_pot_size - player1_bet) gain_loss_stage2_count[2] = 1 elif player1_action_stage2 == "Check/Call": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][1] += int( total_pot_size - player1_bet) reward_count[hash_key_stage2][1] += 1 else: gain_loss_stage2[1] = int(total_pot_size - player1_bet) gain_loss_stage2_count[1] = 1 else: # print("Player 2 Wins!!",total_pot_size) # print("Player 2 Gain!!",int(total_pot_size-player2_bet)) # print("Player 2 Wins!!", total_pot_size) # print("Player 2 Gain!!", int(total_pot_size - player2_bet)) if player1_action_stage3 == "Fold": if hash_key_stage3 in reward_table.keys(): reward_table[hash_key_stage3][0] = -1 * int( player1_bet) reward_count[hash_key_stage3][0] += 1 else: gain_loss_stage3[0] = -1 * int(player1_bet) gain_loss_stage3_count[0] += 1 if player1_action_stage1 == "Bet": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][2] += -1 * int( player1_bet) reward_count[hash_key_stage1][2] += 1 else: gain_loss_stage1[2] = -1 * int(player1_bet) gain_loss_stage1_count[2] = 1 elif player1_action_stage1 == "Check/Call": if hash_key_stage1 in reward_table.keys(): reward_table[hash_key_stage1][1] += -1 * int( player1_bet) reward_count[hash_key_stage1][1] += 1 else: gain_loss_stage1[1] = -1 * int(player1_bet) gain_loss_stage1_count[1] = 1 if player1_action_stage2 == "Bet": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][2] += -1 * int( player1_bet) reward_count[hash_key_stage2][2] += 1 else: gain_loss_stage2[2] = -1 * int(player1_bet) gain_loss_stage2_count[2] = 1 elif player1_action_stage2 == "Check/Call": if hash_key_stage2 in reward_table.keys(): reward_table[hash_key_stage2][1] += -1 * int( player1_bet) reward_count[hash_key_stage2][1] += 1 else: gain_loss_stage2[1] = -1 * int(player1_bet) gain_loss_stage2_count[1] = 1 if hash_key_stage3 not in reward_table.keys(): reward_table[hash_key_stage3] = gain_loss_stage3 reward_count[hash_key_stage3] = gain_loss_stage3_count if hash_key_stage2 not in reward_table.keys(): reward_table[hash_key_stage2] = gain_loss_stage2 reward_count[hash_key_stage2] = gain_loss_stage2_count if hash_key_stage1 not in reward_table.keys(): reward_table[hash_key_stage1] = gain_loss_stage1 reward_count[hash_key_stage1] = gain_loss_stage1_count round_number += 1 print_progress(round_number, rounds, prefix='Progress:', suffix='Complete', bar_length=40) for key in reward_table.keys(): count_fold = reward_count[key][0] count_check = reward_count[key][1] count_bet = reward_count[key][2] if count_fold != 0: reward_table[key][0] = reward_table[key][0] / count_fold if count_check != 0: reward_table[key][1] = reward_table[key][1] / count_check if count_bet != 0: reward_table[key][2] = reward_table[key][2] / count_bet return reward_table
async def bet_to_close(web_client, user_id, channel_id, bet): active_players = player_list[channel_id] tab = tab_list[channel_id]["table"] deck = tab_list[channel_id]["deck"] if bet == tab.highbet: print("betwixt") tab.pot += bet active_players[0].money = active_players[0].money - bet print(active_players[0].money, "active") print(active_players[1].money, "notactive") if tab.turn == 0: print("stage5") tabcards = Card.print_pretty_cards(tab.cards) await sendslack( "<@%s> calls. dealing flop:" % user_id, web_client, channel_id ) await sendslack(tabcards, web_client, channel_id) if active_players[0].dealer: active_players += [active_players.pop(0)] await sendslack( "<@%s> is next to act" % active_players[0].name, web_client, channel_id ) await sendslack("pot is %s" % tab.pot, web_client, channel_id) for name in active_players: name.bet = 0 name.tocall = 0 name.reraise = 0 tab.turn += 1 tab.highbet = 0 active_players[0].canclose = False active_players[1].canclose = True elif tab.turn == 1: print("stage6") tab.cards.append(deck.draw(1)) print(tab_list[channel_id]["table"].cards) tabcards = Card.print_pretty_cards(tab.cards) await sendslack( "<@%s> calls. dealing turn:" % user_id, web_client, channel_id ) await sendslack(tabcards, web_client, channel_id) if active_players[0].dealer: active_players += [active_players.pop(0)] await sendslack( "<@%s> is next to act" % active_players[0].name, web_client, channel_id ) await sendslack("pot is %s" % tab.pot, web_client, channel_id) for name in active_players: name.bet = 0 name.tocall = 0 name.reraise = 0 tab.turn += 1 tab.highbet = 0 active_players[0].canclose = False active_players[1].canclose = True elif tab.turn == 2: print("stage7") tab.cards.append(deck.draw(1)) print(tab.cards) tabcards = Card.print_pretty_cards(tab.cards) await sendslack( "<@%s> calls. dealing river:" % user_id, web_client, channel_id ) await sendslack(tabcards, web_client, channel_id) if active_players[0].dealer: active_players += [active_players.pop(0)] await sendslack( "<@%s> is next to act" % active_players[0].name, web_client, channel_id ) await sendslack("pot is %s" % tab.pot, web_client, channel_id) for name in active_players: name.bet = 0 name.tocall = 0 name.reraise = 0 tab.turn += 1 tab.highbet = 0 active_players[0].canclose = False active_players[1].canclose = True elif tab.turn == 3: await sendslack("<@%s> calls." % user_id, web_client, channel_id) tabcards = Card.print_pretty_cards(tab.cards) await sendslack(tabcards, web_client, channel_id) if tab.plo == True: await calculate_plo(web_client, user_id, channel_id) else: # players = player_list[channel_id] evaluator = Evaluator() scores = {} for p in active_players: pic = Card.print_pretty_cards(p.cards) await sendslack( "<@%s> has %s" % (p.name, pic), web_client, channel_id ) scores[evaluator.evaluate(tab.cards, p.cards)] = p p.cards = [] d = OrderedDict(sorted(scores.items(), key=lambda t: t[0])) items = list(d.items()) for i in items: print(i, "herewith") p_score = i[0] p_class = evaluator.get_rank_class(p_score) hand = evaluator.class_to_string(p_class) await sendslack( "<@%s> has %s" % (i[1].name, hand), web_client, channel_id ) winner = [x for x in items if x[0] == items[0][0]] for p in winner: await sendslack( "<@%s> won and got %d" % (p[1].name, tab.pot), web_client, channel_id, ) for name in active_players: if name.name == p[1].name: name.money += tab.pot if len(active_players) == 2: if active_players[0].money != 0 and active_players[1].money != 0: if active_players[1].dealer: active_players += [active_players.pop(0)] tab.cards.clear() tab.turn = 0 tab.highbet = 0 tab.pot = 0 for name in active_players: name.cards.clear() name.tocall = 0 name.dealer = False name.bet = 0 name.reraise = 0 name.canclose = False await set_up_game(web_client, channel_id)
class HandEvaluation(Player): preflop_opprank_control = 5 preflop_evaluation_mean_control = 100 def __init__(self, cards, playerID, event, evaluation=None): self.evaluator = Evaluator() self.hand = cards self.create_cards_for_game( ) # Remaining cards after dealt two hole cards to this player. 15/02: This is updated after he in instantiated self.make_combinations( ) # all possible card permuations (1326) used to describe opponents range self.official_board = [] self.summary = None self.evaluation = None self.rc = None self.score_desc = None self.hand_strength = None self.event = event self.playerID = playerID # player name self.flop_cards, self.turn_card, self.river_card = None, None, None self.board = None # Fictional board # self.ew_score = None def make_combinations(self): self._combinations = list(combinations(self.deck_of_cards, 2)) # for combo in _combinations: # combo = self.parse_cards(combo[0], combo[1]) def parse_cards(self, a, b): a_rank, a_suit = a b_rank, b_suit = b a_card = Card.new(str(a_rank) + str(a_suit)) b_card = Card.new(str(b_rank) + str(b_suit)) return [a_card, b_card] def from_num_to_cardstring(self, my_card): deck_size = 52 suits = ['h', 'c', 's', 'd'] card_a_suit = '' card_a_rank = '' a, b = ('', '') for card in self.deck_of_cards: ## all cards in game if (str(self.deck_of_cards.index(card)) == my_card): if (len(card) == 2): a, b = card break card_a_rank = a card_a_suit = b return str(a + b) def set_community_cards(self, board, _round): i = 0 while i < (len(board)): if (board[i] == -1): del board[i] else: i = i + 1 if not (all([card is -1 for card in board])): self.board = board def take(self, num_take): import random cards_return_user = [] for num in range(num_take): c = random.choice(self.deck_of_cards) while c in cards_return_user: c = random.choice(self.deck_of_cards) cards_return_user.append(c) return cards_return_user def random_board(self, hand, with_full_deck): deck = self.deck_of_cards b = self.take(3) while (self.is_duplicates(b, hand)): b = self.take(3) b = [Card.new(b[0]), Card.new(b[1]), Card.new(b[2])] return b def setup_random_board(self, hand=None): b = [] if self.board is None: #PREFLOP b = self.random_board(hand, with_full_deck=False) return b def shares_duplicate(self, cardA, cardB, check_this): if cardA in check_this or cardB in check_this: return True else: return False def is_duplicates(self, board, hand): duplicate = False for card_b in board: for card_h in hand: if card_b == card_h: duplicate = True return duplicate ## TODO: May need to modify handstrength to use 1036 * 2 in the case of having 2 opponents def handStrength(self, event): ahead, tied, behind = 0, 0, 0 a, b, random_board, ourRank, oppRank = None, None, None, None, None count_none_debug = 0 # Consider all two card combinations of remaining cards for potential_opp_cards in (self._combinations * (Player.total_plrs - 1)): a, b = Card.new(potential_opp_cards[0]), Card.new( potential_opp_cards[1]) if self.shares_duplicate(a, b, self.hand): continue if event is "Preflop": oppRank = self.do_mean_evaluation( [a, b], event, n=self.preflop_opprank_control) else: need_skip = False while need_skip is False: if (self.shares_duplicate(a, b, self.board)): need_skip = True break if need_skip: continue oppRank = self.evaluator.evaluate(self.board, [a, b]) if (oppRank is None): continue count_none_debug += 1 elif ( self.evaluation < oppRank ): # Note: With treys evaluation, lower number means better hand ahead = ahead + 1 elif self.evaluation == oppRank: tied = tied + 1 else: behind = behind + 1 hand_strength = (ahead + tied / 2) / (ahead + tied + behind) return hand_strength def set_evaluation(self, value): self.evaluation = value def evaluate(self, event): if event == 'Preflop': self.set_evaluation( self.do_mean_evaluation( self.hand, event, n=self.preflop_evaluation_mean_control)) self.hand_strength = ((1 - self.evaluation / 7462) * 2) if ( (1 - self.evaluation / 7462) * 2) < 1.0 else 1.0 # self.hand_strength = self.handStrength(event) # self.detect_draws() else: # self.detect_draws() self.set_evaluation(self.evaluator.evaluate(self.board, self.hand)) self.hand_strength = self.handStrength( event ) # UPDATE 12/03: Only using handStrength for post-flop for the moment self.rc = self.rank_class(self.evaluation) self.score_desc = self.evaluator.class_to_string(self.rc) self.summary = self.hand_strength, self.evaluation, self.rc, self.score_desc, self.hand, self.board return self.summary def ew_parse(self, card_list, is_num=True): list_trey_to_st = [] if (is_num): for card in card_list: list_trey_to_st.append(Card.int_to_str(card)) list_st_to_ppe = [] for card_st in list_trey_to_st: list_st_to_ppe.append(card_st[1].upper() + card_st[0]) return list_st_to_ppe def do_mean_evaluation(self, hand, event, n): fictional_board = None evaluation = None total_sum_evals = 0 list_evaluations = [] for i in range(n): if event is "Preflop": fictional_board = self.setup_random_board( hand ) # fictional board used to evaluate 5-card set in treys evaluation function. hand is passed in to avoid duplicates in creating board while self.shares_duplicate(hand[0], hand[1], fictional_board): fictional_board = self.setup_random_board(hand) evaluation = self.evaluator.evaluate(fictional_board, hand) del fictional_board else: evaluation = self.evaluator.evaluate(self.board, hand) list_evaluations.append(evaluation) total_sum_evals = total_sum_evals + evaluation del evaluation mean = total_sum_evals / n which_eval = self.closest_to_mean(mean, list_evaluations) return which_eval def closest_to_mean(self, mean, list_evaluations): sdfm = {'eval': None, 'smallest_distance_from_mean': None} sdfm['smallest_distance_from_mean'] = 7462 for evaluation in list_evaluations: this_distance = abs(evaluation - mean) if (this_distance < sdfm['smallest_distance_from_mean']): sdfm['smallest_distance_from_mean'] = this_distance sdfm['eval'] = evaluation return sdfm['eval'] def board_join(self, a, b): l1 = [] l2 = [] for elem_a in a: l1.append(elem_a) l2.append(b) l3 = l1 + l2 return tuple(l3) def rank_class(self, evaluation): rc = self.evaluator.get_rank_class(evaluation) return rc def set_hand(self, hand): self.hand = hand def get_evaluation(self, event): return self.summary def create_cards_for_game(self): suits = ['h', 'c', 's', 'd'] li = [] for rank in range(13): for suit in suits: if (rank == 8): card_r = 'T' elif (rank == 9): card_r = 'J' elif (rank == 10): card_r = 'Q' elif (rank == 11): card_r = 'K' elif (rank == 12): card_r = 'A' else: card_r = str(rank + 2) card_str = card_r + suit if card_str != self.hand[0] and card_str != self.hand[1]: li.append(card_str) self.deck_of_cards = li
print(Card.print_pretty_cards(board)) print(Card.print_pretty_cards(p1)) print(Card.print_pretty_cards(p2)) print(Card.print_pretty_cards(p3)) print(Card.print_pretty_cards(p4)) print(Card.print_pretty_cards(p5)) evaluator = Evaluator() p1_score = evaluator.evaluate(board, p1) p2_score = evaluator.evaluate(board, p2) p3_score = evaluator.evaluate(board, p3) p4_score = evaluator.evaluate(board, p4) p5_score = evaluator.evaluate(board, p5) scores = [p1_score,p2_score,p3_score,p4_score,p5_score] p1_class = evaluator.get_rank_class(p1_score) p2_class = evaluator.get_rank_class(p2_score) p3_class = evaluator.get_rank_class(p3_score) p4_class = evaluator.get_rank_class(p4_score) p5_class = evaluator.get_rank_class(p5_score) classes = [p1_class,p2_class,p3_class,p4_class,p5_class] print(evaluator.class_to_string(p1_class)) print(evaluator.class_to_string(p2_class)) print(evaluator.class_to_string(p3_class)) print(evaluator.class_to_string(p4_class)) print(evaluator.class_to_string(p5_class)) print(p1_score) print(p2_score) print(p3_score)
def uruchom(self): sprawdz = Evaluator() rozp = 0 # indeks gracza rozpoczynajacego licytacje # główna pętla gry while True: print( "\n*******************************Kolejna runda*********************************" ) talia = Deck() # talia kart stol = poker.Stol(len(self.gracze)) zwyciezca = -1 # indeks zwycięzcy pas = -1 for g in self.gracze: g.reka = talia.draw(2) stol.karty = talia.draw(5) global_info = stol.doloz_stawke( self.gracze[rozp], self.ustawienia.ciemne) # początkowa stawka na 1. turę self.gracze[rozp].stan = poker.stan_gracza["postawil"] najwyzsza_stawka = self.ustawienia.ciemne print(global_info) # pętla 3 tur for tura in range(1, 4): print("\n\n**************Trwa tura %s****************" % str(tura)) print("\nObecnie w puli: ", stol.pula) poker.zresetuj_akcje( self.gracze ) # do czyszczenia akcji z poprz. tury poza pasów i ew. allinów if tura == 1: aktywny = poker.nastepny( rozp ) # aktywny to indeks gracza aktywnego (aktualnie decydującego) w licytacji else: # a nastepny() to przesunięcie iteratora na nast. gracza aktywny = rozp koniec = False # pętla pozwalająca wykonywać akcje graczy (jeden obrót to decyzja jednego gracza) while True: global_info = '' if self.gracze[aktywny].stan != poker.stan_gracza[ "va bank"]: # wyjątek pomijający graczy vabank # wypisywanie info global_info += "\n**************Teraz gracz %s***************" % ( aktywny + 1) global_info += stol.wypisz_karty_na_stole() global_info += '\n' + self.gracze[ aktywny].wypisz_karty_gracza() global_info += "\nNajwyższa stawka na stole: " + str( najwyzsza_stawka) global_info += "\nTwoja stawka: " + str( stol.stawki_graczy[aktywny]) global_info += "\nKapital: " + str( self.gracze[aktywny].kapital) print(global_info) # wczytanie akcji gracza, więcej w poker.py odp = poker.wczytaj_poprawna_odp( najwyzsza_stawka - stol.stawki_graczy[aktywny], self.gracze[aktywny].kapital, self.gracze[aktywny].podbicia) # wykonanie wybranej akcji global_info = poker.podejmij_akcje( self.gracze[aktywny], odp, stol) print(global_info) if najwyzsza_stawka < stol.stawki_graczy[aktywny]: najwyzsza_stawka = stol.stawki_graczy[ aktywny] # do info o najwyższej postawionej stawce # obsługa spasowania if self.gracze[aktywny].stan == poker.stan_gracza[ "spasowal"]: pas = poker.czy_wszyscy_spasowali(self.gracze) if pas != -1: koniec = True # obsługa opcji wylączenia gry if self.gracze[aktywny].stan == poker.stan_gracza[ "skonczyl"]: zwyciezca = poker.nastepny(aktywny) koniec = True if koniec: break # tu jest sprawdzenie czy wszyscy gracze już coś zrobili gdy stawki są sobie równe if poker.czy_koniec_tury(self.gracze, stol, najwyzsza_stawka): break aktywny = poker.nastepny(aktywny) # **********************************koniec pętli while()*************************************** # sprzątanie po skończonej turze stol.zbierz_do_puli() # wszystkie stawki idą do wspólnej puli if zwyciezca >= 0 or pas >= 0: break # gdy któryś z dwóch graczy spasował if poker.liczba_graczy_w_licytacji(self.gracze) <= 1: stol.odkryte = 5 break stol.odkryte += 1 najwyzsza_stawka = 0 # **********************koniec pętli z turami*************************************** if pas >= 0 and not poker.czy_ktos_allin( self.gracze): # gdy wszyscy spasowali print("\n***Zwyciezca rundy zostaje gracz %s!***" % (pas + 1)) self.gracze[pas].kapital += stol.pula stol.pula = 0 elif zwyciezca == -1: # tu nastąpi sprawdzanie kart print("\n****************Sprawdzenie kart*****************") stol.wypisz_karty_na_stole() wyniki = list() print() for g in self.gracze: g.wypisz_karty_gracza() wyniki.append(sprawdz.evaluate(stol.karty, g.reka)) print( "Wynik gracza %d: %s (%d)" % (g.id + 1, sprawdz.class_to_string( sprawdz.get_rank_class(wyniki[-1])), wyniki[-1])) global_info = poker.rozdaj_pule(self.gracze, stol, wyniki) print(global_info) # całkowity stan kapitału graczy print("\nStan kapitalu graczy: ") for g in self.gracze: print("Gracz %d: %d" % (g.id + 1, g.kapital)) if zwyciezca != -1: print("\n***Zwyciezca gry zostaje gracz %d, gratulacje!!!***" % (zwyciezca + 1)) print("\n") input("Nacisnij ENTER aby kontynuowac.") break else: # sprawdzenie czy komuś się pieniądze skończyły zwyciezca = -1 if self.gracze[0].kapital == 0: zwyciezca = 2 elif self.gracze[1].kapital == 0: zwyciezca = 1 if zwyciezca != -1: print( "\n***Zwyciezca gry zostaje gracz %d, gratulacje!!!***" % (zwyciezca + 1)) print("\n") input("Nacisnij ENTER aby kontynuowac.") break input("\nNacisnij ENTER aby kontynuowac.") rozp = poker.nastepny(rozp, len(self.gracze)) poker.zresetuj_akcje(self.gracze, do_poczatku=True) return
def run(self): conn, addr = mySocket.accept() print(">>Polaczenie od: " + str(addr)) global_info = "\n\nGra Texas Hold'em Poker sterowany głosowo dla 2 graczy. Zapraszamy do gry!" print(global_info) conn.send(global_info.encode()) # conn.recv(1024) ustawienia = UstawieniaGry(2) gracze = list() for i in range(0, ustawienia.liczba_graczy): gracze.append(poker.Gracz(i)) sprawdz = Evaluator() rozp = 0 # 0 - idx gracza na serwerze # 1 - idx klienta # główna pętla gry while True: global_info = "\n*******************************Kolejna runda*********************************" talia = Deck() # talia kart stol = poker.Stol(len(gracze)) zwyciezca = -1 # indeks zwycięzcy pas = -1 for g in gracze: g.reka = talia.draw(2) stol.karty = talia.draw(5) global_info += '\n' + str( stol.doloz_stawke( gracze[rozp], ustawienia.ciemne)) # początkowa stawka na 1. turę gracze[rozp].stan = poker.stan_gracza["postawil"] najwyzsza_stawka = ustawienia.ciemne print(global_info) conn.send(pickle.dumps(poker.PaczkaDoKlienta(global_info))) # pętla 3 tur for tura in range(1, 4): global_info = "\n\n**************Trwa tura %s****************" % str( tura) global_info += "\n\nObecnie w puli: " + str(stol.pula) poker.zresetuj_akcje( gracze ) # do czyszczenia akcji z poprz. tury poza pasów i ew. allinów if tura == 1: aktywny = poker.nastepny( rozp ) # aktywny to indeks gracza aktywnego (aktualnie decydującego) w licytacji else: # a nastepny() to przesunięcie iteratora na nast. gracza aktywny = rozp koniec = False print(global_info) conn.send(pickle.dumps(poker.PaczkaDoKlienta(global_info))) # pętla pozwalająca wykonywać akcje graczy (jeden obrót to decyzja jednego gracza) while True: global_info = '' if gracze[aktywny].stan != poker.stan_gracza[ "va bank"]: # wyjątek pomijający graczy vabank # wypisywanie info global_info += "\n**************Teraz gracz %s***************" % ( aktywny + 1) global_info += stol.wypisz_karty_na_stole() global_info += '\n' + gracze[ aktywny].wypisz_karty_gracza() global_info += "\nNajwyższa stawka na stole: " + str( najwyzsza_stawka) global_info += "\nTwoja stawka: " + str( stol.stawki_graczy[aktywny]) global_info += "\nKapital: " + str( gracze[aktywny].kapital) if aktywny == 0: print(global_info) # wczytanie akcji gracza, więcej w poker.py odp = poker.wczytaj_poprawna_odp( najwyzsza_stawka - stol.stawki_graczy[aktywny], gracze[aktywny].kapital, gracze[aktywny].podbicia) else: conn.send( pickle.dumps( poker.PaczkaDoKlienta( stol=global_info, min=najwyzsza_stawka - stol.stawki_graczy[aktywny], maks=gracze[aktywny].kapital, podbicia=gracze[aktywny].podbicia, odp=True))) odp = conn.recv(1024) if odp: odp = pickle.loads(odp).odpowiedz else: print('\nUtracono polaczenie z klientem.') conn.close() return # wykonanie wybranej akcji global_info = poker.podejmij_akcje( gracze[aktywny], odp, stol) print(global_info) conn.send( pickle.dumps( poker.PaczkaDoKlienta(akcja=global_info))) if najwyzsza_stawka < stol.stawki_graczy[aktywny]: najwyzsza_stawka = stol.stawki_graczy[ aktywny] # do info o najwyższej postawionej stawce # obsługa spasowania if gracze[aktywny].stan == poker.stan_gracza["spasowal"]: pas = poker.czy_wszyscy_spasowali(gracze) if pas != -1: koniec = True # obsługa opcji wylączenia gry if gracze[aktywny].stan == poker.stan_gracza["skonczyl"]: zwyciezca = poker.nastepny(aktywny) koniec = True if koniec: break # tu jest sprawdzenie czy wszyscy gracze już coś zrobili gdy stawki są sobie równe if poker.czy_koniec_tury(gracze, stol, najwyzsza_stawka): break aktywny = poker.nastepny(aktywny) # **********************************koniec pętli while()*************************************** # sprzątanie po skończonej turze stol.zbierz_do_puli() # wszystkie stawki idą do wspólnej puli if zwyciezca >= 0 or pas >= 0: break # gdy któryś z dwóch graczy spasował if poker.liczba_graczy_w_licytacji(gracze) <= 1: stol.odkryte = 5 break stol.odkryte += 1 najwyzsza_stawka = 0 # **********************koniec pętli z turami*************************************** global_info = '' if pas >= 0 and not poker.czy_ktos_allin( gracze): # gdy wszyscy spasowali global_info = "\n***Zwyciezca rundy zostaje gracz %s!***" % ( pas + 1) gracze[pas].kapital += stol.pula stol.pula = 0 elif zwyciezca == -1: # tu nastąpi sprawdzanie kart global_info = "\n****************Sprawdzenie kart*****************\n" global_info += stol.wypisz_karty_na_stole() + '\n' for g in gracze: global_info += g.wypisz_karty_gracza() wyniki = list() global_info += '\n' for g in gracze: wyniki.append(sprawdz.evaluate(stol.karty, g.reka)) global_info += "\nWynik gracza %d: %s (%d)" \ % (g.id + 1, sprawdz.class_to_string(sprawdz.get_rank_class(wyniki[-1])), wyniki[-1]) global_info += poker.rozdaj_pule(gracze, stol, wyniki) # całkowity stan kapitału graczy global_info += "\n\nStan kapitalu graczy: " for g in gracze: global_info += "\nGracz %d: %d" % (g.id + 1, g.kapital) if zwyciezca == -1: # sprawdzenie czy komuś się pieniądze skończyły zwyciezca = -1 if gracze[0].kapital == 0: zwyciezca = 1 elif gracze[1].kapital == 0: zwyciezca = 0 if zwyciezca != -1: global_info += "\n\n***Zwyciezca gry zostaje gracz %d, gratulacje!!!***" % ( zwyciezca + 1) print(global_info) conn.send(pickle.dumps(poker.PaczkaDoKlienta(global_info))) input("\nNacisnij ENTER aby kontynuowac.") break print(global_info) conn.send(pickle.dumps(poker.PaczkaDoKlienta(global_info))) input("\nNacisnij ENTER aby kontynuowac.") rozp = poker.nastepny(rozp, len(gracze)) poker.zresetuj_akcje(gracze, do_poczatku=True) conn.send( pickle.dumps( poker.PaczkaDoKlienta('\nSerwer zakonczyl polaczenie.'))) conn.close() global koniec_polaczenia koniec_polaczenia = True print('>>Zakonczono dzialanie gry.') return
pot_array_stage3 = convert_pot_to_numpy(total_pot_size) state_array_player1_stage3 = np.stack( (flop1_array, flop2_array, flop3_array, turn_array, river_array, Card6_array_player1, Card7_array_player1, all_card_array_player1, pot_array_stage3)) total_pot_size += pot_size player1_bet += player1_new_bet player2_bet += player2_new_bet if winner == "Player 1": print("Player 1 Wins!!", total_pot_size) print("Player 1 Gain!!", int(total_pot_size - player1_bet)) elif winner == "Player 2": print("Player 2 Wins!!", total_pot_size) print("Player 2 Gain!!", int(total_pot_size - player2_bet)) else: final_score_player1 = evaluator.get_rank_class( evaluator._seven(player1_complete_hand)) final_score_player2 = evaluator.get_rank_class( evaluator._seven(player2_complete_hand)) if final_score_player1 < final_score_player2: print("Player 1 Wins!!", total_pot_size) print("Player 1 Gain!!", int(total_pot_size - player1_bet)) else: print("Player 2 Wins!!", total_pot_size) print("Player 2 Gain!!", int(total_pot_size - player2_bet))
class Table: def __init__(self, n_players, agents, seed, stack_low=50, stack_high=200, hand_history_location='hands/', invalid_action_penalty=-5): self.hand_history_location = hand_history_location self.hand_history_enabled = False self.stack_low = stack_low self.stack_high = stack_high self.rng = np.random.default_rng(seed) self.n_players = n_players self.pot = 0 self.bet_to_match = 0 self.minimum_raise = 0 self.street = GameState.PREFLOP self.cards = [] self.deck = Deck() self.players = [Player(n+1, agents[n], 'player_%d' % n, invalid_action_penalty) for n in range(n_players)] self.active_players = n_players self.evaluator = Evaluator() self.history = [] def seed(self, seed): self.rng = np.random.default_rng(seed) def reset(self): self.pot = 0 self.street = GameState.PREFLOP self.cards = [] self.deck.cards = Deck.GetFullDeck() self.rng.shuffle(self.deck.cards) self.rng.shuffle(self.players) self.active_players = self.n_players initial_draw = self.deck.draw(self.n_players * 2) for i, player in enumerate(self.players): player.reset() player.position = i player.cards = [initial_draw[i], initial_draw[i+self.n_players]] player.stack = self.rng.integers(self.stack_low, self.stack_high, 1)[0] self.bet_to_match = 0 self.history = [] def play_hand(self): if self.hand_history_enabled: self._history_initialize() blinds_collected = False hand_is_over = False for street in GameState: street_finished = False last_bet_placed_by = None self.street = street self.bet_to_match = 0 self.minimum_raise = 0 for player in self.players: player.finish_street() if street == GameState.FLOP: self.cards = self.deck.draw(3) self._write_event("*** FLOP *** [%s %s %s]" % (Card.int_to_str(self.cards[0]), Card.int_to_str(self.cards[1]), Card.int_to_str(self.cards[2]))) if street == GameState.TURN: new = self.deck.draw(1) self.cards.append(new) self._write_event("*** TURN *** [%s %s %s] [%s]" % (Card.int_to_str(self.cards[0]), Card.int_to_str(self.cards[1]), Card.int_to_str(self.cards[2]), Card.int_to_str(self.cards[3]))) if street == GameState.RIVER: new = self.deck.draw(1) self.cards.append(new) self._write_event("*** RIVER *** [%s %s %s %s] [%s]" % (Card.int_to_str(self.cards[0]), Card.int_to_str(self.cards[1]), Card.int_to_str(self.cards[2]), Card.int_to_str(self.cards[3]), Card.int_to_str(self.cards[4]))) while not street_finished and not hand_is_over: for player in self.players: if player.all_in or player.state is not PlayerState.ACTIVE: continue if street == GameState.PREFLOP and not blinds_collected: if player.position == TablePosition.SB: self.pot += player.bet(0.5) self._change_bet_to_match(0.5) self._write_event("%s: posts small blind $%.2f" % (player.name, SB)) continue elif player.position == TablePosition.BB: self.pot += player.bet(1) self._change_bet_to_match(1) last_bet_placed_by = player blinds_collected = True self._write_event("%s: posts big blind $%.2f" % (player.name, BB)) if self.hand_history_enabled: self._write_hole_cards() continue have_actions = [p for p in self.players if p.state is PlayerState.ACTIVE if not p.all_in] if len(have_actions) < 2: amount = 0 # Everone else is all in or folded if self.active_players > 1: street_finished = True biggest_match = max([p.bet_this_street for p in self.players if p.state is PlayerState.ACTIVE if p is not player]) if biggest_match < player.bet_this_street: amount = player.bet_this_street - biggest_match # Everone else has folded else: hand_is_over = True amount = self.minimum_raise if amount > 0: self.pot -= amount player.stack += amount player.money_in_pot -= amount player.bet_this_street -= amount self._write_event( "Uncalled bet ($%.2f) returned to %s" % (amount * BB, player.name) ) break # If no one has raised after a bet, the betting round is over if last_bet_placed_by is player: street_finished = True break observation = self._get_observation(player) valid_actions = self._get_valid_actions(player) action = player.step(observation, valid_actions) # If action is not valid, a valid action (check or fold) is automatically taken in _is_action_valid if not self._is_action_valid(player, action, valid_actions): player.punish_invalid_action() continue if action.action_type is PlayerAction.FOLD: player.fold() self.active_players -= 1 self._write_event("%s: folds" % player.name) elif action.action_type is PlayerAction.CHECK: player.check() self._write_event("%s: checks" % player.name) elif action.action_type is PlayerAction.CALL: call_size = player.call(self.bet_to_match) self.pot += call_size if player.all_in: self._write_event("%s: calls $%.2f and is all-in" % (player.name, call_size*BB)) else: self._write_event("%s: calls $%.2f" % (player.name, call_size*BB)) elif action.action_type is PlayerAction.BET: previous_bet_this_street = player.bet_this_street actual_bet_size = player.bet(np.round(action.bet_amount, 2)) self.pot += actual_bet_size if self.bet_to_match == 0: if player.all_in: self._write_event("%s: bets $%.2f and is all-in" % (player.name, actual_bet_size*BB)) else: self._write_event("%s: bets $%.2f" % (player.name, actual_bet_size*BB)) else: if player.all_in: self._write_event("%s: raises $%.2f to $%.2f and is all-in" % (player.name, ((actual_bet_size+previous_bet_this_street)-self.bet_to_match)*BB, (actual_bet_size+previous_bet_this_street)*BB) ) else: self._write_event("%s: raises $%.2f to $%.2f" % (player.name, ((actual_bet_size+previous_bet_this_street)-self.bet_to_match)*BB, (actual_bet_size+previous_bet_this_street)*BB) ) self._change_bet_to_match(actual_bet_size+previous_bet_this_street) last_bet_placed_by = player else: raise Exception('Invalid action specified') if last_bet_placed_by is None: break if hand_is_over: break if not hand_is_over: if self.hand_history_enabled: self._write_show_down() self._distribute_pot() self._finish_hand() def _history_initialize(self): t = time.localtime() self.history.append("PokerStars Hand #%d: Hold'em No Limit ($%.2f/$%.2f USD) - %d/%d/%d %d:%d:%d ET" % (np.random.randint(2230397, 32303976), SB, BB, t.tm_year, t.tm_mon, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec)) self.history.append("Table 'Wempe III' 6-max Seat #%d is the button" % self.players[min(1, 2)].identifier) for i, player in enumerate(self.players): self.history.append("Seat %d: %s ($%.2f in chips)" % (i+1, player.name, player.stack*BB)) def _write_hole_cards(self): self.history.append("*** HOLE CARDS ***") for i, player in enumerate(self.players): self.history.append("Dealt to %s [%s %s]" % (player.name, Card.int_to_str(player.cards[0]), Card.int_to_str(player.cards[1]))) def _write_show_down(self): self.history.append("*** SHOW DOWN ***") hand_types = [self.evaluator.class_to_string(self.evaluator.get_rank_class(p.hand_rank)) for p in self.players if p.state is PlayerState.ACTIVE] for player in self.players: if player.state is PlayerState.ACTIVE: player.calculate_hand_rank(self.evaluator, self.cards) player_hand_type = self.evaluator.class_to_string(self.evaluator.get_rank_class(player.hand_rank)) matches = len([m for m in hand_types if m is player_hand_type]) multiple = matches > 1 self.history.append("%s: shows [%s %s] (%s)" % (player.name, Card.int_to_str(player.cards[0]), Card.int_to_str(player.cards[1]), pretty_print_hand(player.cards, player_hand_type, self.cards, multiple)) ) def _write_event(self, text): if self.hand_history_enabled: self.history.append(text) def _change_bet_to_match(self, new_amount): self.minimum_raise = new_amount - self.bet_to_match self.bet_to_match = new_amount def _get_observation(self, player): keys = ['position', 'state', 'stack', 'money_in_pot', 'bet_this_street', 'all_in'] values = [ [other.position, other.state, other.stack, other.money_in_pot, other.bet_this_street, other.all_in] for other in self.players if other is not player ] return { 'self': { 'position': player.position, 'cards': [[Card.get_suit_int(card), Card.get_rank_int(card)] for card in player.cards], 'stack': player.stack, 'money_in_pot': player.money_in_pot, 'bet_this_street': player.bet_this_street, }, 'table': { 'street': int(self.street), 'cards': [[Card.get_suit_int(card), Card.get_rank_int(card)] for card in self.cards], 'pot': self.pot, 'bet_to_match': self.bet_to_match, 'minimum_raise': self.minimum_raise, }, 'others': [ { key: val for key, val in zip(keys, value) } for value in values ] } def _is_action_valid(self, player, action, valid_actions): action_list, bet_range = valid_actions['actions_list'], valid_actions['bet_range'] if action.action_type not in action_list: if PlayerAction.FOLD in action_list: player.fold() self.active_players -= 1 self._write_event("%s: folds" % player.name) return False if PlayerAction.CHECK in action_list: player.check() self._write_event("%s: checks" % player.name) return False raise Exception('Something went wrong when validating actions, invalid contents of valid_actions') if action.action_type is PlayerAction.BET: if not bet_range[0] < action.bet_amount < bet_range[1]: player.fold() self.active_players -= 1 self._write_event("%s: folds" % player.name) return False if action.bet_amount > player.stack: player.fold() self.active_players -= 1 self._write_event("%s: folds" % player.name) return False return True def _get_valid_actions(self, player): valid_actions = [PlayerAction.CHECK, PlayerAction.FOLD, PlayerAction.BET, PlayerAction.CALL] valid_bet_range = [max(self.bet_to_match + self.minimum_raise, 1), player.stack] if self.bet_to_match == 0: valid_actions.remove(PlayerAction.CALL) valid_actions.remove(PlayerAction.FOLD) if self.bet_to_match != 0: valid_actions.remove(PlayerAction.CHECK) if player.stack < max(self.bet_to_match + self.minimum_raise, 1): valid_bet_range = [0, 0] valid_actions.remove(PlayerAction.BET) return {'actions_list': valid_actions, 'bet_range': valid_bet_range} def _finish_hand(self): for player in self.players: player.step(None, None, True) if self.hand_history_enabled: if player.winnings > 0: player.winnings = np.round(player.winnings, 2) self._write_event("%s collected $%.2f from pot" % (player.name, player.winnings*BB)) self._write_event("*** SUMMARY ***") self._write_event("Total pot $%.2f | Rake $%.2f" % (self.pot*BB, 0)) if self.street == GameState.FLOP: self._write_event("Board [%s %s %s]" % (Card.int_to_str(self.cards[0]), Card.int_to_str(self.cards[1]), Card.int_to_str(self.cards[2])) ) elif self.street == GameState.TURN: self._write_event("Board [%s %s %s %s]" % (Card.int_to_str(self.cards[0]), Card.int_to_str(self.cards[1]), Card.int_to_str(self.cards[2]), Card.int_to_str(self.cards[3])) ) elif self.street == GameState.RIVER: self._write_event("Board [%s %s %s %s %s]" % (Card.int_to_str(self.cards[0]), Card.int_to_str(self.cards[1]), Card.int_to_str(self.cards[2]), Card.int_to_str(self.cards[3]), Card.int_to_str(self.cards[4])) ) if self.hand_history_enabled and self.hand_history_location is not None: with open('%s/handhistory_%s.txt' % (self.hand_history_location,time.time()), 'w') as f: for row in self.history: f.writelines(row + '\n') def _distribute_pot(self): pot = 0 for player in self.players: if player.state is not PlayerState.ACTIVE: pot += player.money_in_pot player.winnings -= player.money_in_pot active_players = [p for p in self.players if p.state is PlayerState.ACTIVE] if len(active_players) == 1: active_players[0].winnings += pot + active_players[0].money_in_pot return for player in active_players: player.calculate_hand_rank(self.evaluator, self.cards) while True: min_money_in_pot = min([p.money_in_pot for p in active_players]) for player in active_players: pot += min_money_in_pot player.money_in_pot -= min_money_in_pot best_hand_rank = min([p.hand_rank for p in active_players]) winners = [p for p in active_players if p.hand_rank == best_hand_rank] for winner in winners: winner.winnings += pot / len(winners) active_players = [p for p in active_players if p.money_in_pot > 0] if len(active_players) <= 1: if len(active_players) == 1: active_players[0].winnings += active_players[0].money_in_pot break pot = 0
# or for random cards or games, create a deck print("Dealing a new hand...") deck = Deck() board = deck.draw(5) player1_hand = deck.draw(2) player2_hand = deck.draw(2) print("The board:") Card.print_pretty_cards(board) print("Player 1's cards:") Card.print_pretty_cards(player1_hand) print("Player 2's cards:") Card.print_pretty_cards(player2_hand) p1_score = evaluator.evaluate(board, player1_hand) p2_score = evaluator.evaluate(board, player2_hand) # bin the scores into classes p1_class = evaluator.get_rank_class(p1_score) p2_class = evaluator.get_rank_class(p2_score) # or get a human-friendly string to describe the score print(f"Player 1 hand rank = {p1_score} {evaluator.class_to_string(p1_class)}") print(f"Player 2 hand rank = {p2_score} {evaluator.class_to_string(p2_class)}") # or just a summary of the entire hand hands = [player1_hand, player2_hand] evaluator.hand_summary(board, hands)
async def calculate_plo(web_client, user_id, channel_id): active_players = player_list[channel_id] tab = tab_list[channel_id]["table"] deck = tab_list[channel_id]["deck"] evaluator = Evaluator() allboard = await findsubsets(tab.cards, 3) p0allcard = await findsubsets(active_players[0].cards, 2) p1allcard = await findsubsets(active_players[1].cards, 2) boardlist = [list(x) for x in allboard] tmpp0list = [list(x) for x in p0allcard] tmpp1list = [list(x) for x in p1allcard] p0list = [] p1list = [] for i in boardlist: for j in tmpp0list: p0list.append(evaluator.evaluate(i, j)) for i in boardlist: for j in tmpp1list: p1list.append(evaluator.evaluate(i, j)) p0list.sort() p1list.sort() p0numhand = evaluator.get_rank_class(p0list[0]) p0hand = evaluator.class_to_string(p0numhand) p1numhand = evaluator.get_rank_class(p1list[0]) p1hand = evaluator.class_to_string(p1numhand) for p in active_players: pic = Card.print_pretty_cards(p.cards) await sendslack("<@%s> shows %s" % (p.name, pic), web_client, channel_id) await sendslack( "<@%s> has %s" % (active_players[0].name, p0hand), web_client, channel_id ) await sendslack( "<@%s> has %s" % (active_players[1].name, p1hand), web_client, channel_id ) if p0list[0] > p1list[0]: await sendslack( "<@%s> wins %d" % (active_players[0].name, tab.pot), web_client, channel_id ) active_players[0].money += tab.pot else: await sendslack( "<@%s> wins %d" % (active_players[1].name, tab.pot), web_client, channel_id ) active_players[1].money += tab.pot if len(active_players) == 2: if active_players[0].money != 0 and active_players[1].money != 0: if active_players[1].dealer: active_players += [active_players.pop(0)] tab.cards.clear() tab.turn = 0 tab.highbet = 0 tab.pot = 0 for name in active_players: name.cards.clear() name.tocall = 0 name.dealer = False name.bet = 0 await set_up_game(web_client, channel_id, plo=True)