def evalStregth(self, isBet=False):
action = Action.Check
amount = 0
pre_percent = self.hands_strength
if self.stage != Stage.PreFlop and self.stage != Stage.HandOver:
print("Hand card:")
Card.print_pretty_cards(self.hands)
print("Board card:")
Card.print_pretty_cards(self.board)
self.hands_strength = self.winRateStrategy.evaluate(
self.hands, self.board)
isBetter = (self.hands_strength > pre_percent)
if self.hands_strength >= 0.9:
if isBetter:
action = Action.Allin
else:
action = Action.Raise
elif self.hands_strength >= 0.8 and self.hands_strength < 0.9:
action = Action.Bet
amount = max(self.min_bet, self.my_chips / 2)
elif self.hands_strength >= 0.6 and self.hands_strength < 0.8:
if self.min_bet < (self.my_chips / 3) and isBetter:
action = Action.Raise
elif "allin" in self.opponent_action:
action = Action.Fold
else:
action = Action.Call
elif self.hands_strength >= 0.5 and self.hands_strength < 0.6:
if self.min_bet < (self.my_chips /
5) and self.my_bet_chips < (self.my_chips / 2):
action = Action.Call
else:
action = Action.Fold
elif self.hands_strength >= 0.4 and self.hands_strength < 0.5:
if self.min_bet < (self.my_chips / 10):
action = Action.Call
else:
action = Action.Fold
elif self.hands_strength >= 0.18 and self.hands_strength < 0.4:
if not isBet:
action = Action.Check
elif self.min_bet < (self.my_chips / 20):
action = Action.Call
else:
action = Action.Fold
else:
if self.stage == Stage.PreFlop:
Card.print_pretty_cards(self.hands)
if "allin" not in self.opponent_action:
action = Action.Call
else:
action = Action.Fold
else:
action = Action.Fold
return (action, amount)
def GoToShowdown(player_1, player_2):
if evaluator.evaluate(player_1.board, player_1.hand) == evaluator.evaluate(
player_2.board, player_2.hand):
print("Draw")
elif evaluator.evaluate(player_1.board,
player_1.hand) < evaluator.evaluate(
player_2.board, player_2.hand):
print("Player 1 Wins")
else:
print("Player 2 Wins")
print(Card.print_pretty_cards(player_1.board + player_1.hand))
print("Player 1 hand rank = %d (%s)\n" %
(evaluator.evaluate(player_1.board, player_1.hand),
evaluator.class_to_string(
evaluator.get_rank_class(
evaluator.evaluate(player_1.board, player_1.hand)))))
print(Card.print_pretty_cards(player_2.board + player_2.hand))
print("Player 2 hand rank = %d (%s)\n" %
(evaluator.evaluate(player_2.board, player_2.hand),
evaluator.class_to_string(
evaluator.get_rank_class(
evaluator.evaluate(player_2.board, player_2.hand)))))
def PlayerFolded(game, total_games):
players_hands = []
for player in table.members:
players_hands.append(player.cards)
print("PLAYER_1:\t" + Card.print_pretty_cards(players_hands[0]))
print("PLAYER_2:\t" + Card.print_pretty_cards(players_hands[1]))
print("Board:\t" + Card.print_pretty_cards(self.board))
if player_folded[1] == 'Player 1':
print("Player 1 Folds -> Player 2 is the winner")
self.current_table.members[1].player.stack += table.pot
print("Player 1 Stack:\t" + str(table.members[0].player.stack))
print("Player 2 Stack:\t" + str(table.members[1].player.stack))
winner = 2
table.members[0].player.Game_Over(False, True,
total_games - game)
table.members[1].player.Game_Over(True, True,
total_games - game)
else:
print("Player 2 Folds -> Player 1 is the winner")
self.current_table.members[0].player.stack += table.pot
print("Player 1 Stack:\t" + str(table.members[0].player.stack))
print("Player 2 Stack:\t" + str(table.members[1].player.stack))
winner = 1
table.members[1].player.Game_Over(False, True,
total_games - game)
table.members[0].player.Game_Over(True, True,
total_games - game)
print(
'--------------------------------------------------------------------------\n'
)
num_actions = len(table.members[0].actions) if len(
table.members[0].actions) > 0 else 1
#Uncomment to Write to GAME LOGS
#self.Game_Summary(winner,table.pot,table.members[0].actions+"/"+table.members[1].actions,table.members[0].time_taken/num_actions,table.members[1].time_taken/num_actions,game)
table.members[0].time_taken = 0
table.members[1].time_taken = 0
return winner
def Turn(dealer, non_dealer):
table.big_blind = table.big_blind * 2
drawn_cards = [deck.draw(1)]
print("Turn:" + Card.print_pretty_cards(drawn_cards))
for i in drawn_cards:
self.board.append(i)
for member in table.members:
member.player.add_board(self.board)
first_to_act = table.members[non_dealer]
second_to_act = table.members[dealer]
player_folded = Decisions([first_to_act, second_to_act], 2)
return player_folded
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 build_subtree(self, target_node, path):
self.count += 1
if type(target_node) == BeginNode:
subpath = path + "\\Beginnode" + str(self.count)
elif type(target_node) == CardNode:
if target_node.board == "":
subpath = path + "\\" + str([
Card.int_to_pretty_str(card) for card in target_node.hands
])
elif len(target_node.board) == 3:
subpath = path + "\\" + str([
Card.int_to_pretty_str(card) for card in target_node.board
])
else:
subpath = path + "\\" + Card.int_to_pretty_str(
target_node.board[-1])
elif type(target_node) == ActionNode:
subpath = path + "\\(" + action_to_str[
target_node.label] + "," + action_to_str[
target_node.previous_action] + ")"
else:
subpath = path + "\\" + target_node.reason
if os.path.exists(subpath) == False:
os.mkdir(subpath)
os.chdir(subpath)
print(self.count, type(target_node))
if type(target_node) == TerminalNode:
with open("node info.txt", "w") as f:
f.write(str(target_node))
else:
target_node.get_children()
with open("node info.txt", "w") as f:
f.write(str(target_node))
if len(target_node.board) != "":
Card.print_pretty_cards(target_node.board)
for node in target_node.children:
self.build_subtree(node, subpath)
def print_pretty_cards_on_table(self):
"""Input: cards, Output: pretty cards"""
if self.cards_on_table != None:
cards_list_with_ints = \
self.convert_from_string_to_list(self.cards_on_table)
output = Card.print_pretty_cards(cards_list_with_ints)
# Change output from [9h], [6s], ... to 9h 6s ...
output = output.replace("[", "")
output = output.replace("]", "")
output = output.replace(",", "")
output = output.replace(" ", "")
return output
else:
return ''
def test_print_pretty_cards_deck(self):
"""
Input: String with cards separated by commas
Output: Pretty cards as a string
"""
# Arrange
table = Table()
table.deck = str(Card.new('As')) + ',' + str(Card.new('9h'))
# Act
table = table.print_pretty_cards_deck()
cards_result = Card.print_pretty_cards(
[Card.new('As'), Card.new('9h')])
# Assertion
self.assertEqual(table, cards_result)
self.assertIsInstance(table, str)
async def set_up_game(web_client, channel_id, plo=False):
players = player_list[channel_id]
if channel_id not in tab_list:
deck = Deck()
deck.shuffle()
tab = Table()
tab_list[channel_id] = {}
tab_list[channel_id]["table"] = tab
tab_list[channel_id]["deck"] = deck
tab = tab_list[channel_id]["table"]
deck = tab_list[channel_id]["deck"]
deck.shuffle()
tab.cards.extend(deck.draw(3))
if plo:
print("plos")
tab.plo = True
for name in players:
if plo:
name.cards.extend(deck.draw(4))
else:
print("nlhe")
name.cards.extend(deck.draw(2))
print("got to cards bit")
pic = Card.print_pretty_cards(name.cards)
await sendslack(pic, web_client, name.name)
if len(players) == 2:
i = random.randint(1, 2)
if i == 1:
players += [players.pop(0)]
await start_heads_up(web_client, channel_id)
if len(players) > 2:
random.shuffle(players)
tab.origlist = players.copy()
await start_game(web_client, channel_id)
# https://github.com/worldveil/deuces # Treys is a Python 3 compatible version from treys import Card from treys import Evaluator from treys import Deck deck = Deck() board = deck.draw(5) p1 = deck.draw(2) p2 = deck.draw(2) p3 = deck.draw(2) p4 = deck.draw(2) p5 = deck.draw(2) 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)
myhand.append(Card.new('3d'))
myhand.append(Card.new('4s'))
myhand.append(Card.new('5h'))
myhand.append(Card.new('As'))
print('Rank for A2345 is: ', evaluator.evaluate(myhand, []))
myhand = []
myhand.append(Card.new('Ac'))
myhand.append(Card.new('Kd'))
myhand.append(Card.new('Qs'))
myhand.append(Card.new('Jh'))
myhand.append(Card.new('Ts'))
print('Rank for AKQJT is: ', evaluator.evaluate(myhand, []))
'''
# create a card
card = Card.new('Qh')
# create a board and hole cards
board = [
Card.new('2h'),
Card.new('2s'),
Card.new('Jc')
]
hand = [
Card.new('Qs'),
Card.new('Th')
]
# pretty print cards to console
from treys import Card, Evaluator, Deck
# create a card
card = Card.new('Qh')
# create a board and hole cards
board = [Card.new('2h'), Card.new('2s'), Card.new('Jc')]
hand = [Card.new('Qs'), Card.new('Th')]
# pretty print cards to console
Card.print_pretty_cards(board + hand)
# create an evaluator
evaluator = Evaluator()
# and rank your hand
rank = evaluator.evaluate(board, hand)
print()
# 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)
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)
# Takes a hand and board combination and evaluates it #
from treys import Card
from treys import Deck
from treys import Evaluator
board = [Card.new('Ah'), Card.new('Kd'), Card.new('Jc')]
hand = [Card.new('Qs'), Card.new('Th')]
print(Card.print_pretty_cards(board + hand))
# Hand strength is valued on a scale of 1 to 7462, where 1 is a Royal Flush and 7462 is unsuited 7-5-4-3-2
evaluator = Evaluator()
print(evaluator.evaluate(board, hand))
def PlayGame(self, no_of_games=1):
#if self.current_table.is_full:
current_game = 0
while current_game < no_of_games:
self.game_string = f'{str(current_game+1)}D{str(self.current_table.dealer_position)}P'
game_round = 0 #0,1,2,3,4,5 -> Preflop,Flop,Turn,River,Postflop,Showdown
deck = Deck()
for member in self.current_table.members:
member.cards = deck.draw(2)
#Write Cards to Bot File
while game_round < 6:
if game_round == 0:
print("Pot:" + str(self.current_table.pot) + "\n")
#time.sleep(5)
decisions, player_folded = self.GetDecisions()
self.game_string += f'{decisions}'
self.UpdateGame()
if player_folded == -1:
game_round += 1
else:
game_round = 5
if game_round == 1:
print("Pot:" + str(self.current_table.pot) + "\n")
drawn_cards = []
drawn_cards = deck.draw(3)
print("Flop:" + Card.print_pretty_cards(drawn_cards))
for i in drawn_cards:
self.board.append(i)
self.game_string += f'F{self.GetCardInt(i)}'
decisions, player_folded = self.GetDecisions()
self.game_string += f'F{decisions}'
self.UpdateGame()
if player_folded == True:
game_round = 5
else:
game_round += 1
if game_round == 2:
print("Pot:" + str(self.current_table.pot) + "\n")
drawn_cards = [deck.draw(1)]
print("Turn:" + Card.print_pretty_cards(drawn_cards))
for i in drawn_cards:
self.board.append(i)
self.game_string += f'T{self.GetCardInt(i)}'
decisions, player_folded = self.GetDecisions()
self.game_string += f'T{decisions}'
self.UpdateGame()
if player_folded == True:
game_round = 5
else:
game_round += 1
if game_round == 3:
print("Pot:" + str(self.current_table.pot) + "\n")
drawn_cards = [deck.draw(1)]
print("River:" + Card.print_pretty_cards(drawn_cards))
for i in drawn_cards:
self.board.append(i)
self.game_string += f'R{self.GetCardInt(i)}'
decisions, player_folded = self.GetDecisions()
self.game_string += f'R{decisions}'
self.UpdateGame()
if player_folded == True:
game_round = 5
else:
game_round += 1
if game_round == 4:
print("Pot:" + str(self.current_table.pot) + "\n")
game_round += 1
if game_round == 5:
if player_folded == -1:
for member in self.current_table.members:
self.game_string += f'S{member.seat_no}A{self.GetCardInt(member.cards[0])}B{self.GetCardInt(member.cards[1])}'
winner = self.Showdown()
self.game_string += f'W{winner}E'
self.UpdateGame()
else:
winner = self.Showdown(player_folded=(True,
player_folded))
self.game_string += f'W{winner}E'
self.UpdateGame()
game_round += 1
self.board = []
self.current_table.pot = 0
no_of_games -= 1
def print_game(game_dict, true_game):
"""
Pretty prints the predicted game labels with the true game labels
Parameters
----------
game_dict : dict with the cards and chips detected for the game_id
true_game : list of the cards and chips in the true game
----------
Returns
None
"""
#list to dict, with THOSE headers
header_dict = [
'T1', 'T2', 'T3', 'T4', 'T5', 'P11', 'P12', 'P21', 'P22', 'P31', 'P32',
'P41', 'P42', 'CR', 'CG', 'CB', 'CK', 'CW'
]
game = [game_dict[key] for key in header_dict]
score, errors_game = eval_game(game_dict, true_game, verbose=False)
def handle_empty(card):
if card == '0' or card == 0:
return None
card2 = card[:-1] + card[-1:].lower()
return Card.new(card2)
def parse_pretty_hand(game):
board = game[:5]
all_players = [game[5 + i * 2:5 + (i + 1) * 2] for i in range(4)]
chips = game[13:]
board = [handle_empty(ci) for ci in board]
hands = [[handle_empty(ci) for ci in pi] for pi in all_players]
chips = [int(chip) for chip in chips]
return hands, board, chips
def print_hand(my_hand):
#print(" --- " , my_hand)
if my_hand[0] != None:
print(Card.print_pretty_cards(my_hand))
else:
print(my_hand)
hands_found, board_found, chips_found = parse_pretty_hand(game)
hands_true, board_true, chips_true = parse_pretty_hand(true_game)
#### Printing game begins
#printing table cards
print("__" * 20)
print("Table ", end='')
errors_table = errors_game[0:5]
if np.sum(errors_table) != 0:
print_color("mistakes in cards : ", 'red')
print(list(np.where(errors_table)[0]))
print("True table")
print(Card.print_pretty_cards(board_true))
print("Found table")
print(Card.print_pretty_cards(board_found))
else:
print_color("found correctly", 'green')
print("\n")
print(Card.print_pretty_cards(board_found))
print('\n')
##### Printing players cards
ascii_check = ["---->", "xxxxx"]
#ascii_circle = [🔴,🟢,🔵,⚫,⚪]
ascii_circle = [0, 1, 2, 3, 4]
errors_hands = errors_game[5:-5]
for i in range(4):
sum_error = np.sum(errors_hands[i * 2:(i + 1) * 2])
right = ascii_check[0] if sum_error == 0 else ascii_check[1]
if sum_error == 0:
print_color(ascii_check[0], 'green')
else:
print_color(ascii_check[1], 'red')
print(f"Player {i+1} ", end='')
if sum_error == 0:
print_color("found correctly", 'green')
print_hand(hands_true[i])
else:
print_color("error", 'red')
print("\n True hand")
print_hand(hands_true[i])
print("Estimated hand")
print_hand(hands_found[i])
print('\n')
#### Printing chips
chip_names = ['Red', 'Green', 'Blue', 'Black', 'White']
chip_color = ['red', 'green', 'blue', 'black', 'white']
for i in range(5):
diff = chips_found[i] - chips_true[i]
if diff == 0:
print_color(ascii_check[0], "green")
else:
print_color(ascii_check[1], "red")
print_color(f"Chip {chip_names[i]}", chip_color[i])
print(f"\tfound: {chips_found[i]}. Count error: ( {diff} )", end='\n')
print("__" * 20)
wm.add_watch(self.communication_files_directory, pyinotify.ALL_EVENTS, rec=True)
# event handler
kwargs = {"player_list": self.player_list}
eh = MyEventHandler(**kwargs)
# automate process of using bash
# wd = os.getcwd()
# #os.chdir("/usr/local/home/u180455/Desktop/Project/MLFYP_Project/MLFYP_Project/pokercasino")
# os.chdir("/home/gary/Desktop/MLFYP_Project/MLFYP_Project/pokercasino")
# subprocess.Popen("./lasvegas")
# os.chdir(wd)
# notifier
notifier = pyinotify.Notifier(wm, eh)
notifier.loop()
if __name__ == '__main__':
treys_card.print_pretty_cards([268446761, 134236965, 33589533] + [67115551, 16787479])
game = Game()
# graphics = graphical_display.main_draw(game)
tops = ["\t" * self.num_tabs + self.ncol * '=']
inner = ["\t" * self.num_tabs + '|' + " " *
(self.ncol - 2) + '|'] * (self.nrow - 2)
rows = tops + inner + tops
player_str = "{}, ${} in stack".format("Shyam", 10)
middle = self.nrow // 2
potstr = "pot: {}, side pot: {}".format(pot, side_pot)
rows[middle - 1] = self.applyPadding(potstr, self.getPadding(potstr))
rows[middle] = self.applyPadding(river_str, self.getPadding(river_str))
return '\n' + round_str + '\n' + self.playerPadding(
player_str, self.getPadding(
player_str, 0.0)) + '\n' + '\n'.join(rows) + '\n' * 2
def check(self):
print("hey")
if __name__ == "__main__":
from treys import Card
board = [Card.new('Ah'), Card.new('Kd'), Card.new('Jc')]
hand = [Card.new('Qs'), Card.new('Th')]
p = Printer(15, 50)
s = p.printBoard(1, Card.print_pretty_cards(board), pot=10)
print(s)
import random
from treys import Card, Deck, Evaluator
evaluator = Evaluator()
deck = Deck()
print("1v1 Texas Hold'em")
# Draw flop, turn, and river respectively
flop = deck.draw(3)
turn = deck.draw(1)
river = deck.draw(1)
board = flop + [turn] + [river]
hand1 = deck.draw(2)
hand2 = deck.draw(2)
hands = [hand1, hand2]
print("Board:", Card.print_pretty_cards(board))
evaluator.evaluate(board, hand1)
print("Summary:")
evaluator.hand_summary(board, hands)
# [J♦],[6♦]
# Board card:
# [7♣],[3♣],[A♦]
# hole = [getCard('Jd'), getCard('6d')]
# boards = [getCard('7c'), getCard('3c'), getCard('Ad')]
# print("Hole:")
# Card.print_pretty_cards(hole)
# print("Boards:")
# Card.print_pretty_cards(boards)
# print("Draw:")
# drawCard, rate = CardCounting().evaluate(hole, boards, 0.75)
# Card.print_pretty_cards(drawCard)
hole = [getCard('5s'), getCard('5h')]
pot = []
HoleEvaluator().evaluate(hole, 3, 1000)
drawCard.clear()
hole = [getCard('As'), getCard('9c')]
boards = [getCard('Qc'), getCard('6c'), getCard('9d'), getCard('6d')]
drawCard, rate = CardCounting().evaluate(hole, boards, 0.6)
Card.print_pretty_cards(drawCard)
print('rate:{:2.2%}'.format(rate))
drawCard.clear()
hole = [getCard('5d'), getCard('Qc')]
boards = [getCard('2d'), getCard('Td'), getCard('Kc'), getCard('Jc')]
drawCard, rate = CardCounting().evaluate(hole, boards, 0.6)
Card.print_pretty_cards(drawCard)
print('rate:{:2.2%}'.format(rate))
action = random.randint(0, 31)
new_eval = draw_until_empty_reward_mean(hand, action)
reward = get_reward(new_eval)
current_metric_score += reward
if (i+1) % metrics_window == 0:
metrics_score.append(current_metric_score/metrics_window)
current_metric_score = 0
train_X.append(feat.reshape((61,)))
Q[0, action] = reward
train_Y.append(Q.reshape((32,)))
if (i+1) % train_steps == 0:
print("hand n° ", str(i))
print("random %", str(epsi))
print(Card.print_pretty_cards(old_hand))
print(map_to_draw(np.argmax(Q)))
print(Card.print_pretty_cards(hand))
print(Q)
model.fit(np.stack(train_X), np.stack(train_Y), verbose=1, epochs=5)
# reduce explo
epsi *= 0.9
if len(train_X) > max_replay:
train_X = train_X[50:]
train_Y = train_Y[50:]
print(metrics_score)
print("Saving model..")
model.save('models/modelremade.h5')
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)
def print_hand(my_hand):
#print(" --- " , my_hand)
if my_hand[0] != None:
print(Card.print_pretty_cards(my_hand))
else:
print(my_hand)
def get_win_prob(self, state, playerid):
"""Calculate the win probability from your board cards and hand cards by using simple Monte Carlo method.
"""
evaluator = Evaluator()
def get_card_class(card_int_list):
res = [
Card.new(Card.int_to_str(c)) for c in card_int_list if c != -1
]
return res
def WinProbability(hand, board):
rank = evaluator.evaluate(board, hand)
percentage = 1.0 - evaluator.get_five_card_rank_percentage(rank)
return percentage
hand_cards = get_card_class(state.player_states[playerid].hand)
board_cards = get_card_class(state.community_card)
if any([True for h in hand_cards if h in board_cards]):
Card.print_pretty_cards(hand_cards)
Card.print_pretty_cards(board_cards)
num_players = len(
[p for p in state.player_states if not p.emptyplayer])
win = 0
round = 0
board_cards_to_draw = 5 - len(board_cards) # 2
rest_cards = self._pick_unused_card(board_cards + hand_cards)
#print("rest cards")
#Card.print_pretty_cards(rest_cards)
#choiced = random.sample(unused, card_num)
for i in range(self.simulation_number):
unused_cards = random.sample(rest_cards, (num_players - 1) * 2 +
board_cards_to_draw)
board_sample = unused_cards[len(unused_cards) -
board_cards_to_draw:]
unused_cards = unused_cards[:len(unused_cards) -
board_cards_to_draw]
opponents_hole = [
unused_cards[2 * i:2 * i + 2] for i in range(num_players - 1)
]
try:
opponents_score = [
WinProbability(hole, board_sample)
for hole in opponents_hole
]
my_rank = WinProbability(hand_cards, board_sample)
if my_rank >= max(opponents_score):
win += 1
round += 1
except Exception as inst: # Exception, e:
#print e.message
continue
#print("Win:{}".format(win))
#print('round:{}'.format(round))
if round == 0:
if len(board_cards) > 1:
try:
return WinProbability(board_cards, hand_cards)
except:
return 0.6
else:
return 0.6
win_prob = win / float(round)
return win_prob
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
return 0
#input is single card and single swap
#helper function for make_swaps
def do_swap(card, swap):
char_one = swap[0]
char_two = swap[1]
if (Card.get_suit_int(card) == char_to_int[char_one]):
return Card.new(rank_int_to_char[Card.get_rank_int(card)] + char_two)
else:
return card
#EXAMPLES
hand = []
hand.append(Card.new("4c"))
hand.append(Card.new("Ac"))
print("Original hand: ")
Card.print_pretty_cards(hand)
s = find_swap(hand)
new_hand = make_swaps(hand, s)
if (new_hand != 0):
print("\nNew hand: ")
Card.print_pretty_cards(new_hand)
def process_IN_CLOSE_WRITE(self, event):
### declaring a bot_number and event_type
#print("IN_CLOSE_WRITE event:", event.pathname)
global file_changed
arr = re.split(r'[/]',event.pathname)
most_recent_file_changed = (arr[len(arr)-1]) # last string in file path
last_letter = most_recent_file_changed[len(most_recent_file_changed)-1]
bot_number = last_letter if (last_letter =='0' or last_letter == '1' or last_letter == '2') else ''
event_type = most_recent_file_changed if bot_number == '' else most_recent_file_changed[0:len(most_recent_file_changed)-1]
filename = str(event_type+bot_number)
file_data = get_status_from_file(str(filename))
if event_type == "give_hand_bot":
if bot_number == '0':
self.player_list[0].card_holding = llf.GHB_Parsing(self.player_list[0], file_data) #check cards
#PROBLEM: Cannot evaluate preflop without players position which is retrieved in casinoToBot file overwrite
#he, evaluation, rc, score_desc, _ = self.player_list[0].hand_evaluate_preflop(self.player_list[0].card_holding, self.player_list[0].name)
# bot 0 now has his cards
elif bot_number == '1':
self.player_list[1].card_holding = llf.GHB_Parsing(self.player_list[1], file_data) #check cards
#print(self.player_list[0].card_holding)
#PROBLEM: Cannot evaluate preflop without players position which is retrieved in casinoToBot file overwrite
#he, evaluation, rc, score_desc, _ = self.player_list[1].hand_evaluate_preflop(self.player_list[1].card_holding, self.player_list[1].name)
#bot 1 now has his cards
elif bot_number == '2':
self.player_list[2].card_holding = llf.GHB_Parsing(self.player_list[2], file_data) #check cards
#print(self.player_list[0].card_holding)
#PROBLEM: Cannot evaluate preflop without players position which is retrieved in casinoToBot file overwrite
#he, evaluation, rc, score_desc, _ = self.player_list[1].hand_evaluate_preflop(self.player_list[1].card_holding, self.player_list[1].name)
#bot 1 now has his cards
elif event_type == "casinoToBot": # only on (second) iteration, is the casinoToBOT file written with the actions ie 'rrc'
treys_card.print_pretty_cards([268446761, 134236965, 33589533] + [67115551, 16787479])
with open("./test_file_data_change_CTB", 'a+') as f:
f.write("\n"+file_data)
f.close()
ctb_file_content = re.split(r'[DPFFFFTTRRSABSABWWE]',file_data) # DEBUG: test_file_data
dealer_no = ctb_file_content[1]
# casinoToBot is written: hand number> D <dealer button position> P <action by all players in order from first to act, e.g. fccrf...> F <flop card 1> F <flop 2> F <flop 3> F <flop action starting with first player to act>
# T <turn card> T <turn action> R <river card> R <river action>
bot_n = int(bot_number)
bot_cards = self.player_list[bot_n].card_holding
bot_name = self.player_list[bot_n].name
# we want to check if ONLY the preflop action is filled
is_preflop_action_filled, is_flop_action_filled, is_turn_action_filled, is_river_action_filled = llf.casinoToBot_ParsingRead(self, ctb_file_content, self.player_list[bot_n], self.player_list, bot_number) # DEBUG: test_file_data #check cards
flop_cards_present, turn_card_present, river_card_present = llf.check_cards_shown(file_data)
first_meeting = {0: False, 1: False, 2: False, 3: False}
is_new_game = False
# PREFLOP
if (flop_cards_present == False and turn_card_present == False and river_card_present == False):
# first move (BTN)
if(is_preflop_action_filled == False and is_flop_action_filled == False and is_turn_action_filled ==False and is_river_action_filled == False): # is only preflop filled? he, evaluation, rc, score_desc, player_action = self.player_list[bot_n].hand_evaluate_preflop(bot_cards, bot_name) # USE FOR DEBUGGING (files have alreayd been filled with debugger)
for player in self.player_list:
player.is_new_game = True
first_meeting[0] = True
he, rc, score_desc, player_action = self.player_list[bot_n].hand_evaluate(bot_cards, bot_name, 'Preflop', first_meeting, True) # USE FOR DEBUGGING (files have alreayd been filled with debugger)
self.player_list[bot_n].is_new_game = False
elif(is_preflop_action_filled == True and is_flop_action_filled == False and is_turn_action_filled ==False and is_river_action_filled == False): # is flop filled yet?
first_meeting[0] = False
he, rc, score_desc, player_action = self.player_list[bot_n].hand_evaluate(bot_cards, bot_name, 'Preflop', first_meeting, False) # USE FOR DEBUGGING (files have alreayd been filled with debugger)
self.player_list[bot_n].is_new_game = False
#POSTFLOP
elif (flop_cards_present == True and turn_card_present == False and river_card_present == False):
#first move of flop (SB assuming he hasn't folded)
if(is_preflop_action_filled == True and is_flop_action_filled == False and is_turn_action_filled ==False and is_river_action_filled == False): # is flop filled yet?
first_meeting[1] = True
self.player_list[bot_n].action_sent = False
he, rc, score_desc, player_action = self.player_list[bot_n].hand_evaluate(bot_cards, bot_name, 'Flop', first_meeting, False) # USE FOR DEBUGGING (files have alreayd been filled with debugger)
elif(is_preflop_action_filled == True and is_flop_action_filled == True and is_turn_action_filled ==False and is_river_action_filled == False): # is turn filled yet?
first_meeting[1] = False
self.player_list[bot_n].action_sent = False
he, rc, score_desc, player_action = self.player_list[bot_n].hand_evaluate(bot_cards, bot_name, 'Flop', first_meeting, False) # USE FOR DEBUGGING (files have alreayd been filled with debugger)
#TURN
elif (flop_cards_present == True and turn_card_present == True and river_card_present == False):
#print("inside TURN main")
#print("\n", is_preflop_action_filled, is_flop_action_filled, is_turn_action_filled, is_river_action_filled)
# first move of turn
if(is_turn_action_filled ==False and is_river_action_filled == False): # is turn filled yet?
#print("inside TURN 1")
first_meeting[2] = True
self.player_list[bot_n].action_sent = False
he, rc, score_desc, player_action = self.player_list[bot_n].hand_evaluate(bot_cards, bot_name, 'Turn', first_meeting, False) # USE FOR DEBUGGING (files have alreayd been filled with debugger)
elif(is_turn_action_filled ==True and is_river_action_filled == False): #is river filled yet?
#print("inside TURN 2")
first_meeting[2] = False
self.player_list[bot_n].action_sent = False
he, rc, score_desc, player_action = self.player_list[bot_n].hand_evaluate(bot_cards, bot_name, 'Turn', first_meeting, False) # USE FOR DEBUGGING (files have alreayd been filled with debugger)
#RIVER
elif (flop_cards_present == True and turn_card_present == True and river_card_present == True):
# first move of river
if(is_preflop_action_filled == True and is_flop_action_filled == True and is_turn_action_filled ==True and is_river_action_filled == False): #is river filled yet?
first_meeting[3] = True
self.player_list[bot_n].action_sent = False
he, rc, score_desc, player_action = self.player_list[bot_n].hand_evaluate(bot_cards, bot_name, 'River', first_meeting, False) # USE FOR DEBUGGING (files have alreayd been filled with debugger)
elif(is_preflop_action_filled == True and is_flop_action_filled == True and is_turn_action_filled ==True and is_river_action_filled == True): #is river filled yet?
first_meeting[3] = False
self.player_list[bot_n].action_sent = False
he, rc, score_desc, player_action = self.player_list[bot_n].hand_evaluate(bot_cards, bot_name, 'River', first_meeting, False) # USE FOR DEBUGGING (files have alreayd been filled with debugger)
def play_game_human_human(self):
"""Rollout one OFC game and return the LHS score and LHS/RHS boards."""
deck = DeckGenerator.new_deck()
lhs_board = OFCBoard()
rhs_board = OFCBoard()
lhs_start = deck[0:5]
rhs_start = deck[6:11]
# Starting hand one card at a time for now. In future, give
# all cards at once
lhs_board.pretty()
print('Player 1 starting cards;'),
Card.print_pretty_cards([Card.new(card) for card in lhs_start])
for i in range(5):
card = lhs_start[i]
street_id = self.lhs_agent.place_new_card(card, lhs_board)
lhs_board.place_card_by_id(card, street_id)
lhs_board.pretty()
rhs_board.pretty()
print('Player 2 starting cards;'),
Card.print_pretty_cards([Card.new(card) for card in rhs_start])
for i in range(5):
card = rhs_start[i]
street_id = self.rhs_agent.place_new_card(card, rhs_board)
rhs_board.place_card_by_id(card, street_id)
rhs_board.pretty()
# Eight cards one at a time
for i in range(8):
self.print_both_boards(lhs_board, rhs_board)
card = deck.pop()
street_id = self.lhs_agent.place_new_card(card, lhs_board)
lhs_board.place_card_by_id(card, street_id)
self.print_both_boards(lhs_board, rhs_board)
card = deck.pop()
street_id = self.rhs_agent.place_new_card(card, rhs_board)
rhs_board.place_card_by_id(card, street_id)
print('Final Boards')
self.print_both_boards(lhs_board, rhs_board)
lhs_royalties = lhs_board.get_royalties()
rhs_royalties = rhs_board.get_royalties()
if lhs_board.is_foul() and rhs_board.is_foul():
lhs_score = 0
elif lhs_board.is_foul():
lhs_score = (-1 * rhs_royalties) - 6
elif rhs_board.is_foul():
lhs_score = lhs_royalties + 6
else:
exch = self.calculate_scoop(lhs_board, rhs_board)
lhs_score = exch + lhs_royalties - rhs_royalties
return lhs_score, lhs_board, rhs_board
