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