def test_init(self, hand, make_holding):
holding_no_cards = make_holding(player_id=hand.dealer.id,
hand_id=hand.id)
assert holding_no_cards.id > 0
assert len(holding_no_cards.cards) == 0
assert len(Card.query.all()) == 0
holding_cards_ints = make_holding(
player_id=hand.dealer.id,
hand_id=hand.id,
cards=[PokerCard.new('As'),
PokerCard.new('Ac')])
assert holding_cards_ints.id > 0
assert len(holding_cards_ints.cards) == 2
assert len(Card.query.all()) == 2
holding_cards_objs = make_holding(player_id=hand.dealer.id,
hand_id=hand.id,
cards=Card.query.all())
assert holding_cards_objs.id > 0
assert len(holding_cards_objs.cards) == 2
assert len(Card.query.all()) == 2
with pytest.raises(InvalidCardError):
make_holding(player_id=hand.dealer.id,
hand_id=hand.id,
cards=["invalid card"])
with pytest.raises(sqlalchemy.exc.IntegrityError):
make_holding(player_id=None, is_board=False, hand_id=hand.id)
def get_score(hand_cards, board_cards):
board = []
for x in board_cards:
x = x.encode('ascii', 'ignore')
c = Card.new('{0}{1}'.format(x[0], x[1].lower()))
board.append(c)
hand = []
for x in hand_cards:
x = x.encode('ascii', 'ignore')
c = Card.new('{0}{1}'.format(x[0], x[1].lower()))
hand.append(c)
score_min = 9999999
if (len(hand) + len(board) <= 5):
return score_min
else:
for board_five_match in combinations(board, 5 - len(hand)):
evaluator = Evaluator()
score = evaluator.evaluate(tuple(board_five_match), tuple(hand))
if (score < score_min):
score_min = score
return score_min
def test_codes_property(self, hand, make_holding):
holding = make_holding(
player_id=hand.dealer.id,
hand_id=hand.id,
cards=[PokerCard.new('As'),
PokerCard.new('Ac')])
assert holding.codes == [PokerCard.new('As'), PokerCard.new('Ac')]
def hand_strength(hand_cards, community):
if len(community) == 0:
hand_cards.sort(key=order_cards)
raw_score = two_card_lookup[" ".join(hand_cards)]
scaled_score = (1325 - raw_score) * 2.9562264151 + 3545
return scaled_score
elif len(community) == 3 and len(hand_cards) == 0:
community.sort(key=order_cards)
community = " ".join(community)
community = transform_for_lookup(community)
raw_score = three_card_lookup[community]
scaled_score = (22100 - raw_score) * 0.2618552036 + 1675
return scaled_score
elif len(community) == 4 and len(hand_cards) == 0:
community.sort(key=order_cards)
community = " ".join(community)
community = transform_for_lookup(community)
raw_score = four_card_lookup[community]
scaled_score = (270725 - raw_score) * 0.02756526525 + 22
return four_card_lookup[community]
else:
deuces_cards = [Card.new(card) for card in hand_cards]
deuces_community = [Card.new(card) for card in community]
return evaluator.evaluate(deuces_cards, deuces_community)
def evaluate_showdown_probabilities(self, hand, board, nsim):
board_cards = [Card.new(j) for j in board]
hand_cards = [Card.new(j) for j in hand]
cards_in_play = cp.copy(board_cards)
cards_in_play.extend(hand_cards)
board_cards_to_draw = (5 - len(board))
hand_cards_to_draw = (2 - len(hand))
villain_cards_to_draw = 2
num_cards_to_draw = board_cards_to_draw + hand_cards_to_draw + villain_cards_to_draw
deck = de.Deck()
draw_deck = list(set(deck.cards) - set(cards_in_play))
nwins = 0.0
for i in range(nsim):
rest_of_cards = sample(draw_deck, num_cards_to_draw)
board_sim = cp.copy(board_cards)
hand_sim = cp.copy(hand_cards)
board_sim.extend(rest_of_cards[0:board_cards_to_draw])
hand_sim.extend(
rest_of_cards[board_cards_to_draw:(board_cards_to_draw +
hand_cards_to_draw)])
villain_hand = rest_of_cards[(board_cards_to_draw +
hand_cards_to_draw):]
villain_rank = self.card_evaluator.evaluate(
board_sim, villain_hand)
hero_rank = self.card_evaluator.evaluate(board_sim, hand_sim)
nwins += hero_rank < villain_rank
win_pct = nwins / nsim
return win_pct
def get_action(board_cards=[],hand_cards=['AH', 'KD']):
if(len(board_cards)+len(hand_cards)==0):
return 'error'
board = []
for x in board_cards:
c = Card.new('{0}{1}'.format(x[0], x[1].lower()))
board.append(c)
hand = []
for x in hand_cards:
c = Card.new('{0}{1}'.format(x[0], x[1].lower()))
hand.append(c)
score = get_score_by_simulate(hand,board)
print(score)
BAD_SCORE = 7000
BEST_SCORE = 1000
BETTER_SCORE = 2000
GOOD_SCORE = 4000
if(len(hand)+len(board)>5 and score>BAD_SCORE):
action = 'fold'
else:
if(score<=BEST_SCORE):
action = 'all_in'
elif(score<=BETTER_SCORE):
action = 'raise_max'
elif(score>BETTER_SCORE and score<=GOOD_SCORE):
action = 'raise_min'
else:
action = 'call'
return action
def is_good(board_cards=[], hand_cards=['AH', 'KD']):
if (len(board_cards) + len(hand_cards) == 0):
return False
board = []
for x in board_cards:
c = Card.new('{0}{1}'.format(x[0], x[1].lower()))
board.append(c)
hand = []
for x in hand_cards:
c = Card.new('{0}{1}'.format(x[0], x[1].lower()))
hand.append(c)
evaluator = Evaluator()
deck = Deck()
random_cards = deck.draw(5 - len(board) - len(hand))
score = evaluator.evaluate(board + random_cards, hand)
rank_class = evaluator.get_rank_class(score)
print_cards(board + random_cards + hand, rank_class)
if (rank_class < 9):
return True
return False
def get_card_suite(board, hand):
if not (all(hand) and all(board)):
return -1
elif '-' in hand or '-' in board:
return -1
board = [deucesCard.new(c) for c in board]
hand = [deucesCard.new(c) for c in hand]
return evaluator.evaluate(board, hand)
def test_front_lookup_trips():
weakest = [Card.new(x) for x in ['Kh', 'Ks', 'Kd', 'Ad', 'Qh']]
middle = [Card.new(x) for x in ['Ah', 'As', 'Ad']]
strongest = [Card.new(x) for x in ['Ah', 'As', 'Ad', '2d', '3d']]
assert evaluator.evaluate(strongest, []) < \
evaluator.evaluate(middle, []) < \
evaluator.evaluate(weakest, [])
def test_front_lookup_aces():
strongest = [Card.new(x) for x in ['Ah', 'As', '6d']]
middle = [Card.new(x) for x in ['Ah', 'As', '5d', '4d', '3d']]
weakest = [Card.new(x) for x in ['Ah', 'As', '5d']]
assert evaluator.evaluate(strongest, []) < \
evaluator.evaluate(middle, []) < \
evaluator.evaluate(weakest, [])
def test_get_hands():
'''Test that we convert a raw line of input cards into 2 hands of Cards'''
raw_cards = '8C TS KC 9H 4S 7D 2S 5D 3S AC'
expected_cards = (
[Card.new('8c'), Card.new('Ts'), Card.new('Kc'), Card.new('9h'), Card.new('4s')],
[Card.new('7d'), Card.new('2s'), Card.new('5d'), Card.new('3s'), Card.new('Ac')],
)
assert get_hands(raw_cards) == expected_cards
def __init__(self):
card = {}
deck = []
ranked_hands = []
n = 0
for i in ['2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K', 'A']:
for j in ['s', 'h', 'c', 'd']:
card[i+j] = Card.new(i+j)
deck.append(Card.new(i+j))
n += 1
for hand in combinations([card['As'], card['Ad'], card['Ac'], card['Ah']], 2):
ranked_hands.append(set(hand))
for hand in combinations([card['Ks'], card['Kd'], card['Kc'], card['Kh']], 2):
ranked_hands.append(set(hand))
for hand in combinations([card['Qs'], card['Qd'], card['Qc'], card['Qh']], 2):
ranked_hands.append(set(hand))
ranked_hands.append(set((card['As'], card['Ks'])))
ranked_hands.append(set((card['Ad'], card['Kd'])))
ranked_hands.append(set((card['Ac'], card['Kc'])))
ranked_hands.append(set((card['Ah'], card['Kh'])))
for hand in combinations([card['Js'], card['Jd'], card['Jc'], card['Jh']], 2):
ranked_hands.append(set(hand))
ranked_hands.append(set((card['As'], card['Qs'])))
ranked_hands.append(set((card['Ad'], card['Qd'])))
ranked_hands.append(set((card['Ac'], card['Qc'])))
ranked_hands.append(set((card['Ah'], card['Qh'])))
ranked_hands.append(set((card['Ks'], card['Qs'])))
ranked_hands.append(set((card['Kd'], card['Qd'])))
ranked_hands.append(set((card['Kc'], card['Qc'])))
ranked_hands.append(set((card['Kh'], card['Qh'])))
ranked_hands.append(set((card['As'], card['Js'])))
ranked_hands.append(set((card['Ad'], card['Jd'])))
ranked_hands.append(set((card['Ac'], card['Jc'])))
ranked_hands.append(set((card['Ah'], card['Jh'])))
ranked_hands.append(set((card['Ks'], card['Js'])))
ranked_hands.append(set((card['Kd'], card['Jd'])))
ranked_hands.append(set((card['Kc'], card['Jc'])))
ranked_hands.append(set((card['Kh'], card['Jh'])))
for hand in combinations([card['Ts'], card['Td'], card['Tc'], card['Th']], 2):
ranked_hands.append(set(hand))
self.ranked_hands = ranked_hands
self.card_dict = card
self.deck = deck
self.evaluator = Evaluator()
def __init__(self, new_deck, player_hand_string, flop=False):
self.my_hand = [Card.new(i) for i in player_hand_string]
self.deck = new_deck
self.deck.cards.remove(self.my_hand[0])
self.deck.cards.remove(self.my_hand[1])
if flop:
for new_card in flop:
self.board_cards.append(Card.new(new_card))
self.deck.cards.remove(self.board_cards[-1])
def holding(hand):
return Holding.create(id=1,
player_id=hand.dealer_id,
hand_id=hand.id,
is_board=False,
active=True,
created_utc=datetime.datetime(2019, 7, 31),
cards=[PokerCard.new('As'),
PokerCard.new('Ac')])
def test_front_lookup_very_low():
weakest = [Card.new(x) for x in ['2h', '3s', '4d']]
middle = [Card.new(x) for x in ['2h', '3s', '5d']]
stronger = [Card.new(x) for x in ['2h', '4s', '5d']]
strongest = [Card.new(x) for x in ['2h', '3s', '7d']]
assert evaluator.evaluate(strongest, []) < \
evaluator.evaluate(stronger, []) < \
evaluator.evaluate(middle, []) < \
evaluator.evaluate(weakest, [])
def getHandStrength(self):
evaluator = Evaluator()
score = evaluator.evaluate(
[Card.new(str(self.hand[0])),
Card.new(str(self.hand[1]))],
[Card.new('Td'), Card.new('4c'),
Card.new('9s')])
rank = evaluator.get_rank_class(score)
print "Score:", score, "Percentile:", round(
1 - float(score) / float(7254),
2), "Class:", evaluator.class_to_string(rank)
def get_hand_strength(hole_cards, board_cards):
"""
Takes in hole cards and board cards and returns the hand strength.
"""
evaluator=Evaluator()
hole=[Card.new(hole_cards[0]), Card.new(hole_cards[1])]
board=[]
for card in board_cards:
board.append(Card.new(card))
strength=(7643-evaluator.evaluate(hole, board))/float(7642)
return strength
def get_deuces_hand_strength(self, cards, board_cards):
"""
Gets the effective hand strength of your cards at any stage of the game using the deuces library.
"""
evaluator = Evaluator()
hole = [Card.new(cards[0]), Card.new(cards[1])
] #Turns cards and board cards into deuces.Card objects
board = []
for card in board_cards:
board.append(Card.new(card))
return (7643 - evaluator.evaluate(hole, board)) / float(
7642) #Turns the hand strength into a decimal in the range of 0-1
def set_player_hand(self, first_card_name, second_card_name):
if not self._check_non_empty_string(first_card_name):
raise ValueError('First card name cannot be empty')
return
if not self._check_non_empty_string(second_card_name):
raise ValueError('Second card name cannot be empty')
return
self.hand = [
Card.new( first_card_name.strip() ),
Card.new( second_card_name.strip() )
]
def encode(self, plyr_board, oppo_board, current_card,
plyr_cards, game_over, score):
current_card = [Card.new(current_card)]
plyr_cards = [Card.new(x) for x in plyr_cards]
plyr_front_ranks = self.cards_to_ranks(plyr_board.front.cards, 3)
plyr_mid_ranks = self.cards_to_ranks(plyr_board.mid.cards, 5)
plyr_back_ranks = self.cards_to_ranks(plyr_board.back.cards, 5)
oppo_front_ranks = self.cards_to_ranks(plyr_board.front.cards, 3)
oppo_mid_ranks = self.cards_to_ranks(plyr_board.mid.cards, 5)
oppo_back_ranks = self.cards_to_ranks(plyr_board.back.cards, 5)
plyr_front_suits = self.cards_to_suits(plyr_board.front.cards)
plyr_mid_suits = self.cards_to_suits(plyr_board.mid.cards)
plyr_back_suits = self.cards_to_suits(plyr_board.back.cards)
oppo_front_suits = self.cards_to_suits(plyr_board.front.cards)
oppo_mid_suits = self.cards_to_suits(plyr_board.mid.cards)
oppo_back_suits = self.cards_to_suits(plyr_board.back.cards)
current_card_rank = self.cards_to_ranks(current_card, 1)
current_card_suit = self.cards_to_suits(current_card)
remaining_card_ranks = self.cards_to_ranks(plyr_cards, 4)
remaining_card_suits = self.cards_to_suits(plyr_cards)
free_streets = np.array(plyr_board.get_free_streets())
free_streets_std = (free_streets - 0.5) * 2 # Hacky "standardisation"
encoding = np.hstack([
plyr_front_ranks,
plyr_mid_ranks,
plyr_back_ranks,
plyr_front_suits,
plyr_mid_suits,
plyr_back_suits,
oppo_front_ranks,
oppo_mid_ranks,
oppo_back_ranks,
oppo_front_suits,
oppo_mid_suits,
oppo_back_suits,
current_card_rank,
current_card_suit,
remaining_card_ranks,
remaining_card_suits,
free_streets_std
])
return encoding
def test_cards_relationship(self, hand, make_holding, make_card):
holding = make_holding(player_id=hand.dealer.id, hand_id=hand.id)
card1 = make_card(code=PokerCard.new('As'), rank='A', suit='s')
card2 = make_card(code=PokerCard.new('Ac'), rank='A', suit='c')
assert len(holding.cards) == 0
holding.cards.append(card1)
assert len(holding.cards) == 1
assert holding.cards[0] is card1
holding.cards.append(card2)
assert len(holding.cards) == 2
assert holding.cards[1] is card2
def getRank(num_player,card_player,board_player): playerrank=[[]for row in range(num_player)] hand=[]*2 board=[]*5 for i in range(num_player): for t in range(len(card_player[i])): hand=[Card.new(card_player[i][t][0]),Card.new(card_player[i][t][1])] evaluator=Evaluator() board=[Card.new(board_player[i][0]),Card.new(board_player[i][1]),Card.new(board_player[i][2]),Card.new(board_player[i][3]),Card.new(board_player[i][4])] rank=evaluator.evaluate(board,hand) playerrank[i].append(rank) print hand,rank,playerrank[i] print playerrank return playerrank
def get_strength_difference(hole_cards_1, hole_cards_2, board_cards):
"""
Takes in the hole cards and the board cards and returns the difference in hand strength between player one and
player two.
"""
evaluator=Evaluator()
hole_1=[Card.new(hole_cards_1[0]), Card.new(hole_cards_1[1])]
hole_2=[Card.new(hole_cards_2[0]), Card.new(hole_cards_2[1])]
board=[]
for card in board_cards:
board.append(Card.new(card))
strength_1=(7643-evaluator.evaluate(hole_1, board))/float(7642)
strength_2=(7643-evaluator.evaluate(hole_2, board))/float(7642)
return strength_1-strength_2
def test_front_royalties():
front = [Card.new(x) for x in ['2h', '2c', '3d']]
assert RoyaltyCalculator.score_front_royalties(front) == 0
front = [Card.new(x) for x in ['6h', '6c', '3d']]
assert RoyaltyCalculator.score_front_royalties(front) == 1
front = [Card.new(x) for x in ['Ah', 'Ac', '3d']]
assert RoyaltyCalculator.score_front_royalties(front) == 9
front = [Card.new(x) for x in ['2h', '2c', '2d']]
assert RoyaltyCalculator.score_front_royalties(front) == 10
front = [Card.new(x) for x in ['Ah', 'Ac', 'Ad']]
assert RoyaltyCalculator.score_front_royalties(front) == 22
def test_front_royalties():
front = [Card.new(x) for x in ['2h', '2c', '3d']]
assert RoyaltyCalculator.score_front_royalties(front) == 0
front = [Card.new(x) for x in ['6h', '6c', '3d']]
assert RoyaltyCalculator.score_front_royalties(front) == 1
front = [Card.new(x) for x in ['Ah', 'Ac', '3d']]
assert RoyaltyCalculator.score_front_royalties(front) == 9
front = [Card.new(x) for x in ['2h', '2c', '2d']]
assert RoyaltyCalculator.score_front_royalties(front) == 10
front = [Card.new(x) for x in ['Ah', 'Ac', 'Ad']]
assert RoyaltyCalculator.score_front_royalties(front) == 22
def add(self, new_card):
nc = Card.new(new_card)
if nc in self.deck.cards:
self.board_cards.append(nc)
self.deck.cards.remove(self.board_cards[-1])
else:
raise Exception("Found repeated card: " + str(new_card))
def get_format_cards(self, cards):
allcards = []
for card in cards:
card = str(card)
newcard= Card.new(str(card[0].upper() +card[1].lower()))
allcards.append(newcard)
return allcards
def get_bet(self, data):
roundnum = data['game']['roundName']
players = data['game']['players']
chips = data['self']['chips']
hands = data['self']['cards']
self.raise_count = data['game']['raiseCount']
self.my_step = data['game']['betCount']
self.my_chips = chips
self.my_name = data['self']['playerName']
self.number_players = len(players)
self.my_call_bet = data['self']['minBet']
self.my_raise_bet = self.my_call_bet * 2
self.hole = []
for card in (hands):
card = convert_card_str(card)
card = Card.new(card)
self.hole.append(card)
print ("...roundnum: ", format(roundnum), " -> force bet")
print ('...my_call_bet:', format(self.my_call_bet), "my_raise_bet", format(self.my_raise_bet), "my_chips", format(self.my_chips), "table bet", format(self.table_bet))
Card.print_pretty_cards (self.hole)
Card.print_pretty_cards (self.board)
if roundnum == 'Deal' and self.my_step == 0:
print ("...Force to bet!")
action = 'call'
amount = self.my_call_bet
self.my_step += 1
self.total_bet += amount
return action, amount
else:
return self.get_action(data)
def get_probabilities(card_1, card_2, other_players, trials=10000):
"""
for a given preflop hand, compute the probabilities of winning or tying.
Note that we've got a very important design decision here: we could obtain
the probabilities in a combinatorial fashion -- it's possible to mathematically
reason to obtain the exact probability of winning or tying, but this seems
quite involved. It's much easier to use a Monte Carlo simulation to approximate
the probabilities. With a large number of trials (e.g. 10k or 100k) the
approximations should be sufficiently close to the theoretical "true" values
for all practical intents and purposes.
"""
deck = map(lambda (x, y): Card.new(y + x), list(product(suits, ranks)))
wins = 0
ties = 0
deck.remove(card_1)
deck.remove(card_2)
for i in range(trials):
# Randomly shuffling the deck and slicing the first few cards to get hands
# seems computationally cheaper than using random.choice to select subsets as hands
shuffle(deck)
shared_cards = deck[:5]
# hands held by other players
other_hands = [
deck[5 + (2 * x):7 + (2 * x)] for x in range(other_players)
]
result = eval_table([card_1, card_2], shared_cards, other_hands)
if result == WIN:
wins += 1
elif result == TIE:
ties += 1
return wins / float(trials), ties / float(trials)
def cardsRank(self, cards):
evaCards = []
for card in cards:
evaCards.append(Card.new(self.ePoint[self.getPointOf(card)] + \
self.eColor[self.getColorOf(card)]))
rank = self.evaluator.evaluate(evaCards)
return rank
def get_probabilities(card_1, card_2, other_players, trials=10000):
"""
for a given preflop hand, compute the probabilities of winning or tying.
Note that we've got a very important design decision here: we could obtain
the probabilities in a combinatorial fashion -- it's possible to mathematically
reason to obtain the exact probability of winning or tying, but this seems
quite involved. It's much easier to use a Monte Carlo simulation to approximate
the probabilities. With a large number of trials (e.g. 10k or 100k) the
approximations should be sufficiently close to the theoretical "true" values
for all practical intents and purposes.
"""
deck = map(lambda (x,y): Card.new(y+x), list(product(suits,ranks)))
wins = 0
ties = 0
deck.remove(card_1)
deck.remove(card_2)
for i in range(trials):
# Randomly shuffling the deck and slicing the first few cards to get hands
# seems computationally cheaper than using random.choice to select subsets as hands
shuffle(deck)
shared_cards = deck[:5]
# hands held by other players
other_hands = [deck[5+(2*x):7+(2*x)] for x in range(other_players)]
result = eval_table([card_1, card_2], shared_cards, other_hands)
if result == WIN:
wins +=1
elif result == TIE:
ties +=1
return wins/float(trials), ties/float(trials)
def __init__(self, cards, board, evaluator=None):
"""Initialize new poker hand from a card array and an evaluator."""
assert len(cards) == 2
assert len(board) in [3, 4, 5]
# checking there are 5, 6 or 7 unique cards
cardset = set(list(cards) + list(board))
assert len(cardset) == len(cards) + len(board)
if isinstance(cards[0], str):
self._cards = [Card.new(card_str) for card_str in cards]
else:
self._cards = list(cards)
self._cards = sorted(self._cards)
#TODO allow for Flop object to be passed
self._board = Flop(board)
if evaluator:
self.ev = evaluator
else:
ev = Evaluator()
self.ev = ev
self.rank = self.ev.evaluate(self._cards, self._board._cards)
self.rank_class = self.ev.get_rank_class(self.rank)
self._hand_ranks = sorted(
[Card.get_rank_int(card) for card in self._cards])
self._board_ranks = self._board.ranks
def takeAction(player, action, data):
global current_md5
global hand
global board
# print(action)
# print(data)
if action == "__new_peer":
# calcuate md5 by player name
# current_md5 = "70be3acc4a99a780e1b405e1ff7971c5"
current_md5 = hashlib.md5(player).hexdigest()
print('MD5 of Current User: '******'playerName']:
card_list = player_info['cards']
for card in card_list:
hand.append(Card.new(convertToDeucesCard(card)))
print("****** My hand cards ******")
Card.print_pretty_cards(hand)
print("***************************")
elif action == "__bet":
takeActionByDeuces(player, action, data)
elif action == "__action":
if len(data['game']['board']) == 0:
takeActionByHand(player, action, data)
else:
takeActionByDeuces(player, action, data)
def cardsRank(self, cards):
evaCards = []
for card in cards:
evaCards.append(Card.new(self.ePoint[self.getPointOf(card)] + \
self.eColor[self.getColorOf(card)]))
rank = self.evaluator.evaluate(evaCards)
return rank
def get_all_card():
output = []
tbl = get_all_cardstr()
for c in tbl:
output.append(Card.new(c))
return output
def buildDeck(cards):
deck = list();
for value in Card.STR_RANKS:
for suit in 'shdc':
if value+suit not in cards:
deck.append(Card.new(value+suit));
deck = shuffleDeck(deck);
return deck;
def parse_cards(cardstr):
#have to replace 10 with T for deuces
cardstr = cardstr.replace('10', 'T')
cardlist = cardstr.split(' ')
hand = []
for card in cardlist:
dcard = Card.new(card)
hand.append(dcard)
return hand
def evaluate_hands(self):
agent_hands = []
if self.in_game_count > 1:
evaluator = Evaluator()
board = []
scores = []
hand_types = []
for c in self.community_cards:
board.append(Card.new(c))
for i in range(0, len(self.agents)):
agent = self.agents[i]
agent_hand = []
for c in agent.hand:
agent_hand.append(Card.new(c))
if self.in_game[i]:
agent_hands.append(agent.hand)
agent_score = evaluator.evaluate(board, agent_hand)
agent_hand_type = evaluator.class_to_string(evaluator.get_rank_class(agent_score))
scores.append(agent_score)
hand_types.append(agent_hand_type)
else:
agent_hands += [None]
scores.append(9999999999999)
lowest_rank = scores[0]
winner = 0
for i in range(0, len(self.agents)):
if lowest_rank > scores[i]:
lowest_rank = scores[i]
winner = i
return (winner, agent_hands)
else: # Only 1 remaining player
winner = 0
for i in range(0, len(self.agents)):
if (self.in_game[i]):
winner = i
break
return winner, agent_hands
def get_lowest_unpairing_card(hand):
"""Add the worst possible card to an incomplete hand. Something
that cannot pair up or make a flush or make a straight."""
existing_ranks = set([Card.get_rank_int(x) for x in hand])
remaining_ranks = list(set(range(12)) - existing_ranks)
selected_rank = remaining_ranks[0]
would_be_hand = hand + [Card.new(Card.STR_RANKS[selected_rank] + 'h')]
if is_straight(would_be_hand):
selected_rank = remaining_ranks[1] # Don't make a straight
selected_rank_str = Card.STR_RANKS[selected_rank]
last_suit = Card.get_suit_int(hand[-1])
last_suit_index = [1, 2, 4, 8].index(last_suit)
selected_suit = [1, 2, 4, 8][(last_suit_index + 1) % 4]
selected_suit_str = Card.INT_SUIT_TO_CHAR_SUIT[selected_suit]
selected_card_str = selected_rank_str + str(selected_suit_str)
return Card.new(selected_card_str)
def setUpDeucesCards(cardsList):
# Take a list of cards numbered 1-52 and put them into the form
#used by deuces evaluator.
# Convert card numbers to a deuces form string.
cardStrings = []
for i in range (0,len(cardsList)):
cardStrings.append(convertToDeuces(cardsList[i]))
# Put cards into a deuces form hand.
deucesCards = []
for i in range (0,len(cardsList)):
deucesCards.append(Card.new(cardStrings[i]))
return deucesCards
def main(other_players, trials):
with open("lookup-table-" + str(other_players), "w") as f:
# iterate over all 169 equivalent starting hands. If you're curious about
# why there are only 169 equivalent starting hands, see:
# https://en.wikipedia.org/wiki/Texas_hold_'em_starting_hands#Essentials
count = 0
for c1 in range(len(ranks)):
for c2 in range(c1,len(ranks)):
# note that the way we iterate means that r1 <= r2 always.
# knowing this makes it easier to get data from the output lookup table.
r1 = ranks[c1]
r2 = ranks[c2]
# We only ever use Spades and Clubs as suits because all that matters
# is whether your starting cards are suited or off-suit. The suits
# themselves are all equivalent, so the nominal choice doesn't matter.
if r1==r2:
wins,ties = get_probabilities((Card.new(r1 + "s")), Card.new(r2 + "c"),
other_players, trials)
write_to_file(f, r1, r2, "offsuit", wins, ties)
count +=1
else:
wins,ties = get_probabilities((Card.new(r1 + "s")), Card.new(r2+ "c"),
other_players, trials)
write_to_file(f, r1, r2, "offsuit", wins, ties)
count +=1
wins,ties = get_probabilities((Card.new(r1 + "s")), Card.new(r2+ "s"),
other_players, trials)
write_to_file(f, r1, r2, "suited", wins, ties)
count +=1
# Log the script's progress. For a given number of players, every simulation
# should take roughly equally long. However, the more players you have,
# the longer the entire process takes. (More hands to evaluate.)
print "Simulated " + str(count) +" / 169"
def encode(self, plyr_board, oppo_board, current_card,
plyr_cards, game_over, score):
if current_card is not None:
current_card = Card.new(current_card)
current_card_binary = self.card_to_ranks_binary(current_card)
else:
current_card_binary = np.zeros(13)
free_streets = np.array(plyr_board.get_free_streets())
free_streets_std = (free_streets - 0.5) * 2 # Hacky "standardisation"
encoding = np.hstack([
current_card_binary,
free_streets_std
])
return encoding
def getRank4(card): hand=[Card.new(card[0]),Card.new(card[1])] evaluator=Evaluator() board=[Card.new(card[2]),Card.new(card[3]),Card.new(card[4]),Card.new(card[5]),Card.new(card[6])] rank4=evaluator.evaluate(board,hand) return rank4
def getRankBoard(card): board1=[Card.new(card[2]),Card.new(card[3])] evaluator=Evaluator() board2=[Card.new(card[4]),Card.new(card[5]),Card.new(card[6])] rankboard=evaluator.evaluate(board1,board2) return rankboard
def __init__(self, card_strs):
self.cards = [Card.new(x) for x in card_strs]
def add_card(self, new_card_str):
self.cards.append(Card.new(new_card_str))
from rlofc.royalty_calculator import RoyaltyCalculator
from deuces import Card
no_pair = [Card.new(x) for x in ['2h', '9c', '3d', '4d', '5d']]
one_pair = [Card.new(x) for x in ['Ah', 'Th', '8h', '5h', '5c']]
two_pair = [Card.new(x) for x in ['Ah', 'Th', 'Th', '5h', '5c']]
trips = [Card.new(x) for x in ['Ah', 'Th', '8h', '8d', '8c']]
straight = [Card.new(x) for x in ['Ah', 'Kh', 'Qh', 'Jh', 'Tc']]
flush = [Card.new(x) for x in ['Ah', 'Th', '8h', '5h', '4h']]
boat = [Card.new(x) for x in ['Ah', 'As', 'Ac', '8d', '8c']]
quads = [Card.new(x) for x in ['Ah', 'As', 'Ac', 'Ad', 'Kc']]
sf = [Card.new(x) for x in ['Ah', '2h', '3h', '4h', '5h']]
royal = [Card.new(x) for x in ['Ah', 'Kh', 'Qh', 'Jh', 'Th']]
def test_back_royalties():
assert RoyaltyCalculator.score_back_royalties(no_pair) == 0
assert RoyaltyCalculator.score_back_royalties(one_pair) == 0
assert RoyaltyCalculator.score_back_royalties(two_pair) == 0
assert RoyaltyCalculator.score_back_royalties(trips) == 0
assert RoyaltyCalculator.score_back_royalties(straight) == 2
assert RoyaltyCalculator.score_back_royalties(flush) == 4
assert RoyaltyCalculator.score_back_royalties(boat) == 6
assert RoyaltyCalculator.score_back_royalties(quads) == 10
assert RoyaltyCalculator.score_back_royalties(sf) == 15
assert RoyaltyCalculator.score_back_royalties(royal) == 35
def test_mid_royalties():
assert RoyaltyCalculator.score_mid_royalties(no_pair) == 0
def getHandScore(self):
hand = [Card.new(c) for c in self.hole_cards]
board = [Card.new(c) for c in self.community_cards]
return self.evaluator.evaluate(board, hand)
from deuces import Card, Evaluator, Deck
# create a board and hole cards
board = []
hand = [
Card.new('2s'),
Card.new('5c')
]
hand2 = [
Card.new('2s'),
Card.new('7c')
]
# create an evaluator
evaluator = Evaluator()
# and rank your hand
rank = evaluator.evaluate(board, hand)
rank2 = evaluator.evaluate(board, hand2)
print rank, rank2
def parse_cards(self, cards):
list = []
for tup in cards:
list.append(Card.new(self.ranks[tup[0]] + str(tup[1])))
return list
from deuces 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 "Rank for your hand is: %d" % rank
# 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)
def take_action(ws, event_name, data):
global MY_SITE
global HAND_CARDS
global BOARD_CARDS
global MINBET
if event_name in ["__game_prepare", "__game_start"]:
pass
elif event_name == "__new_round":
my_site, online_player_number = get_my_site(data)
hand_cards = [player for player in data['players'] if player['playerName'] == name_md5][0]['cards']
HAND_CARDS = [Card.new('{}{}'.format(hand_card[0], str.lower(hand_card[-1]))) for hand_card in hand_cards]
if my_site == 1:
MY_SITE = SB
return
elif my_site == 2:
MY_SITE = BB
return
elif online_player_number >= 8:
if my_site <= 4:
MY_SITE = UTG
return
if online_player_number - my_site >= 2:
MY_SITE = MP
return
if online_player_number - my_site >= 1:
MY_SITE = CO
return
else:
MY_SITE = BTN
return
else:
if my_site <= 3:
MY_SITE = UTG
return
if online_player_number - my_site >= 2:
MY_SITE = MP
return
if online_player_number - my_site >= 1:
MY_SITE = CO
return
else:
MY_SITE = BTN
return
elif event_name == "__bet":
BOARD_CARDS = [Card.new('{}{}'.format(card[0], str.lower(card[-1]))) for card in data['game']['board']]
MINBET = data['self']['minBet']
Card.print_pretty_cards(HAND_CARDS + BOARD_CARDS)
win_prob = poker_deuces.calculate_winning_probability(HAND_CARDS, BOARD_CARDS, len(
[player for player in data['game']['players'] if not player['folded']]), SAMPLE_COUNT)
print('my winning probability: {}%'.format(win_prob * 100))
ws.send(json.dumps({
"eventName": "__action",
"data": {
"action": "bet"
}
}))
elif event_name == "__action":
BOARD_CARDS = [Card.new('{}{}'.format(card[0], str.lower(card[-1]))) for card in data['game']['board']]
MINBET = data['self']['minBet']
Card.print_pretty_cards(HAND_CARDS + BOARD_CARDS)
win_prob = poker_deuces.calculate_winning_probability(HAND_CARDS, BOARD_CARDS, len([player for player in data['game']['players'] if not player['folded']]), SAMPLE_COUNT)
print('my winning probability: {}%'.format(win_prob * 100))
ws.send(json.dumps({
"eventName": "__action",
"data": {
"action": "call"
}
}))
elif event_name == "__show_action":
BOARD_CARDS = [Card.new('{}{}'.format(card[0], str.lower(card[-1]))) for card in data['table']['board']]
# MINBET = data['action']['amount']
win_prob = poker_deuces.calculate_winning_probability(HAND_CARDS, BOARD_CARDS, len(
[player for player in data['players'] if not player['folded']]), SAMPLE_COUNT)
Card.print_pretty_cards(HAND_CARDS + BOARD_CARDS)
print('my winning probability: {}%'.format(win_prob * 100))
elif event_name == "__round_end":
MY_SITE = None
MINBET = None
HAND_CARDS = []
BOARD_CARDS = []
print('Round End')
elif event_name == "__game_over":
print('Game Over')
os._exit(0)
else:
pass
from deuces 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 "Rank for your hand is: %d" % rank
# 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)
if rank_class in [0, 1, 5]:
return True
return False
evaluator = Evaluator()
cards = ['Ah', 'Kh', 'Qh', 'Jh', 'Th', '9h', '8h',
'7h', '6h', '5h', '4h', '3h', '2h']
perms = []
for i in xrange(len(cards)):
for j in xrange(i, len(cards)):
for k in xrange(j, len(cards)):
perms.append([Card.new(cards[i]),
Card.new(cards[j]),
Card.new(cards[k])])
front_lookup = {}
for perm in perms:
# Add the two lowest unpairing cards
hand = copy(perm)
hand.append(get_lowest_unpairing_card(hand))
hand.append(get_lowest_unpairing_card(hand))
prime_prod = Card.prime_product_from_hand(perm)
rank = evaluator.evaluate(hand, []) + 1
kicker = Card.get_rank_int(perm[0]) * 0.01 + \
Card.get_rank_int(perm[1]) * 0.0001 + \
def str_to_cards(cardsstr):
cards = []
for cardstr in cardsstr:
card = Card.new(cardstr)
cards.append(card)
return cards
