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
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
deck = Deck()
board = deck.draw(5)
player1_hand = deck.draw(2)
player2_hand = deck.draw(2)
print("The board:")
print(card.pretty(board))
print("Player 1's cards:")
print(card.pretty(player1_hand))
print("Player 2's cards:")
print(card.pretty(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("Player 1 hand rank = %d (%s)" %
(p1_score, evaluator.class_to_string(p1_class)))
print("Player 2 hand rank = %d (%s)" %
(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)
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)
print(p4_score)
print(p5_score)
ind = scores.index(min(scores))
print("The winner is player number", ind+1,"with the hand", evaluator.class_to_string(classes[ind]))
deck1 = Deck()
flop = deck1.draw(3)
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
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
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)
