def eval_post_flop_current(hole_cards, community_cards): board = [] hand = [] remaining_cards = all_cards[:] for card in hole_cards: new_card = Card.new(card[1] + card[0].lower()) hand.append(new_card) remaining_cards.remove(new_card) for card in community_cards: new_card = Card.new(card[1] + card[0].lower()) board.append(new_card) remaining_cards.remove(new_card) score = evaluator.evaluate(board, hand) rounds = 0 wins = 0 draws = 0 for i in xrange(0, len(remaining_cards)): for j in xrange(i + 1, len(remaining_cards)): rounds += 1 opp_hand = [remaining_cards[i], remaining_cards[j]] opp_score = evaluator.evaluate(board, opp_hand) if (opp_score > score): wins += 1 # elif(evaluator.evaluate(board, opp_hand) < score): # loses += 1 elif (opp_score == score): draws += 1 # print("Rounds played: " + str(rounds) + " Wins: " + str(wins) + " Draws: " + str(draws)) return 100.0 * (float(wins) / rounds)
def eval_post_flop_rank(hole_cards, community_cards): board = [] hand = [] for card in hole_cards: hand.append(Card.new(card[1] + card[0].lower())) # 9c, Ah, Kd etc.. for card in community_cards: board.append(Card.new(card[1] + card[0].lower())) score = evaluator.evaluate(board, hand) return ( 7462 - score + 1 ) / 7462.0 * 100 # there are only 7642 distinctly ranked hands in poker
def straight_and_highcards(self, straights, highcards): """ Unique five card sets. Straights and highcards. Reuses bit sequences from flush calculations. """ rank = LookupTable.MAX_FLUSH + 1 for s in straights: prime_product = Card.prime_product_from_rankbits(s) self.unsuited_lookup[prime_product] = rank rank += 1 rank = LookupTable.MAX_PAIR + 1 for h in highcards: prime_product = Card.prime_product_from_rankbits(h) self.unsuited_lookup[prime_product] = rank rank += 1
def GetFullDeck(): if Deck._FULL_DECK: return list(Deck._FULL_DECK) # create the standard 52 card deck for rank in Card.STR_RANKS: for suit, val in Card.CHAR_SUIT_TO_INT_SUIT.iteritems(): Deck._FULL_DECK.append(Card.new(rank + suit)) return list(Deck._FULL_DECK)
def _five(self, cards): """ Performs an evalution given cards in integer form, mapping them to a rank in the range [1, 7462], with lower ranks being more powerful. Variant of Cactus Kev's 5 card evaluator, though I saved a lot of memory space using a hash table and condensing some of the calculations. """ # if flush if cards[0] & cards[1] & cards[2] & cards[3] & cards[4] & 0xF000: handOR = (cards[0] | cards[1] | cards[2] | cards[3] | cards[4]) >> 16 prime = Card.prime_product_from_rankbits(handOR) return self.table.flush_lookup[prime] # otherwise else: prime = Card.prime_product_from_hand(cards) return self.table.unsuited_lookup[prime]
def __str__(self): return Card.print_pretty_cards(self.cards)
def flushes(self): """ Straight flushes and flushes. Lookup is done on 13 bit integer (2^13 > 7462): xxxbbbbb bbbbbbbb => integer hand index """ # straight flushes in rank order straight_flushes = [ 7936, # int('0b1111100000000', 2), # royal flush 3968, # int('0b111110000000', 2), 1984, # int('0b11111000000', 2), 992, # int('0b1111100000', 2), 496, # int('0b111110000', 2), 248, # int('0b11111000', 2), 124, # int('0b1111100', 2), 62, # int('0b111110', 2), 31, # int('0b11111', 2), 4111 # int('0b1000000001111', 2) # 5 high ] # now we'll dynamically generate all the other # flushes (including straight flushes) flushes = [] gen = self.get_lexographically_next_bit_sequence(int('0b11111', 2)) # 1277 = number of high cards # 1277 + len(str_flushes) is number of hands with all cards unique rank for i in xrange(1277 + len(straight_flushes) - 1): # we also iterate over SFs # pull the next flush pattern from our generator f = next(gen) # if this flush matches perfectly any # straight flush, do not add it notSF = True for sf in straight_flushes: # if f XOR sf == 0, then bit pattern # is same, and we should not add if not f ^ sf: notSF = False if notSF: flushes.append(f) # we started from the lowest straight pattern, now we want to start ranking from # the most powerful hands, so we reverse flushes.reverse() # now add to the lookup map: # start with straight flushes and the rank of 1 # since theyit is the best hand in poker # rank 1 = Royal Flush! rank = 1 for sf in straight_flushes: prime_product = Card.prime_product_from_rankbits(sf) self.flush_lookup[prime_product] = rank rank += 1 # we start the counting for flushes on max full house, which # is the worst rank that a full house can have (2,2,2,3,3) rank = LookupTable.MAX_FULL_HOUSE + 1 for f in flushes: prime_product = Card.prime_product_from_rankbits(f) self.flush_lookup[prime_product] = rank rank += 1 # we can reuse these bit sequences for straights # and high cards since they are inherently related # and differ only by context self.straight_and_highcards(straight_flushes, flushes)
def eval_post_flop_true(hole_cards, community_cards): board = [] hand = [] remaining_cards = all_cards[:] for card in hole_cards: new_card = Card.new(card[1] + card[0].lower()) hand.append(new_card) remaining_cards.remove(new_card) for card in community_cards: new_card = Card.new(card[1] + card[0].lower()) board.append(new_card) remaining_cards.remove(new_card) rounds = 0 wins = 0 draws = 0 if (len(community_cards) == 5): # (45 choose 2) = 990 iterations score = evaluator.evaluate(board, hand) for i in xrange(0, len(remaining_cards)): for j in xrange(i + 1, len(remaining_cards)): rounds += 1 opp_hand = [remaining_cards[i], remaining_cards[j]] opp_score = evaluator.evaluate(board, opp_hand) if (opp_score > score): wins += 1 # elif(evaluator.evaluate(board, opp_hand) < score): # loses += 1 elif (opp_score == score): draws += 1 print("Rounds played: " + str(rounds) + " Wins: " + str(wins) + " Draws: " + str(draws)) return (float(wins) / rounds) * 100.0 elif (len(community_cards) == 4 ): # (46 choose 3) * (3 choose 1) = 45540 iterations for i in range(0, len(remaining_cards)): temp_board = board + [remaining_cards[i]] for j in xrange(0, len(remaining_cards)): if (i == j): continue else: for k in xrange(j + 1, len(remaining_cards)): if ((i == k) or (j == k)): continue else: rounds += 1 opp_hand = [remaining_cards[j], remaining_cards[k]] opp_score = evaluator.evaluate( temp_board, opp_hand) score = evaluator.evaluate(temp_board, hand) if (opp_score > score): wins += 1 # elif(evaluator.evaluate(board, opp_hand) < score): # loses += 1 elif (opp_score < score): draws += 1 print("Rounds played: " + str(rounds) + " Wins: " + str(wins) + " Draws: " + str(draws)) return (float(wins) / rounds) * 100.0 elif (len(community_cards) == 3 ): # (47 choose 4) * (4 choose 2) = 1070190 iterations for h in xrange(0, len(remaining_cards)): temp_board = board + [remaining_cards[h]] for i in xrange(h + 1, len(remaining_cards)): temp_board_2 = temp_board + [remaining_cards[i]] for j in xrange(0, len(remaining_cards)): if ((i == j) or (h == j)): continue else: for k in xrange(j + 1, len(remaining_cards)): if ((i == k) or (h == k)): continue else: rounds += 1 # print(rounds) opp_hand = [ remaining_cards[j], remaining_cards[k] ] opp_score = evaluator.evaluate( temp_board_2, opp_hand) score = evaluator.evaluate(temp_board_2, hand) if (opp_score > score): wins += 1 # elif(evaluator.evaluate(board, opp_hand) < score): # loses += 1 elif (opp_score < score): draws += 1 print("Rounds played: " + str(rounds) + " Wins: " + str(wins) + " Draws: " + str(draws)) return (float(wins) / rounds) * 100.0 else: print("ERROR")
# https://github.com/worldveil/deuces # e.g. hole_cards = ['SA', 'C2'], community_cards = ['D9', 'H3', 'C5', 'S6', 'D4'] from Group02_card import Card import Group02_evaluator evaluator = Group02_evaluator.Evaluator() all_cards = [] all_cards.append(Card.new('Ad')) for i in xrange(8): all_cards.append(Card.new(str(i + 2) + 'd')) all_cards.append(Card.new('Td')) all_cards.append(Card.new('Jd')) all_cards.append(Card.new('Qd')) all_cards.append(Card.new('Kd')) all_cards.append(Card.new('Ac')) for i in xrange(8): all_cards.append(Card.new(str(i + 2) + 'c')) all_cards.append(Card.new('Tc')) all_cards.append(Card.new('Jc')) all_cards.append(Card.new('Qc')) all_cards.append(Card.new('Kc')) all_cards.append(Card.new('Ah')) for i in xrange(8): all_cards.append(Card.new(str(i + 2) + 'h')) all_cards.append(Card.new('Th')) all_cards.append(Card.new('Jh')) all_cards.append(Card.new('Qh')) all_cards.append(Card.new('Kh'))