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 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 get_win_prob(self,state, playerid,hand_cards, board_cards,num_players):
win = 0
rounds=0
evaluator = Evaluator()
for i in range(self.simulation_number):
board_cards_to_draw = 5 - len(board_cards) # 2
board_sample = board_cards + self._pick_unused_card(board_cards_to_draw,hand_cards+board_cards)
unused_cards = self._pick_unused_card((num_players - 1) * 2, hand_cards + board_sample)
board_sample = [Card.new(i) for i in board_sample]
unused_cards = [Card.new(i) for i in unused_cards]
opponents_hole = [unused_cards[2 * i:2 * i + 2] for i in range(num_players - 1)]
#hand_sample = self._pick_unused_card(2, board_sample + hand_cards)
try:
opponents_score = [1 - evaluator.evaluate(hole, board_sample)/7462 for hole in opponents_hole]
myhand_cards = [Card.new(i) for i in hand_cards]
my_rank = 1 - evaluator.evaluate(myhand_cards, board_sample)/7462
if my_rank >= max(opponents_score):
win += 1
#rival_rank = evaluator.evaluate_hand(hand_sample, board_sample)
rounds+=1
except Exception as e:
#print e.message
continue
win_prob = win / rounds
return win_prob
def HeroVsRangeEquityCalc(self):
global vilRange
START = DT.datetime.now()
# Hero Hand
heroHandstr = self.ui.heroHand.toPlainText()
heroCard1 = Card.new(heroHandstr[0:2])
heroCard2 = Card.new(heroHandstr[3:5])
heroHand = [
heroCard1, heroCard2
] # This is not going to work on 10 ---- need to search for commas or sumn like below. 10 = T
# Board
Boardstr = self.ui.board.toPlainText()
### Func to be extracted to Loose file func(str,',') -> nCardList
# Break up text by comma
Board = separateCardsByComma(
Boardstr) ## Functio nname should be better
### END FUN TO BE EXTRACTED
# Evaluate Equity
Equity = EquityVsRange(vilRange, heroHand, flop=Board)
self.ui.EvalTextDisplay.setPlainText(str(Equity))
END = DT.datetime.now()
TIME = END - START
print(TIME.seconds)
def _get_cards_rank(self, hole_card, round_state, debug_printouts):
"""
:param hole_card: Hole cards of own player
:param round_state: Current round state, containing community cards
:param debug_printouts: Parameter for debugging purpose only. Allows printing the calculated hand rank
:return: Float between 0 and 1, representing the current five card rank among all possible poker hands.
0 represents the weakest five card combination, 1 the strongest (Royal Flush)
"""
evaluator = Evaluator()
board = []
hand = []
if len(round_state['community_card']) >= len(board):
for card in round_state['community_card']:
board.append(Card.new(card))
for card in hole_card:
hand.append(Card.new(card))
score = evaluator.evaluate(board, hand)
if debug_printouts:
Card.print_pretty_cards(board + hand)
print(Card.print_pretty_cards(board + hand))
return 1 - evaluator.get_five_card_rank_percentage(score)
def decide_action(status):
hand = []
board = []
pocket_cards = status['pocketCards']
common_cards = status['communityCards']
for card in pocket_cards:
if card['rank'] == "10":
rank = "T"
elif len(card['rank']) > 1:
rank = card['rank'][0].upper()
else:
rank = card['rank']
suit = card['suit'][0]
hand.append(Card.new('{}{}'.format(rank, suit)))
for card in common_cards:
if card['rank'] == "10":
rank = "T"
elif len(card['rank']) > 1:
rank = card['rank'][0].upper()
else:
rank = card['rank']
suit = card['suit'][0]
board.append(Card.new('{}{}'.format(rank, suit)))
return 'call'
def test_check_players_have_cards(self):
"""Return False if at least one player have cards"""
# Arrange
cards1 = str(Card.new('As')) + ',' + str(Card.new('9s'))
cards2 = str(Card.new('Ah')) + ',' + str(Card.new('9h'))
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, cards=cards1)
player1.save()
player2 = Player(name=us2, cards=cards2)
player2.save()
player3 = Player(name=us3)
player3.save()
player4 = Player(name=us4)
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4)
# Act
result = table.check_players_have_cards()
# Assertion
self.assertFalse(result)
table.remove_cards_from_players()
result2 = table.check_players_have_cards()
self.assertTrue(result2)
def hero_hole_cards(hh_preflop):
#Returns a list which contains the integer representation of two hole cards belonging to hero based on treys library.
hole_cards = []
hole_cards.append(
Card.new(hh_preflop.split('Dealt to Hero ')[1].split()[0][1:]))
hole_cards.append(
Card.new(hh_preflop.split('Dealt to Hero ')[1].split()[1][:-1]))
return hole_cards
def set_hand_card(self, cards):
self.hand_cards = cards
cardOne = Card.new(cards[0]['value'] + cards[0]['suit'])
cardTwo = Card.new(cards[1]['value'] + cards[1]['suit'])
self.is_suited = cards[0]['suit'] == cards[1]['suit']
self.is_pair = cards[0]['value'] == cards[1]['value']
self.hand_score = Card.prime_product_from_hand([cardOne, cardTwo])
self.hand_rank = evaluator.get_rank_class(self.hand_score)
def get_hand_with_board_rank_class(self):
hand = [
Card.new(card['value'] + card['suit']) for card in self.hand_cards
]
board = [
Card.new(card['value'] + card['suit']) for card in self.board_cards
]
score = evaluator.evaluate(board, hand)
return evaluator.get_rank_class(score)
def getKey(self, cards):
board = []
hand = []
for e in cards[0]:
board.append(card.new(self.cardMap.get(e)))
for e in cards[1]:
hand.append(card.new(self.cardMap.get(e)))
eval = self.evaluator.evaluate(hand, board)
return str(ceil(eval / 39))
def randCommunity(community):
if len(community) == 3:
hand = [
Card.new(allCards[randint(0, 51)]),
Card.new(allCards[randint(0, 51)])
]
elif len(community) == 4:
hand = [Card.new(allCards[randint(0, 51)])]
else:
hand = []
return evaluator.evaluate(community, hand) / MAXSCORE
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)))
def make_a_bet(self):
# action, stake, use_reserve
latest_status = self.game.status[-1]
schnizel_userId = self.game.login_response['playerId']
schnizel_player = None
for player in latest_status['activePlayers']:
if player['playerId'] == schnizel_userId:
schnizel_player = player
pocket_cards = latest_status['pocketCards']
community_cards = latest_status['communityCards']
hand = []
community = []
for pocket_card in pocket_cards:
card_name = pocket_card['rank'].upper()[0] + pocket_card['suit'][0]
if card_name[0] == '1':
card_name = 'T' + card_name[1]
hand.append(Card.new(card_name))
for community_card in community_cards:
card_name = community_card['rank'].upper()[0] + community_card['suit'][0]
if card_name[0] == '1':
card_name = 'T' + card_name[1]
community.append(Card.new(card_name))
schnitzel_chips = self.game.get_schnitzel_chips()
try:
use_superpower = useSuperpower(self.get_superpowers(), hand, community, int(latest_status['stake']), schnitzel_chips)
if use_superpower is not None:
self.game.superpowers[use_superpower] -= 1
return use_superpower, 0, False
except Exception:
pass
# community = [Card.new('Jh'), Card.new('Ad'), Card.new('3s')]
# hand = [Card.new('4s'), Card.new('Jc')]
bidAmount = max(int(latest_status['stake']) - int(schnizel_player['stake']), 10)
currentMoney = schnizel_player['chips']
try:
# community_with_spy = community + self.get_spied()
# hand_with_leech = hand + self.get_leeched()
# action, amount = decision(community_with_spy, hand_with_leech, bidAmount, currentMoney)
action, amount = decision(community, hand, bidAmount, currentMoney)
print(f'Choosing {action}, and putting {amount}')
except Exception as e:
print(traceback.format_exc())
print('Decision issue')
return 'raise', bidAmount, False
return action, amount, False
def villain_hole_cards(hh_showdown, hh_river):
#Returns a list which contains the integer representation of two hole cards belonging to villain based on treys library.
hole_cards = []
hole_cards.append(
Card.new(
hh_showdown.split(obtain_villain_position(hh_river) +
': shows ')[1].split()[0][1:]))
hole_cards.append(
Card.new(
hh_showdown.split(obtain_villain_position(hh_river) +
': shows ')[1].split()[1][:-1]))
return hole_cards
def test_remove_cards_on_table(self):
"""Remove all cards from all players"""
# Arrange
cards = str(Card.new('As')) + ',' + str(Card.new('9s'))
table = Table(cards_on_table=cards)
# Act
table.remove_cards_on_table()
# Assertion
self.assertEqual(table.cards_on_table, None)
def expected_key(self, table, hand):
table = self.card_to_str(table)
hand = self.card_to_str(hand)
table, hand = self.convert_card(table, hand)
ontable = [Card.new(card) for card in table]
inhand = [Card.new(card) for card in hand]
try:
treys_rank = self.evaluator.evaluate(ontable, inhand)
except Exception:
treys_rank = -1
all_cards = table + hand
allinwin_rank = expectedRank(expected.get_expected_value(all_cards))
return '{}-{}'.format(allinwin_rank, treys_rank)
def convert_hand_to_treys(hand):
num = []
color = []
for card in hand:
color.append(card[0])
num.append(card[1])
card1 = Card.new(num[0].upper() + color[0].lower())
card2 = Card.new(num[1].upper() + color[1].lower())
feat = np.zeros(13)
for c in [card1, card2]:
feat[Card.get_rank_int(c)] = 1
return feat
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 convert_card_to_treys(cards):
convert_cards = []
hand_nb_spade = 0
hand_nb_heart = 0
hand_nb_diamond = 0
hand_nb_clover = 0
feats = []
for card in cards:
color = card[0]
num = card[1]
if color == "C":
hand_nb_clover += 1
elif color == "H":
hand_nb_heart += 1
elif color == "D":
hand_nb_diamond += 1
elif color == "S":
hand_nb_spade += 1
convert_cards.append(Card.new(num.upper() + color.lower()))
for i in [0, 1, 2, 3, 4]:
feat = np.zeros(13)
try:
feat[Card.get_rank_int(convert_cards[i])] = 1
feats.append(feat)
except Exception as e:
feats.append(feat)
return feats, hand_nb_spade, hand_nb_heart, hand_nb_diamond, hand_nb_clover
def get_observation(data):
global community_card
# print(data)
stack = data['self']['chips']
# print('stack= ', stack)
hand_cards = [Card.new(x[0] + x[1].lower()) for x in data['self']['cards']]
# print('hand_cards= ', hand_cards)
# print('community_card= ',community_card)
cards = transferCard(hand_cards + community_card)
# print('cards= ',cards)
to_call = data['self']['minBet']
# print('to_call= ',to_call)
if len(community_card) == 0:
handrank = -1
else:
handrank = Evaluator().evaluate(community_card, hand_cards)
# print('handrank= ',handrank)
betting = data['self']['bet']
# print('betting= ',betting)
totalpot = betting
for player in data['game']['players']:
totalpot += player['bet']
# print('totalpot= ',totalpot)
return np.concatenate(([totalpot, handrank], cards))
def pyDealerCardToDeucesCard(cardString):
newCard = ""
if cardString.startswith("Ace"):
newCard += "A"
elif cardString.startswith("King"):
newCard += "K"
elif cardString.startswith("Queen"):
newCard += "Q"
elif cardString.startswith("Jack"):
newCard += "J"
elif cardString.startswith("10"):
newCard += "T"
else: # numerical value under 10
newCard += cardString[0]
if cardString.endswith("Clubs"):
newCard += "c"
elif cardString.endswith("Spades"):
newCard += "s"
elif cardString.endswith("Hearts"):
newCard += "h"
elif cardString.endswith("Diamonds"):
newCard += "d"
return Card.new(newCard)
def board_to_hands(board,hand1,hand2):
hand1.reset()
hand2.reset()
board = board.reshape(1,52)
board = board[0]
unseen = []
full_deck = []
for suit, val in Card.CHAR_SUIT_TO_INT_SUIT.items():
for rank in Card.STR_RANKS:
full_deck.append(Card.new(rank + suit))
BOARD_TO_HAND = {0:unseen,
1:hand1.top_hand,
2:hand1.middle_hand,
3:hand1.bottom_hand,
4:hand1.discards,
5:hand1.dealt_cards,
-1:hand2.top_hand,
-2:hand2.middle_hand,
-3:hand2.bottom_hand,
-4:hand2.discards,
-5:hand2.dealt_cards}
for i in range(52):
BOARD_TO_HAND[board[i]].append(full_deck[i])
def __init__(self, strategy=None, desiredCards=None):
self.strategy = strategy
self.desiredCards = ([
Card.print_pretty_card(Card.new(card)) if len(card) > 1 else card
for card in desiredCards
] if desiredCards else None)
self.POKER_HAND_EVALUATOR = Evaluator()
def board_to_players(board, player1, player2):
player1.reset()
player2.reset()
board = list(board)
unseen = []
full_deck = []
for suit, val in Card.CHAR_SUIT_TO_INT_SUIT.items():
for rank in Card.STR_RANKS:
full_deck.append(Card.new(rank + suit))
BOARD_TO_HAND = {
0: unseen,
1: player1.top_hand,
2: player1.middle_hand,
3: player1.bottom_hand,
4: player1.discards,
5: player1.dealt_cards,
-1: player2.top_hand,
-2: player2.middle_hand,
-3: player2.bottom_hand,
-4: player2.discards,
-5: player2.dealt_cards
}
for i in range(52):
BOARD_TO_HAND[board[i]].append(full_deck[i])
board = np.array(board)
def test_convert_from_list_to_string(self):
"""
Input: Strings representing cards separate by commas
Output: List with int's
"""
# Arrange
cards_list = [Card.new('As'), Card.new('9h')]
cards_string = str(Card.new('As')) + ',' + str(Card.new('9h'))
# Act
result = Table.convert_from_list_to_string(self, cards_list)
# Assertion
self.assertEqual(result, cards_string)
self.assertIsInstance(result, str)
def test_on_table_is_only_3_cards(self):
"""Return True if on table is only 3 cards"""
# Arrange
cards = str(Card.new('As')) + ',' + str(Card.new('9s')) + ',' + str(
Card.new('3c'))
table = Table(cards_on_table=cards)
# Act
result = table.on_table_is_only_3_cards()
# Assertion
self.assertTrue(result)
cards2 = str(Card.new('As')) + ',' + str(Card.new('9s'))
table2 = Table(cards_on_table=cards2)
result2 = table2.on_table_is_only_3_cards()
self.assertFalse(result2)
def test_print_pretty_cards_cards(self):
"""
Input: String with cards separated by commas
Output: Pretty cards as a string
"""
# Arrange
player = Player('player')
player.cards = str(Card.new('As')) + ',' + str(Card.new('9h'))
# Act
player_result = player.print_pretty_cards_cards()
cards_result = 'A♠9♥'
# Assertion
self.assertEqual(player_result, cards_result)
self.assertIsInstance(player_result, str)
def test_print_pretty_cards_on_table(self):
"""
Input: String with cards separated by commas
Output: Pretty cards as a string
"""
# Arrange
table = Table()
table.cards_on_table = str(Card.new('As')) + ',' + str(Card.new('9h'))
# Act
table = table.print_pretty_cards_on_table()
cards_result = 'A♠9♥'
# Assertion
self.assertEqual(table, cards_result)
self.assertIsInstance(table, str)
def play_game_human_cpu(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()
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)
print('')
# 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)
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
