def hand_strength(self, board):
''' hand strength '''
evaluator = deuces.Evaluator()
b5 = self.best_five(board)
h1 = b5[:2].replace('S',
's').replace('H',
'h').replace('D',
'd').replace('C', 'c')
h2 = b5[3:5].replace('S',
's').replace('H',
'h').replace('D',
'd').replace('C', 'c')
b1 = b5[6:8].replace('S',
's').replace('H',
'h').replace('D',
'd').replace('C', 'c')
b2 = b5[9:11].replace('S',
's').replace('H',
'h').replace('D',
'd').replace('C', 'c')
b3 = b5[12:14].replace('S', 's').replace('H', 'h').replace(
'D', 'd').replace('C', 'c')
hl = [deuces.Card.new(h1), deuces.Card.new(h2)]
bl = [deuces.Card.new(b1), deuces.Card.new(b2), deuces.Card.new(b3)]
strength = evaluator.evaluate(bl, hl)
return strength
def get_winner(self):
evaluator = deuces.Evaluator()
winner = 0
best_score = 8000
scores = "Each hand has been scored:"
for uid in p.in_game:
hand = []
#Generate a hand that the deuces module understands
for card in p.players[uid].hand.cards:
rank = str(card.rank)
if rank == '10':
rank = 'T'
suit = card.suit.lower()
hand.append(deuces.Card.new(rank + suit))
p.players[uid].score = evaluator.evaluate([], hand)
p.players[uid].rank_class = evaluator.get_rank_class(p.players[uid].score)
if p.players[uid].score < best_score:
best_score = p.players[uid].score
winner = uid
scores = scores + " " + p.players[uid].name + " - " + str(evaluator.class_to_string(p.players[uid].rank_class)) + ","
del evaluator
scores = scores[:-1]
self.phenny.say(scores)
winnings = self.betting_pot - p.players[winner].bet
house = (winnings * 0.05)
casino.gold += house
winnings = (winnings * 0.95)
p.players[winner].win(self.phenny, self.betting_pot)
self.phenny.say("%s has the highest ranking hand! They won %d gold! They now have %d gold. %d gold was taken by the house." % (p.players[winner].name, winnings, p.players[winner].gold, house))
def process_user_class(self):
# Save in a dict
rank_dict = {}
board = list(eval(self.dealer_cards))
# create an evaluator
evaluator = deuces.Evaluator()
if self.player_cards and self.player_cards != '':
player_cards_dict = eval(self.player_cards)
else:
player_cards_dict = {}
if self.player_active_dict and self.player_active_dict != '':
player_active_dict = eval(self.player_active_dict)
else:
player_active_dict = {}
for player in player_cards_dict:
if player_active_dict[player]:
hand = player_cards_dict[player]
# and rank your hand
rank = evaluator.evaluate(board, hand)
else:
rank = -1
rank_dict[player] = rank
return rank_dict
def generate_postflop_odds(preflop_type, deck):
"""
For each of the six preflop buckets, calculates the odds of the postflop cards putting the hand into one of the five
hand strength buckets.
"""
evaluator=deuces.Evaluator()
postflop_odds=[]
for type in preflop_type: #Loops through each of the preflop buckets
odds=[0, 0, 0, 0, 0]
for hand in type: #Loops through each hand in the bucket
new_deck=deck[:]
new_deck.remove(hand[0]) #Removes the cards in the current hand from the deck
new_deck.remove(hand[1])
postflop_hands=list(itertools.combinations(new_deck, 5))
for i in range(10000): #Doesn't loop through all possible five board cards for each hole card, only picks 50 random ones and estimates odds of going from one bucket to another
board=postflop_hands.pop(random.randint(0, len(postflop_hands)-1))
hand_strength=get_hand_strength(hand, board, evaluator)
if hand_strength<=.2:
odds[0]+=1
elif hand_strength>.2 and hand_strength<=.4:
odds[1]+=1
elif hand_strength>.4 and hand_strength<=.6:
odds[2]+=1
elif hand_strength>.6 and hand_strength<=.8:
odds[3]+=1
else:
odds[4]+=1
total=sum(odds)
for i in range(len(odds)):
odds[i]=odds[i]/float(total)
print(odds)
postflop_odds.append(odds)
return postflop_odds
def calculate_winner(g):
'''
Given 5 cards, calculates who has the stronger hand.
'''
player_1_hand = [
deuces.Card.new(g.cards_in_play[0]),
deuces.Card.new(g.cards_in_play[1])
]
player_2_hand = [
deuces.Card.new(g.cards_in_play[2]),
deuces.Card.new(g.cards_in_play[3])
]
board = [
deuces.Card.new(g.cards_in_play[4]),
deuces.Card.new(g.cards_in_play[5]),
deuces.Card.new(g.cards_in_play[6])
]
evaluator = deuces.Evaluator()
player_1_hand_value = evaluator.evaluate(board, player_1_hand)
player_2_hand_value = evaluator.evaluate(board, player_2_hand)
if player_1_hand_value < player_2_hand_value:
return g.tree.players[0]
elif player_1_hand_value > player_2_hand_value:
return g.tree.players[1]
else:
return None
def __init__(self, qntd_players):
self.game_deck = deuces.Deck()
self.game_players = [self.game_deck.draw(2), self.game_deck.draw(2)]
self.last_act = [1, 1]
self.board = self.game_deck.draw(5)
self.player_turn = 0
self.now = 'bet'
self.state = 1
self.eval = deuces.Evaluator()
def __init__(self, qntd_players):
# self.game_deck = deuces.deck
# self.player_turn = 0
# self.state = 0
# self.game = game(qntd_players)
# self.game.board = self.game.game_deck.draw(5)
# self.game.players = [self.game.game_deck.draw(2),self.game.game_deck.draw(2)]
# self.players_list = self.game.player_on
self.game_deck = deuces.Deck()
self.game_players = [self.game_deck.draw(2), self.game_deck.draw(2)]
self.last_act = [1, 1]
self.board = self.game_deck.draw(5)
self.player_turn = 0
self.state = 1
self.eval = deuces.Evaluator()
def calc_win_prob_by_sampling(hole_cards, board_cards, data):
"""
Calculate the probability to win current players by sampling unknown cards
Compute the probability to win one player first
And then take the power of virtual player count
"""
evaluator = deuces.Evaluator()
o_hole_cards = []
o_board_cards = []
for card in hole_cards:
o_hole_card = deuces.Card.new(card)
o_hole_cards.append(o_hole_card)
for card in board_cards:
o_board_card = deuces.Card.new(card)
o_board_cards.append(o_board_card)
n = 1000
win = 0
succeeded_sample = 0
for i in range(n):
deck = deuces.Deck()
board_cards_to_draw = 5 - len(o_board_cards)
o_board_sample = o_board_cards + deck.draw(board_cards_to_draw)
o_hole_sample = deck.draw(2)
try:
my_rank = evaluator.evaluate(o_board_sample, o_hole_cards)
rival_rank = evaluator.evaluate(o_board_sample, o_hole_sample)
except:
continue
if my_rank <= rival_rank:
win += 1
succeeded_sample += 1
print "==== sampling result ==== win : %d, total : %d" % (win,
succeeded_sample)
win_one_prob = win / float(succeeded_sample)
win_all_prob = win_one_prob**virtual_player_count(data)
print "==== Win probability ==== " + str(win_all_prob)
return win_all_prob
def transform_sampling(sim_num, hole_cards, board_cards, data, is_max):
eval_hand = [getCard(card) for card in (hole_cards)]
eval_board = [getCard(card) for card in (board_cards)]
d_hands = [deuces.Card.new(card) for card in hole_cards]
evaluator = deuces.Evaluator()
SUIT_TO_STRING = {
1: "s",
2: "h",
3: "d",
4: "c"
}
RANK_TO_STRING = {
2: "2",
3: "3",
4: "4",
5: "5",
6: "6",
7: "7",
8: "8",
9: "9",
10: "T",
11: "J",
12: "Q",
13: "K",
14: "A"
}
win = 0
succeeded_sample = 0
num_players = player_count[str(data["game"]["roundName"])]
#print "Is max? %s" % is_max
for i in range(sim_num):
board_cards_to_draw = 5 - len(eval_board)
e_board_sample = eval_board + _pick_unused_card(board_cards_to_draw, eval_board+eval_hand) # exclude my cards and community cards
unused_cards = _pick_unused_card((num_players - 1) * 2, eval_hand + e_board_sample)
e_opponents_hole = [unused_cards[2 * i:2 * i + 2] for i in range(num_players - 1)]
d_oppo_sample = []
d_oppo_set = []
d_board_sample = []
for evalcard in e_board_sample: # pokereval Card type
s_hand = str(RANK_TO_STRING[evalcard.rank]) + str(SUIT_TO_STRING[evalcard.suit])
d_board_card = deuces.Card.new(s_hand)
d_board_sample.append(d_board_card)
for evalcardset in e_opponents_hole:
d_oppo_set = []
for e_card in evalcardset:
s_hand = str(RANK_TO_STRING[e_card.rank]) + str(SUIT_TO_STRING[e_card.suit])
d_oppo_card = deuces.Card.new(s_hand)
d_oppo_set.append(d_oppo_card)
#print ("Opponents hands : "+s_hand)
d_oppo_sample.append(d_oppo_set)
try:
my_rank = evaluator.evaluate(d_hands, d_board_sample)
rival_rank = [evaluator.evaluate(opp_hole, d_board_sample) for opp_hole in d_oppo_sample]
#my_rank = pow(evaluator.evaluate(d_hands, d_board_sample), num_players)
#rival_rank = [pow(evaluator.evaluate(opp_hole, d_board_sample), num_players) for opp_hole in d_oppo_sample]
except:
continue
if is_max == 'true':
if my_rank <= max(rival_rank):
win += 1
else:
if my_rank <= min(rival_rank):
win += 1
succeeded_sample += 1
#print "number of min method called: %d, win: %d, total: %d" %(minnum, win, succeeded_sample)
return (win, succeeded_sample)
username=user,
password=pw,
user_agent='Dealer bot v{} by /u/eganwall'.format(version))
# initialize our repository and logger
sg_repo = SG_Repository.Repository()
logger = SG_Utils.LogUtility()
# get our messaging classes
error_messages = SG_Messages.ErrorMessages
reply_messages = SG_Messages.ReplyMessages
constants = SG_Messages.MiscConstants
# initialize the classes we need to run the poker game
card = deuces.Card()
evaluator = deuces.Evaluator()
def handle_message(ch, method, properties, body):
# get current time for elapsed time tracking
start_time = time.time()
message = json.loads(body)
# get the comment instance so we can reply to it
comment = reddit.comment(message['comment_id'])
# get the player from the DB so we can validate their wager
# and update their balance
player = sg_repo.GET_PLAYER_BY_USERNAME(comment.author.name)
def win_prob(self, your_hand, river_cards, no_of_other_hands, sim=10000):
"""
Input Example:
Your Hand: ['Ah', '7c'] ---> Ace of Hearts and Seven of Clubs
River Cards: ['Ad', '2d', '6d'] --> Ace of Diamonds, 2 of Diamonds, 6 of Diamonds, and 2 others (always 5)
No of Others: 2 ---> 2 other players remain
Simulations: number of Monte Carlo simulations to run, default=10000
Output: Your win %
If river_cards are present: Use MC simulations to estimate odds
If no river_cards are present: Use lookup table to find pre-flop odds and return immediately
"""
if len(river_cards) == 0: #Pre-flop, compute with lookup table
if your_hand[0][1] == your_hand[1][1]: #suited
return helper.preflop([
your_hand[0][0] + your_hand[1][0] + 's',
your_hand[1][0] + your_hand[0][0] + 's'
], no_of_other_hands + 1)
else: #unsuited
return helper.preflop([
your_hand[0][0] + your_hand[1][0] + 'o',
your_hand[1][0] + your_hand[0][0] + 'o'
], no_of_other_hands + 1)
else:
possible_cards = [a + b for a in vals for b in suits]
for card in your_hand:
possible_cards.remove(card)
for card in river_cards:
possible_cards.remove(card)
wins = 0
num_cards = 5 - len(river_cards) + 2 * no_of_other_hands
evaluator = d.Evaluator()
for i in range(sim): #10,000 MC simulations
generated_cards = np.random.choice(possible_cards,
num_cards,
replace=False)
counter = 0
my_hand = [d.Card.new(card) for card in your_hand]
board = [d.Card.new(card) for card in river_cards]
while len(board) < 5:
board.append(d.Card.new(generated_cards[counter]))
counter += 1
hand_strength = evaluator.evaluate(board, my_hand)
best_strength = 1e10 #some random large number
no_best_hands = 1 #number of hands that are at best_strength
for j in range(no_of_other_hands):
new_hand = [
d.Card.new(generated_cards[counter]),
d.Card.new(generated_cards[counter + 1])
]
counter += 2
new_strength = evaluator.evaluate(board, new_hand)
if new_strength < best_strength:
best_strength = new_strength
no_best_hands = 1 #reset
elif new_strength == best_strength:
no_best_hands += 1 #add one more
if best_strength > hand_strength:
wins += 1
elif best_strength == hand_strength:
wins += 1 / no_best_hands
return wins / sim
def getPostFlopAction(valid_actions, hand, board, stack, last_action):
evaluator = de.Evaluator()
# return your current hand value the 10 moves will be ascribed accordingly
evaluation = evaluator.get_five_card_rank_percentage(
evaluator.evaluate(hand, board))
actionProb = (1 - evaluation) * 100
if actionProb <= 10:
fold_action_info = valid_actions[0]
action, amount = fold_action_info["action"], fold_action_info["amount"]
elif actionProb > 10 and actionProb <= 55:
call_action_info = valid_actions[1]
action, amount = call_action_info["action"], call_action_info["amount"]
# no simple raise possible anymore
elif valid_actions[2]["amount"]["min"] == -1:
if valid_actions[1]["amount"] >= stack:
action, amount = valid_actions[1]["action"], valid_actions[1][
"amount"]
else:
amount = valid_actions[1]["amount"] - int(last_action[1]) + stack
action = valid_actions[2]["action"]
elif actionProb > 55 and actionProb <= 65:
raise_action_info = valid_actions[2]
action, amount = raise_action_info["action"], raise_action_info[
"amount"]["min"]
elif actionProb > 65 and actionProb <= 70:
raise_action_info = valid_actions[2]
amount_call_action = valid_actions[1]["amount"]
action = raise_action_info["action"]
amount = (raise_action_info["amount"]["min"] -
amount_call_action) * 1.5 + amount_call_action
elif actionProb > 70 and actionProb <= 75:
raise_action_info = valid_actions[2]
amount_call_action = valid_actions[1]["amount"]
action = raise_action_info["action"]
amount = (raise_action_info["amount"]["min"] -
amount_call_action) * 2 + amount_call_action
elif actionProb > 75 and actionProb <= 80:
raise_action_info = valid_actions[2]
amount_call_action = valid_actions[1]["amount"]
action = raise_action_info["action"]
amount = (raise_action_info["amount"]["min"] -
amount_call_action) * 3 + amount_call_action
elif actionProb > 80 and actionProb <= 85:
raise_action_info = valid_actions[2]
amount_call_action = valid_actions[1]["amount"]
action = raise_action_info["action"]
amount = (raise_action_info["amount"]["min"] -
amount_call_action) * 5 + amount_call_action
elif actionProb > 85 and actionProb <= 90:
raise_action_info = valid_actions[2]
amount_call_action = valid_actions[1]["amount"]
action = raise_action_info["action"]
amount = (raise_action_info["amount"]["min"] -
amount_call_action) * 10 + amount_call_action
elif actionProb > 90 and actionProb <= 95:
raise_action_info = valid_actions[2]
amount_call_action = valid_actions[1]["amount"]
action = raise_action_info["action"]
amount = (raise_action_info["amount"]["min"] -
amount_call_action) * 25 + amount_call_action
else:
raise_action_info = valid_actions[2]
action, amount = raise_action_info["action"], raise_action_info[
"amount"]["max"]
if valid_actions[2]["amount"]["max"] != -1:
if action == "raise" and amount > valid_actions[2]["amount"]["max"]:
amount = valid_actions[2]["amount"]["max"]
return action, int(amount)
def run():
SUIT_TO_STRING = {1: "s", 2: "h", 3: "d", 4: "c"}
RANK_TO_STRING = {
2: "2",
3: "3",
4: "4",
5: "5",
6: "6",
7: "7",
8: "8",
9: "9",
10: "T",
11: "J",
12: "Q",
13: "K",
14: "A"
}
hole_cards = ['4s', 'Qh']
board_cards = ['Jc', '6c', '9h']
#board_cards = []
eval_hand = [getCard(card) for card in (hole_cards)]
print eval_hand.__repr__()
eval_board = [getCard(card) for card in (board_cards)]
print eval_board.__repr__()
d_hands = [deuces.Card.new(card) for card in hole_cards]
evaluator = deuces.Evaluator()
sim_num = 15000
win = 0
succeeded_sample = 0
num_players = 6
for i in range(sim_num):
board_cards_to_draw = 5 - len(eval_board)
e_board_sample = eval_board + _pick_unused_card(
board_cards_to_draw,
eval_board + eval_hand) # exclude my cards and community cards
unused_cards = _pick_unused_card((num_players - 1) * 2,
eval_hand + e_board_sample)
e_opponents_hole = [
unused_cards[2 * i:2 * i + 2] for i in range(num_players - 1)
]
d_oppo_sample = []
d_oppo_set = []
d_board_sample = []
for evalcard in e_board_sample: # pokereval Card type
s_hand = str(RANK_TO_STRING[evalcard.rank]) + str(
SUIT_TO_STRING[evalcard.suit])
d_board_card = deuces.Card.new(s_hand)
d_board_sample.append(d_board_card)
#print ("Community : "+s_hand)
for evalcardset in e_opponents_hole:
d_oppo_set = []
for e_card in evalcardset:
s_hand = str(RANK_TO_STRING[e_card.rank]) + str(
SUIT_TO_STRING[e_card.suit])
d_oppo_card = deuces.Card.new(s_hand)
d_oppo_set.append(d_oppo_card)
#print ("Opponents hands : "+s_hand)
d_oppo_sample.append(d_oppo_set)
try:
my_rank = pow(evaluator.evaluate(d_hands, d_board_sample),
num_players)
rival_rank = [
pow(evaluator.evaluate(opp_hole, d_board_sample), num_players)
for opp_hole in d_oppo_sample
]
#print str(my_rank) +" versus "+str(rival_rank)
except:
continue
if my_rank <= min(rival_rank):
win += 1
succeeded_sample += 1
print "==== Sampling result ==== win : %d, total : %d" % (win,
succeeded_sample)
win_one_prob = win / float(succeeded_sample)
print "==== Win probability ==== " + str(win_one_prob)