def test(response): deck = build_deck() board = [] hole = [] hole2 = [] response = "" for i in range(5): card = compute_draw_card(deck) board.append(Card(card.power, card.suit)) response = response + " " + card.name response = response + "-------- P1 " for i in range(2): card = compute_draw_card(deck) hole.append(Card(card.power, card.suit)) response = response + " " + card.name response = response + "-------- P2 " for i in range(2): card = compute_draw_card(deck) hole2.append(Card(card.power, card.suit)) response = response + " " + card.name response = response + "------------ Score " score = HandEvaluator.evaluate_hand(hole, board) score2 = HandEvaluator.evaluate_hand(hole2, board) return HttpResponse(response + "" + str(score) + " " + str(score2))
def get_win_prob(self, hand_cards, board_cards, simulation_number, num_players):
win = 0
round=0
evaluator = HandEvaluator()
for i in range(simulation_number):
board_cards_to_draw = 5 - len(board_cards) # 2
board_sample = board_cards + self._pick_unused_card(board_cards_to_draw, board_cards + hand_cards)
unused_cards = self._pick_unused_card((num_players - 1)*2, hand_cards + board_sample)
opponents_hole = [unused_cards[2 * i:2 * i + 2] for i in range(num_players - 1)]
temp = []
try:
for hole in opponents_hole:
temp = hole + board_sample
opponents_score = pow(evaluator.evaluate_hand(hole, board_sample), num_players)
#opponents_score = [pow(evaluator.evaluate_hand(hole, board_sample), num_players) for hole in opponents_hole]
# hand_sample = self._pick_unused_card(2, board_sample + hand_cards)
my_rank = pow(evaluator.evaluate_hand(hand_cards, board_sample), num_players)
if my_rank > max(opponents_score):
win += 1
elif my_rank == max(opponents_score):
win += 0.5
#rival_rank = evaluator.evaluate_hand(hand_sample, board_sample)
round += 1
except Exception, e:
self.logger.error('exception={}, temp={}'.format(e.message, temp))
continue
def play_game(num_opponents, hand, community, deck): # Shuffle the deck and create a copy of the community cards shuffle(deck) community_copy = [Card(*c) for c in community] # Deal cards to each opponent opponents = [] for i in range(num_opponents): c1 = deck[i * 2] c2 = deck[i * 2 + 1] opponents.append([Card(*c1), Card(*c2)]) # Fill up the community cards for i in range(5 - len(community)): c = deck[num_opponents * 2 + i] community_copy.append(Card(*c)) # Score each opponent max_opponent = max([HandEvaluator.evaluate_hand(opponent, community_copy) for opponent in opponents]) # Score my hand my_hand = [Card(*c) for c in hand] my_score = HandEvaluator.evaluate_hand(my_hand, community_copy) # Calculate the winner if my_score > max_opponent: return True elif my_score == max_opponent: return random() > 0.5 else: return False
def play(self):
self.players[self.dealer].stack -= self.blind;
self.players[1-self.dealer].stack -= self.blind/2;
self.pot += 3*self.blind/2;
while True:
self.deal();
self.table.update_action('', 0);
self.table.update_action('', 1);
self.updateTable()
self.printStatus();
print self.board;
winner = self.bid();
if winner > -1:
break;
if self.state == "done":
board = [self.deck.cardstoC[c] for c in self.board];
hole0 = [self.deck.cardstoC[c] for c in self.players[0].cards]
hole1 = [self.deck.cardstoC[c] for c in self.players[1].cards]
score0 = HandEvaluator.evaluate_hand(hole0, board)
score1 = HandEvaluator.evaluate_hand(hole1, board)
self.state = "show_cards";
self.updateTable();
winner = 0;
if score1 > score0:
winner = 1;
time.sleep(2);
break;
print self.players[winner].name + ' won the hand.\n'
self.players[winner].stack += self.pot;
self.players[winner].num_of_hands_won += 1;
return winner;
def get_win_prob(self, hand_cards, board_cards, simulation_number, num_players):
"""Calculate the win probability from your board cards and hand cards by using simple Monte Carlo method.
Args:
board_cards: The board card list.
hand_cards: The hand card list
Examples:
# >>> get_win_prob(["8H", "TS", "6C"], ["7D", "JC"])
"""
win = 0
round = 0
evaluator = HandEvaluator()
for i in range(simulation_number):
board_cards_to_draw = 5 - len(board_cards) # 2
board_sample = board_cards + self._pick_unused_card(board_cards_to_draw, board_cards + hand_cards)
unused_cards = self._pick_unused_card((num_players - 1) * 2, hand_cards + board_sample)
opponents_hole = [unused_cards[2 * i:2 * i + 2] for i in range(num_players - 1)]
try:
opponents_score = [pow(evaluator.evaluate_hand(hole, board_sample), num_players) for hole in
opponents_hole]
# hand_sample = self._pick_unused_card(2, board_sample + hand_cards)
my_rank = pow(evaluator.evaluate_hand(hand_cards, board_sample), num_players)
if my_rank >= max(opponents_score):
win += 1
# rival_rank = evaluator.evaluate_hand(hand_sample, board_sample)
round += 1
except Exception, e:
print e.message
continue
def get_log_data(state, player_index):
# 'log_data', ['player_name', 'round', 'number_players', 'round_count', 'board', 'total_pot', 'action',
# 'amount', 'chips', 'hand', 'rank', 'big_blind', 'round_bet', 'phase_bet', 'win_money',
# 'isSB', 'isBB']
evaluator = HandEvaluator()
rank = evaluator.evaluate_hand(state.player_state[player_index].hand,
state.table_state.board)
alive_players = [
player for player in state.player_state if player.isSurvive
]
phase = ROUND_NAME_TO_NUM[state.table_state.round]
phase_raise = state.player_state[player_index].phase_raise[phase]
phase_raise = phase_raise - 1 if state.player_state[
player_index].action == 2 else phase_raise
last_phase_raise = -1 if phase == 0 else state.player_state[
player_index].phase_raise[phase - 1]
# isBTN
isSB = 1 if state.player_state[
player_index].player_name == state.table_state.small_blind else 0
isBB = 1 if state.player_state[
player_index].player_name == state.table_state.big_blind else 0
log_data = LOG_DATA(
state.player_state[player_index].player_name,
int(state.table_state.table_number),
int(state.table_state.round_count),
int(ROUND_NAME_TO_NUM[state.table_state.round]),
int(state.table_state.number_players),
state.table_state.board,
float((state.table_state.total_pot -
state.player_state[player_index].amount) /
state.table_state.big_blind_amount),
int(state.player_state[player_index].action),
float(state.player_state[player_index].amount /
state.table_state.big_blind_amount),
float((state.player_state[player_index].chips +
state.player_state[player_index].amount) /
state.table_state.big_blind_amount),
state.player_state[player_index].hand,
float(rank),
int(state.table_state.big_blind_amount),
float((state.player_state[player_index].round_bet -
state.player_state[player_index].amount) /
state.table_state.big_blind_amount),
float((state.player_state[player_index].bet -
state.player_state[player_index].amount) /
state.table_state.big_blind_amount),
int(phase_raise),
int(last_phase_raise),
int(state.player_state[player_index].last_action),
float(state.player_state[player_index].last_amount /
state.table_state.big_blind_amount),
0.0, # win_money
# isBTN,
int(isSB),
int(isBB))
return log_data
def declareAction(self, hole, board, round, my_Raise_Bet, my_Call_Bet,Table_Bet,number_players,raise_count,bet_count,my_Chips,total_bet):
# Aggresive -tight
self.number_players=number_players
my_Raise_Bet=(my_Chips*self.bet_tolerance)/(1-self.bet_tolerance)
print "Round:{}".format(round)
score = HandEvaluator.evaluate_hand(hole, board)
hand_score = HandEvaluator.evaluate_hand(hole, [])
print "score:{}".format(score)
#score = math.pow(score, self.number_players)
print "score:{}".format(score)
if round == 'preflop':
if score >= self.preflop_tight_loose_threshold:
action = 'call'
amount = my_Call_Bet
else:
action = 'fold'
amount = 0
else:
result = self.clf.predict([[hand_score, score]])
action = result[0]
if score >= self.aggresive_passive_threshold:
TableOdds = (my_Raise_Bet+total_bet) / float(my_Raise_Bet + Table_Bet)
if score >= TableOdds and action == "raise":
# action = 'raise'
amount = my_Raise_Bet
else:
TableOdds = (my_Call_Bet+total_bet) / float(my_Call_Bet + Table_Bet)
if score >= TableOdds and action == 'call':
# action = 'call'
amount = my_Call_Bet
elif action == 'fold':
# action = 'fold'
amount = 0
else:
amount = 0
else:
TableOdds = (my_Call_Bet+total_bet) / float(my_Call_Bet + Table_Bet)
if score >= TableOdds and action == 'call':
# action = 'call'
amount = my_Call_Bet
elif action == 'fold':
# action = 'fold'
amount = 0
else:
amount = 0
#if (action=='call' or action=='raise') and len(board)>=4:
#simulation_number=1000
#win_rate=self.get_win_prob(hole, board, simulation_number,number_players)
#if win_rate<0.4:
#action = 'fold'
#amount = 0
#print 'change'
return action, amount
def eval_cards(hand, table):
"""
Returns the cards' strength value evaluated with the pokereval
cards evaluation algorithm.
No cards on table (only hand cards are known):
>>> table = []
>>> hand = [('S', '2'), ('H', 'A')]
>>> eval_cards(hand, table)
0.6817496229260935
Three cards on table:
>>> table = [('D', '3'), ('D', 'J'), ('C', 'Q')]
>>> hand = [('S', '2'), ('H', 'A')]
>>> eval_cards(hand, table)
0.5074005550416282
Four cards on table:
>>> table = [('D', '3'), ('D', 'J'), ('C', 'Q'), ('C', 'K')]
>>> hand = [('S', '2'), ('H', 'A')]
>>> eval_cards(hand, table)
0.39468599033816426
Five cards on table:
>>> table = [('D', '3'), ('D', 'J'), ('C', 'Q'), ('C', 'K'), ('S', '10')]
>>> hand = [('S', '2'), ('H', 'A')]
>>> eval_cards(hand, table)
0.9348484848484848
"""
hand = [Card(*card) for card in card_values(hand)]
table = [Card(*card) for card in card_values(table)]
chance = HandEvaluator.evaluate_hand(hand, table)
return chance
def get_a3c_input(hand, board, round_name, total_pot, my_stack, big_blind,
my_cycle_bet):
cards_index = cards_to_index52(hand)
cards_index = cards_to_index52(board, cards_index)
# covert total_pot and my_stack to big_blind
total_pot_bb = total_pot / big_blind
my_stack_bb = my_stack / big_blind
percentage = HandEvaluator.evaluate_hand(hand, board)
# E = (state.community_state.totalpot + 2 * state.community_state.to_call)
# * percentage # calculate EV
E = percentage * (total_pot - my_cycle_bet) + \
(1 - percentage) * -1 * (my_cycle_bet)
ev = 0
if E > 0:
ev = 1
# convert round_name to num
if round_name not in ['Deal', 'Flop', 'Turn', 'River']:
raise Exception("Error: round_name is not correct")
if round_name == 'Deal':
round = 0
elif round_name == 'Flop':
round = 1
elif round_name == 'Turn':
round = 2
else:
round = 3
round = round / 3 # normalization
# return cards_index + [my_rank, round, total_pot_bb, my_stack_bb]
return cards_index + [round + ev]
def finish_hand(self): winner = "" if self.active_players > 1: self.compute_players() score = 0 board = [Card(self.flop1.power, self.flop1.suit), Card(self.flop2.power, self.flop2.suit) , Card(self.flop3.power, self.flop3.suit), Card(self.turn.power, self.turn.suit), Card(self.river.power, self.river.suit)] for player in self.players: hole = [Card(player.card1[0].power, player.card1[0].suit), Card(player.card2[0].power, player.card2[0].suit)] new_score = HandEvaluator.evaluate_hand(hole, board) if new_score > score: score = new_score winner = player else: winner = self.players[0] winner.stack = winner.stack + self.pot self.pot = 0 self.phase = 0 self.current_player = 0 self.active_players = len(self.all_players) self.checked_players = 0 self.to_pay = 0 self.players = [] self.deck = build_deck() for player in self.all_players: player.card1 = [compute_draw_card(self.deck)] player.card2 = [compute_draw_card(self.deck)] self.flop1 = compute_draw_card(self.deck) self.flop2 = compute_draw_card(self.deck) self.flop3 = compute_draw_card(self.deck) self.players = self.all_players[:]
def get_win_prob(self, hand_cards, board_cards, num_players):
"""Calculate the win probability from your board cards and hand cards by using simple Monte Carlo method.
Args:
board_cards: The board card list.
hand_cards: The hand card list
Examples:
>>> get_win_prob(["8H", "TS", "6C"], ["7D", "JC"])
"""
LOG.info(
"------------MontecarloPokerBot get_win_prob---------------------")
win = 0
round = 0
evaluator = HandEvaluator()
for i in range(self.simulation_number):
board_cards_to_draw = 5 - len(board_cards) # 2
LOG.info("board_cards_to_draw:{}".format(board_cards_to_draw))
board_sample = board_cards + self._pick_unused_card(
board_cards_to_draw, board_cards + hand_cards)
LOG.info("board_sample:{}".format(board_sample))
unused_cards = self._pick_unused_card((num_players - 1) * 2,
hand_cards + board_sample)
opponents_hole = [
unused_cards[2 * i:2 * i + 2] for i in range(num_players - 1)
]
LOG.info("opponents_hole:{}".format(opponents_hole))
hand_sample = self._pick_unused_card(2, board_sample + hand_cards)
LOG.info("hand_sample:{}".format(hand_sample))
try:
opponents_score = [
evaluator.evaluate_hand(hole, board_sample)
for hole in opponents_hole
]
LOG.info("opponents_score:{}".format(opponents_score))
my_rank = evaluator.evaluate_hand(hand_cards, board_sample)
LOG.info("my_rank:{}".format(my_rank))
if my_rank >= max(opponents_score):
win += 1
rival_rank = evaluator.evaluate_hand(hand_sample, board_sample)
LOG.info("rival_rank:{}".format(rival_rank))
round += 1
except Exception, e:
print "get_win_prob exception:{},{}".format(i, e)
continue
def get_hand_strength(self):
# poker eval uses a different representation, we must convert it first
hole = [_get_pokereval_representation(card) for card in self.hole]
community = [
_get_pokereval_representation(card) for card in self.community
]
score = HandEvaluator.evaluate_hand(hole, community)
LOG.info("Score %f" % score)
return score
def evaluate(self):
# if self.evaluate_flag:
# return self.score
hole = [Card(self.points[p], self.colors[c]) for c, p in self.cards]
board = [Card(self.points[p], self.colors[c]) for c, p in self.flops]
score = HandEvaluator.evaluate_hand(hole, board)
self.evaluate_flag = True
# print(score)
return score
def get_hand_strength(self):
# poker eval uses a different representation, we must convert it first
hole = [_get_pokereval_representation(card)
for card in self.hole]
community = [_get_pokereval_representation(card)
for card in self.community]
score = HandEvaluator.evaluate_hand(hole, community)
LOG.info("Score %f" % score)
return score
def get_win_prob(self, hand_cards, board_cards, simulation_number, num_players):
win = 0
round = 0
evaluator = HandEvaluator()
for i in range(simulation_number):
board_cards_to_draw = 5 - len(board_cards) # 2
board_sample = board_cards + self._pick_unused_card(board_cards_to_draw, board_cards + hand_cards)
unused_cards = self._pick_unused_card((num_players - 1) * 2, hand_cards + board_sample)
opponents_hole = [unused_cards[2 * i:2 * i + 2] for i in range(num_players - 1)]
opponents_score = [pow(evaluator.evaluate_hand(hole, board_sample), num_players) for hole in
opponents_hole]
my_rank = pow(evaluator.evaluate_hand(hand_cards, board_sample), num_players)
if my_rank >= max(opponents_score):
win += 1
round += 1
# The large rank value means strong hand card
win_prob = win / float(round)
print "win_prob:{}".format(win_prob), "Win:{}".format(win)
return win_prob
def act(self,observation, actionList):
if observation['state'] != "pre-flop":
possible_cards = [card for card in cardsList if (card not in observation['board'] and
card not in observation['player'].cards)];
possible_cards = [cardstoC[card] for card in possible_cards];
scores = []
board = [cardstoC[c] for c in observation['board']]
for (card1, card2) in itertools.combinations(possible_cards,2):
hole = [card1,card2]
scores.append(HandEvaluator.evaluate_hand(hole, board))
agent_cards = [cardstoC[c] for c in observation['player'].cards]
agent_score = HandEvaluator.evaluate_hand(agent_cards,board)
confidence = 1 - float(sum(np.greater(scores,agent_score)))/len(scores)
if (confidence > .7):
if ("bet" in actionList):
action = "bet"
else:
action = "call"
elif "check" in actionList:
action = "check"
else:
if confidence > .5:
action = "call"
else:
action = "fold"
else:
if "check" in actionList:
action = "check"
else:
action = "call"
if np.random.rand() < .2:
print "--------------------"
print "I'm bluffing: bet"
print "--------------------"
return "bet"
print "--------------------"
print action
print "--------------------"
return action
def pontuacao(self, j, mesa):
score = 0
for i in range(len(j)):
if ((j[i].noJogo == True) and (j[i].naRodada == True)):
j[i].score = HandEvaluator.evaluate_hand(j[i].mao, mesa.cartas)
for i in range(len(j)):
if ((j[i].noJogo == True) and (j[i].naRodada == True)):
if j[i].score > score:
score = j[i].score
for i in range(len(j)):
if ((j[i].noJogo == True) and (j[i].naRodada == True)):
if score == j[i].score:
j[i].venceuRodada()
print("Jogador %d venceu rodada" % (j[i].n))
def calculate_hand(request):
table = cache.get('table')
player = table.players[0]
board = []
for card in table.cards:
board.append(Card(card.power, card.suit))
hole = [Card(player.card1[0].power, player.card1[0].suit),
Card(player.card2[0].power, player.card2[0].suit)]
score = HandEvaluator.evaluate_hand(hole, board)
return HttpResponse(str(score))
def simulation(self, my_score, data, sim_num=1000):
return self.calc_win_prob_by_sampling_eval7(self.cards, self.board, data, sim_num)
eval_hand = getCard(self.cards)
eval_board = getCard(self.board)
evaluator = HandEvaluator()
win = 0
sampling = 0
for _ in range(sim_num):
board_cards_to_draw = 5 - len(eval_board)
board_sample = eval_board + pick_unused_card(board_cards_to_draw, eval_hand + eval_board)
unused_cards = pick_unused_card(2, eval_hand + board_sample)
opponents_hole = unused_cards[0:2]
try:
opponents_score = evaluator.evaluate_hand(opponents_hole, board_sample)
if opponents_score > my_score: # opponent win probability
win += 1
sampling += 1
except Exception:
continue
return win / float(sampling)
def declareAction(self, state, minBet, seat_num):
hole = state.player_state[seat_num].cards
board = state.table_state.board
my_rank = HandEvaluator.evaluate_hand(hole, board)
big_blind = state.table_state.big_blind_amount
chips = state.player_state[seat_num].chips
my_Raise_Bet = min(big_blind, int(chips / 4))
if my_rank > 0.85:
action = 'raise'
amount = my_Raise_Bet
elif my_rank > 0.6:
action = 'call'
amount = minBet
else:
action = 'fold'
amount = 0
return action, amount
from pokereval.card import Card from pokereval.hand_evaluator import HandEvaluator hole = [Card(2, 1), Card(2, 2)] board = [] score = HandEvaluator.evaluate_hand(hole, board)
def hand_value(self, table):
hand = [Card(*card) for card in utils.card_values(self.hand)]
table = [Card(*card) for card in utils.card_values(table)]
score = HandEvaluator.evaluate_hand(hand, table)
return score
def declareAction(self, state, minBet, seat_num):
hole = state.player_state[seat_num].cards
board = state.table_state.board
chips = state.player_state[seat_num].chips
round = state.table_state.round
# Aggresive -tight
self.number_players = len(
[player for player in state.player_state if player.isSurvive])
my_Raise_Bet = (chips * self.bet_tolerance) / (1 - self.bet_tolerance)
my_Call_Bet = minBet
Table_Bet = state.table_state.total_bet
total_bet = state.player_state[
seat_num].roundBet # how many chips you bet in this round
print "Round:{}".format(round)
score = HandEvaluator.evaluate_hand(hole, board)
print "score:{}".format(score)
# score = math.pow(score, self.number_players)
print "score:{}".format(score)
if round == 'Deal':
if score >= self.preflop_tight_loose_threshold:
action = 'call'
amount = my_Call_Bet
else:
action = 'fold'
amount = 0
else:
if score >= self.aggresive_passive_threshold:
TableOdds = (my_Raise_Bet + total_bet) / (my_Raise_Bet +
Table_Bet)
if score >= TableOdds:
action = 'raise'
amount = my_Raise_Bet
else:
TableOdds = (my_Call_Bet + total_bet) / (my_Call_Bet +
Table_Bet)
if score >= TableOdds:
action = 'call'
amount = my_Call_Bet
else:
action = 'fold'
amount = 0
else:
TableOdds = (my_Call_Bet + total_bet) / (my_Call_Bet +
Table_Bet)
if score >= TableOdds:
action = 'call'
amount = my_Call_Bet
else:
action = 'fold'
amount = 0
# if (action=='call' or action=='raise') and len(board)>=4:
# simulation_number=1000
# win_rate=self.get_win_prob(hole, board, simulation_number,number_players)
# if win_rate<0.4:
# action = 'fold'
# amount = 0
# print 'change'
return action, amount
def run(self, input_socket):
# Get a file-object for reading packets from the socket.
# Using this ensures that you get exactly one packet per read.
f_in = input_socket.makefile()
conv = create_pbots_hand_to_twohandeval_dict()
while True:
# Block until the engine sends us a packet.
data = f_in.readline().strip()
# If data is None, connection has closed.
if not data:
print "Gameover, engine disconnected."
break
# Here is where you should implement code to parse the packets from
# the engine and act on it. We are just printing it instead.
print data
# When appropriate, reply to the engine with a legal action.
# The engine will ignore all spurious responses.
# The engine will also check/fold for you if you return an
# illegal action.
# When sending responses, terminate each response with a newline
# character (\n) or your bot will hang!
data = data.split() # Split data into list
command = data[0]
if command == "NEWGAME":
hand = [""]*4 # Initialize hand to be empty
risk = 1
max_preflop_equity, max_flop_equity, max_turn_equity, max_river_equity = 0, 0, 0, 0 # Flush all equities
elif command == "NEWHAND":
if PLOT_FLAG == True:
MADBot_delta.append(str(data[-3]))
otherbot_delta.append(str(data[-2]))
hand = data[3:7]
two_pairs = return_pairs(hand)
convs_two_pairs = [(convert_pbots_hand_to_twohandeval(hole[0], conv), convert_pbots_hand_to_twohandeval(hole[1], conv)) for hole in two_pairs]
max_preflop_equity = max([HandEvaluator.evaluate_hand([Card(h[0][0], h[0][1]), Card(h[1][0], h[1][1])], []) for h in convs_two_pairs])
elif command == "GETACTION":
# Currently CHECK on every move. You'll want to change this.
print 'risk', risk
info = parse_GETACTION(data)
if info['numBoardCards'] == 0:
l, u = get_lower_and_upper_bounds(info["legalActions"][-1])[1]
if max_preflop_equity >= 0.99:
s.send("RAISE:" + str(u) + "\n")
elif max_preflop_equity >= 0.97:
avg = int((u+l)/2)
s.send("RAISE:" + str(avg) + "\n")
elif max_preflop_equity >= 0.95:
s.send("RAISE:" + str(l) + "\n")
else:
s.send("CALL\n")
elif info['numBoardCards'] == 3:
conv_all_cards = []
conv_board_cards = convert_list_to_card_list([convert_pbots_hand_to_twohandeval(card, conv) for card in info['boardCards']]) # in Card form
max_flop_equity = max([HandEvaluator.evaluate_hand([Card(h[0][0], h[0][1]), Card(h[1][0], h[1][1])], conv_board_cards) for h in convs_two_pairs])
cmd, (l, u) = get_lower_and_upper_bounds(info["legalActions"][-1])
if cmd != "CALL":
rand = random.random()
if risk < 0.1:
if (rand >= 0.05):
s.send("FOLD\n")
else:
if max_flop_equity >= 0.95:
if (rand < 0.05):
s.send("CHECK\n")
elif (risk < 0.2):
s.send(cmd + ":" + str(u) + "\n")
else:
s.send(cmd + ":" + str(u) + "\n")
elif max_flop_equity >= 0.90:
if (risk < 0.2):
if (rand < 0.1):
s.send("CALL\n")
elif (rand < 0.10):
s.send("CHECK\n")
else:
avg = int((2*u+l)/3)
s.send(cmd + ":" + str(avg) + "\n")
elif max_flop_equity >= 0.75:
if (risk < 0.2):
if (rand < 0.1):
s.send("CALL\n")
elif (rand < 0.10):
s.send("CHECK\n")
else:
avg = int((u+l)/2)
s.send(cmd + ":" + str(avg) + "\n")
elif max_flop_equity >= 0.60:
if (rand < 0.15) or risk < 0.2:
s.send("FOLD\n")
else:
s.send("CALL\n")
else:
if (rand < 0.05):
s.send("CALL\n")
else:
s.send("FOLD\n")
else:
s.send("CALL\n")
elif info['numBoardCards'] == 4:
conv_all_cards = []
conv_board_cards = convert_list_to_card_list([convert_pbots_hand_to_twohandeval(card, conv) for card in info['boardCards']]) # in Card form
max_flop_equity = max([HandEvaluator.evaluate_hand([Card(h[0][0], h[0][1]), Card(h[1][0], h[1][1])], conv_board_cards) for h in convs_two_pairs])
cmd, (l, u) = get_lower_and_upper_bounds(info["legalActions"][-1])
if cmd != "CALL":
rand = random.random()
if risk < 0.1:
if (rand >= 0.1):
s.send("FOLD\n")
else:
if max_flop_equity >= 0.95:
if (rand < 0.05):
s.send("CHECK\n")
elif (risk < 0.01):
s.send(cmd + ":" + str(u) + "\n")
else:
s.send(cmd + ":" + str(u) + "\n")
elif max_flop_equity >= 0.80:
if (risk < 0.2):
if (rand < 0.1):
s.send("FOLD\n")
else:
s.send("CHECK\n")
elif (rand < 0.10):
s.send("CHECK\n")
else:
avg = int((u+l)/2)
s.send(cmd + ":" + str(avg) + "\n")
elif max_flop_equity >= 0.50:
if (rand < 0.15) or risk < 0.2:
s.send("CHECK\n")
else:
s.send("FOLD\n")
else:
s.send("FOLD\n")
else:
s.send("CALL\n")
elif info['numBoardCards'] == 5:
conv_all_cards = []
conv_board_cards = convert_list_to_card_list([convert_pbots_hand_to_twohandeval(card, conv) for card in info['boardCards']]) # in Card form
max_flop_equity = max([HandEvaluator.evaluate_hand([Card(h[0][0], h[0][1]), Card(h[1][0], h[1][1])], conv_board_cards) for h in convs_two_pairs])
cmd, (l, u) = get_lower_and_upper_bounds(info["legalActions"][-1])
if cmd != "CALL":
rand = random.random()
if risk < 0.1:
if (rand >= 0.05):
s.send("FOLD\n")
else:
if max_flop_equity >= 0.95:
if (rand < 0.05):
s.send("CHECK\n")
elif (risk < 0.01):
s.send("CALL\n")
else:
s.send(cmd + ":" + str(u) + "\n")
elif max_flop_equity >= 0.85:
if (risk < 0.2):
if (rand < 0.1):
s.send("CALL\n")
elif (rand < 0.10):
s.send("CHECK\n")
else:
avg = int((u+l)/2)
s.send(cmd + ":" + str(avg) + "\n")
elif max_flop_equity >= 0.50:
if (rand < 0.15) or risk < 0.2:
s.send("CHECK\n")
else:
s.send("\n")
else:
if (rand < 0.15):
s.send("CALL\n")
else:
s.send("FOLD\n")
else:
s.send("CALL\n")
else:
s.send("CALL\n")
elif command == "REQUESTKEYVALUES":
# At the end, the engine will allow your bot save key/value pairs.
# Send FINISH to indicate you're done.
s.send("FINISH\n")
elif command == "HANDOVER":
hand = [""]*4 # Empty the hand
bankroll = int(data[1])
risk = 1
if bankroll < 100:
diff = 100 - bankroll
if (float(math.log(diff)/math.log(10))) == 0:
risk = 1
elif bankroll > -50:
risk = 1.0 / (float(math.log(diff)/math.log(10)))**(2)
else:
risk = 1.0 / (float(math.log(diff)/math.log(10)))**2
max_preflop_equity, max_flop_equity, max_turn_equity, max_river_equity = 0, 0, 0, 0 # Flush all equities
# Clean up the socket.
print MADBot_delta
print otherbot_delta
print "\n".join(MADBot_delta)
print "=================================================="
print "\n".join(otherbot_delta)
s.close()
def declareAction(self, hole, board, round, my_Raise_Bet, my_Call_Bet, Table_Bet, number_players, raise_count,
bet_count, my_Chips, total_bet):
score = HandEvaluator.evaluate_hand(hole, board)
print "score:{}".format(score)
allin_static_rate = 0.95
preflop_raise_static_rate = 0.98
preflop_call_static_rate = 0.95
flop_raise_static_rate = 0.9
flop_call_static_rate = 0.85
in_montecarlo_rate = 0.69
in_montecarlo_card = 4
if my_Chips + total_bet < 3000:
aggressive_by_chip = 3 - (my_Chips + total_bet) / 1000
else:
aggressive_by_chip = 1
if my_Call_Bet == 0:
action = 'call'
amount = my_Call_Bet
else:
if my_Call_Bet > my_Chips:
my_Call_Bet = my_Chips
call_odd = (((my_Call_Bet + total_bet) / float(my_Chips + total_bet)) ** 0.5) ** aggressive_by_chip
raise_odd = (call_odd ** 0.5) ** aggressive_by_chip
if round == 'preflop' or round == 'Deal':
if score >= raise_odd and score >= self.preflop_threshold or score >= preflop_raise_static_rate:
action = 'raise'
amount = my_Raise_Bet
elif score >= call_odd and score >= self.preflop_threshold or score >= preflop_call_static_rate:
action = 'call'
amount = my_Call_Bet
else:
action = 'fold'
amount = 0
else:
call_odd *= allin_static_rate
raise_odd *= allin_static_rate
if score >= allin_static_rate and len(board) >= in_montecarlo_card:
action = 'allin'
amount = 0
elif score >= allin_static_rate:
action = 'bet'
bet = ((my_Chips + total_bet) / 2) - total_bet
if bet <= total_bet:
bet = my_Call_Bet
amount = bet
elif score >= raise_odd and score >= self.flop_threshold or score >= flop_raise_static_rate:
action = 'raise'
amount = my_Raise_Bet
elif score >= call_odd and score >= self.flop_threshold or score >= flop_call_static_rate:
action = 'call'
amount = my_Call_Bet
else:
action = 'fold'
amount = 0
print "call=%s, raise=%s, score=%s, action=%s" % (call_odd, raise_odd, score, action)
if (action == 'call' or action == 'raise') and len(board) >= in_montecarlo_card and score <= in_montecarlo_rate:
simulation_number = 50
win_rate = self.get_win_prob(hole, board, simulation_number, number_players)
if win_rate < 0.20:
action = 'fold'
amount = 0
elif win_rate < 0.25:
action = 'call'
amount = my_Call_Bet
elif win_rate < 0.30:
action = 'raise'
amount = my_Raise_Bet
else:
action = 'allin'
amount = 0
print 'change'
return action, amount
def main():
game_file = 'HandLogs4/MADbot_vs_StraightOuttaCam'
player_1 = game_file.split('_vs_')[0][10:]
player_2 = game_file.split('_vs_')[1]
f = open(game_file, 'r')
lines = [line for line in f][1:]
full_game_string = ''
for line in lines:
full_game_string += line
game_buckets = full_game_string.split('\n\n')[:-1]
categories = defaultdict(list)
winner = defaultdict(list)
# Buckets all of the games into one of 6 categories:
# (1)full_game (players show their cards)
# Player 1 folds ((2)fold_after_river, (3)fold_after_turn, (4)fold_after_flop, (5)fold_before_flop)
# (2)opponent_folds (player 2 folds at some point in the game)
for game in game_buckets:
if player_1 + " shows" in game:
categories['full_game'] += [game]
elif player_1 + " folds" in game:
if "*** RIVER ***" in game:
categories['fold_after_river'] += [game]
elif "*** TURN ***" in game:
categories['fold_after_turn'] += [game]
elif "*** FLOP ***" in game:
categories['fold_after_flop'] += [game]
else:
categories['fold_before_flop'] += [game]
elif player_2 + " folds" in game:
categories['opponent_folds'] += [game]
if player_1 + " wins the pot" in game:
winner[player_1].append(game)
else:
winner[player_2].append(game)
preflops = []
p1_equities = []
for game in winner[player_1]:
if game not in categories['full_game']:
continue
player_1_hand, player_2_hand = get_players_hands(
game, player_1, player_2)
# Getting pre-flop statistics
# max_preflop = max([HandEvaluator.evaluate_hand([Card(h[0][0], h[0][1]), Card(h[1][0], h[1][1])], []) for h in player_1_hand])
# preflops.append(max_preflop)
# Getting post-flop statistics
game = game[game.index("*** RIVER ***"):]
table_cards = game[game.index("[") + 1:game.index("[") + 12].split()
table_cards_last = game[game.index("]") + 3:game.index("]") +
5].split()
# table_cards = game[game.index("[")+1:game.index("[")+9].split()
# table_cards_last = game[game.index("]")+3:game.index("]")+5].split()
table_cards = table_cards + table_cards_last
conv = create_pbots_hand_to_twohandeval_dict()
converted_board_cards = convert_list_to_card_list([
convert_pbots_hand_to_twohandeval(card) for card in table_cards
]) # in pbotseval form
max_flop_equity = max([
HandEvaluator.evaluate_hand(
[Card(h[0][0], h[0][1]),
Card(h[1][0], h[1][1])], converted_board_cards)
for h in player_1_hand
])
# if max_flop_equity > 0.99:
# print table_cards
# print player_1_hand
# print [HandEvaluator.evaluate_hand([Card(h[0][0], h[0][1]), Card(h[1][0], h[1][1])], converted_board_cards) for h in player_1_hand]
# print player_2_hand
# print [HandEvaluator.evaluate_hand([Card(h[0][0], h[0][1]), Card(h[1][0], h[1][1])], converted_board_cards) for h in player_2_hand]
p1_equities.append(max_flop_equity)
print len(p1_equities)
n, bins, patches = plt.hist(p1_equities,
100,
normed=1,
facecolor='green',
alpha=0.75)
plt.title('We won post river')
plt.show()
'8': 8,
'9': 9,
'T': 10,
'J': 11,
'Q': 12,
'K': 13,
'A': 14,
'O': -1,
'P': 0,
'S': 1
}
n_card1 = y[c_1]
n_card2 = y[c_2]
n_suited = y[suit]
ev_c = np.where(n_suited == 1,
ev.evaluate_hand([c(n_card1, 1),
c(n_card2, 1)]),
ev.evaluate_hand([c(n_card1, 1),
c(n_card2, 2)]))
df = df[df['ev'] == ev_c]
df = df[df['position'] == position]
df = df[df['action'] == action]
df_o = df.output_preflop.to_numpy()
df_c = df.class_preflop.to_numpy()
code = '''{} > {} > {} > {} > {}'''.format(
(c_1 + c_2 + suit), position, action, df_c[-1], df_o[-1])
st.code(code, language='python')
if st.button("{}".format(df_o[-1])):
session.run_id += 1
st.write("_" * 20)
QC KC 3S JC KD 2C 8D AH QS TS
AS KD 3D JD 8H 7C 8C 5C QD 6C"""
short_games = """5H 5C 6S 7S KD 2C 3S 8S 8D TD
5D 8C 9S JS AC 2C 5C 7D 8S QH
2D 9C AS AH AC 3D 6D 7D TD QD
4D 6S 9H QH QC 3D 6D 7H QD QS
2H 2D 4C 4D 4S 3C 3D 3S 9S 9D"""
from pokereval.card import Card
from pokereval.hand_evaluator import HandEvaluator
def card_from_string(s):
rank = list("xx23456789TJQKA").index(s[0])
suit = list("xSHDC").index(s[1])
return Card(rank, suit)
if __name__=="__main__":
count = 0
for game in games.splitlines():
cards = list(map(card_from_string, game.split()))
hand1 = cards[:5]
hand2 = cards[5:]
score1 = HandEvaluator.evaluate_hand(hand1)
score2 = HandEvaluator.evaluate_hand(hand2)
print("{0}:{1}\n{2}:{3}".format(hand1, score1, hand2, score2))
if score1 < score2:
count +=1
print(count)
def takeAction(self, action, data):
# Get number of players and table info
if action == "__game_start":
# print("Game Start")
table_number = data['tableNumber']
self.table = Table(table_number)
return False
elif action == "__new_round":
# print("New Round")
table_data = data['table']
players_data = data['players']
if self.table is None:
# raise ("Error: Table is None.")
table_number = table_data['tableNumber']
self.table = Table(table_number)
self.table.update_table_status(data)
if len(self.players) == 0: # first time join the game
for i, p in enumerate(players_data):
if p['playerName'] == self.md5_name:
self.players.append(
Player(p['playerName'], p['chips'], self.pokerbot))
else:
self.players.append(Player(p['playerName'],
p['chips']))
for i, p in enumerate(self.players):
p.new_round()
p.update_by_state(players_data[i])
return False
elif action == "__show_action":
player_index = utils.get_index_from_player_list(
data['action']['playerName'], self.players)
self.players[player_index].update_action(
data['action'], data['table']['roundName'])
# update table and player
self.table.update_table_status(data)
for i, p in enumerate(self.players):
p.update_by_state(data['players'][i])
return False
elif action == "__bet":
# print("Bet")
action, amount = self.getAction(data)
# print "action: {}".format(action)
# print "action amount: {}".format(amount)
self.ws.send(
json.dumps({
"eventName": "__action",
"data": {
"action": action,
"playerName": self.playerName,
"amount": amount
}
}))
return False
elif action == "__action":
# print("Action")
action, amount = self.getAction(data)
# print "action: {}".format(action)
# print "action amount: {}".format(amount)
self.ws.send(
json.dumps({
"eventName": "__action",
"data": {
"action": action,
"playerName": self.playerName,
"amount": amount
}
}))
return False
elif action == "__deal":
print "Deal Cards"
self.table.update_table_status(data)
for i, p in enumerate(self.players):
p.update_by_state(data['players'][i])
player_index = utils.get_index_from_player_list(
self.md5_name, self.players)
print "hands: {}, board: {}".format(
data['players'][player_index]['cards'], data['table']['board'])
return False
elif action == "__start_reload":
# print "Reload"
# self.ws.send(json.dumps({
# "eventName": "__reload",
# }))
# self.ws.send(json.dumps({
# "eventName": "__reload",
# }))
return False
elif action == "__round_end":
print "Round End"
state = utils.get_current_state(self.table, self.players)
player_index = utils.get_index_from_player_list(
self.md5_name, self.players)
player_data = data['players']
win_money = player_data[player_index]['winMoney']
evaluator = HandEvaluator()
rank = evaluator.evaluate_hand(
state.player_state[player_index].hand, state.table_state.board)
chips = player_data[player_index]['chips']
print "hands: {}, board: {}, rank: {}".format(
state.player_state[player_index].hand, state.table_state.board,
rank)
print "win money: {}, remain chips: {}".format(win_money, chips)
return False
elif action == "__game_over":
print "Game Over"
self.table = None
self.players = []
return True
def run(self, input_socket):
# Get a file-object for reading packets from the socket.
# Using this ensures that you get exactly one packet per read.
f_in = input_socket.makefile()
conv = create_pbots_hand_to_twohandeval_dict()
while True:
# Block until the engine sends us a packet.
data = f_in.readline().strip()
# If data is None, connection has closed.
if not data:
print "Gameover, engine disconnected."
break
# Here is where you should implement code to parse the packets from
# the engine and act on it. We are just printing it instead.
print data
# When appropriate, reply to the engine with a legal action.
# The engine will ignore all spurious responses.
# The engine will also check/fold for you if you return an
# illegal action.
# When sending responses, terminate each response with a newline
# character (\n) or your bot will hang!
data = data.split() # Split data into list
command = data[0]
if command == "NEWGAME":
hand = [""]*4 # Initialize hand to be empty
risk = 1
max_preflop_equity, max_flop_equity = 0, 0 # Flush all equities
elif command == "NEWHAND":
info = parse_NEWHAND(data)
myBank = info['myBank']
if PLOT_FLAG == True:
MADBot_delta.append(myBank)
otherbot_delta.append(info['otherBank'])
hand = info['holeCards']
hand_pairs = get_all_pairs(hand)
# converts engine's format to pokereval's format
converted_hand_pairs = [(convert_pbots_hand_to_twohandeval(hole[0], conv), convert_pbots_hand_to_twohandeval(hole[1], conv)) for hole in hand_pairs]
max_preflop_equity = max([HandEvaluator.evaluate_hand([Card(h[0][0], h[0][1]), Card(h[1][0], h[1][1])], []) for h in converted_hand_pairs])
elif command == "GETACTION":
info = parse_GETACTION(data)
rand = random.random()
if info['numBoardCards'] == 0:
safe = myBank > -3000
l, u = get_lower_and_upper_bounds(info["legalActions"][-1])[1]
if safe:
if info['potSize'] > 50:
s.send("CHECK\n")
else:
if max_preflop_equity > 0.99:
if rand >= 0.4:
s.send("RAISE:" + str(l) + "\n")
s.send("CALL\n")
else:
if max_preflop_equity >= 0.99 and info['potSize'] < 50:
s.send("CALL\n")
else:
s.send("CHECK\n")
elif info['numBoardCards'] == 3:
conv_all_cards = []
# converts engine's format to pokereval's format
converted_board_cards = convert_list_to_card_list([convert_pbots_hand_to_twohandeval(card, conv) for card in info['boardCards']]) # in Card form
max_flop_equity = max([HandEvaluator.evaluate_hand([Card(h[0][0], h[0][1]), Card(h[1][0], h[1][1])], converted_board_cards) for h in converted_hand_pairs])
cmd, (l, u) = get_lower_and_upper_bounds(info["legalActions"][-1])
if cmd != "CALL":
if max_flop_equity >= 0.97:
if rand > 0.7:
s.send(cmd+":" + str(u) + "\n")
elif rand > 0.3:
s.send(cmd+":" + str(l) + "\n")
else:
s.send("CALL\n")
elif max_flop_equity >= 0.90:
if rand > 0.5:
s.send(cmd+":" + str(l) + "\n")
else:
s.send("CALL\n")
elif max_flop_equity >= 0.80:
s.send("CALL\n")
else:
s.send("CHECK\n")
else:
if max_flop_equity >= 0.90:
s.send("CALL\n")
else:
s.send("CHECK\n")
elif info['numBoardCards'] == 4:
conv_all_cards = []
converted_board_cards = convert_list_to_card_list([convert_pbots_hand_to_twohandeval(card, conv) for card in info['boardCards']]) # in Card form
max_flop_equity = max([HandEvaluator.evaluate_hand([Card(h[0][0], h[0][1]), Card(h[1][0], h[1][1])], converted_board_cards) for h in converted_hand_pairs])
cmd, (l, u) = get_lower_and_upper_bounds(info["legalActions"][-1])
if cmd != "CALL":
if max_flop_equity >= 0.96:
if rand > 0.5:
s.send(cmd+":" + str(u) + "\n")
else:
s.send("CALL\n")
elif max_flop_equity >= 0.90:
s.send("CALL\n")
else:
s.send("CHECK\n")
else:
print "PRINTING THE COMMANDDDDDD"
print cmd
if max_flop_equity >= 0.90:
s.send("CALL\n")
else:
s.send("CHECK\n")
elif info['numBoardCards'] == 5:
conv_all_cards = []
conv_board_cards = convert_list_to_card_list([convert_pbots_hand_to_twohandeval(card, conv) for card in info['boardCards']]) # in Card form
max_flop_equity = max([HandEvaluator.evaluate_hand([Card(h[0][0], h[0][1]), Card(h[1][0], h[1][1])], conv_board_cards) for h in converted_hand_pairs])
cmd, (l, u) = get_lower_and_upper_bounds(info["legalActions"][-1])
if cmd != "CALL":
if max_flop_equity >= 0.95:
s.send(cmd+":" + str(u) + "\n")
elif max_flop_equity >= 0.90:
s.send("CALL\n")
else:
s.send("CHECK\n")
else:
print "PRINTING THE COMMANDDDDDD"
print cmd
if max_flop_equity >= 0.90:
s.send("CALL\n")
else:
s.send("CHECK\n")
else:
s.send("CALL\n")
elif command == "REQUESTKEYVALUES":
# At the end, the engine will allow your bot save key/value pairs.
# Send FINISH to indicate you're done.
s.send("FINISH\n")
elif command == "HANDOVER":
hand = [""]*4 # Empty the hand
bankroll = int(data[1])
# risk = 1
# if bankroll < 100:
# diff = 100 - bankroll
# if (float(math.log(diff)/math.log(10))) == 0:
# risk = 1
# elif bankroll > -50:
# risk = 1.0 / (float(math.log(diff)/math.log(10)))**(2)
# else:
# risk = 1.0 / (float(math.log(diff)/math.log(10)))**2
# max_preflop_equity, max_flop_equity, max_turn_equity, max_river_equity = 0, 0, 0, 0 # Flush all equities
max_preflop_equity, max_flop_equity = 0, 0
# Clean up the socket.
print MADBot_delta
print otherbot_delta
# print "\n".join(MADBot_delta)
# print "=================================================="
# print "\n".join(otherbot_delta)
s.close()
def main():
game_file = 'HandLogs4/MADbot_vs_StraightOuttaCam'
player_1 = game_file.split('_vs_')[0][10:]
player_2 = game_file.split('_vs_')[1]
f = open(game_file, 'r')
lines = [line for line in f][1:]
full_game_string = ''
for line in lines:
full_game_string += line
game_buckets = full_game_string.split('\n\n')[:-1]
categories = defaultdict(list)
winner = defaultdict(list)
# Buckets all of the games into one of 6 categories:
# (1)full_game (players show their cards)
# Player 1 folds ((2)fold_after_river, (3)fold_after_turn, (4)fold_after_flop, (5)fold_before_flop)
# (2)opponent_folds (player 2 folds at some point in the game)
for game in game_buckets:
if player_1 + " shows" in game:
categories['full_game'] += [game]
elif player_1 + " folds" in game:
if "*** RIVER ***" in game:
categories['fold_after_river'] += [game]
elif "*** TURN ***" in game:
categories['fold_after_turn'] += [game]
elif "*** FLOP ***" in game:
categories['fold_after_flop'] += [game]
else:
categories['fold_before_flop'] += [game]
elif player_2 + " folds" in game:
categories['opponent_folds'] += [game]
if player_1 + " wins the pot" in game:
winner[player_1].append(game)
else:
winner[player_2].append(game)
preflops = []
p1_equities = []
for game in winner[player_1]:
if game not in categories['full_game']:
continue
player_1_hand, player_2_hand = get_players_hands(game, player_1, player_2)
# Getting pre-flop statistics
# max_preflop = max([HandEvaluator.evaluate_hand([Card(h[0][0], h[0][1]), Card(h[1][0], h[1][1])], []) for h in player_1_hand])
# preflops.append(max_preflop)
# Getting post-flop statistics
game = game[game.index("*** RIVER ***"):]
table_cards = game[game.index("[")+1:game.index("[")+12].split()
table_cards_last = game[game.index("]")+3:game.index("]")+5].split()
# table_cards = game[game.index("[")+1:game.index("[")+9].split()
# table_cards_last = game[game.index("]")+3:game.index("]")+5].split()
table_cards = table_cards + table_cards_last
conv = create_pbots_hand_to_twohandeval_dict()
converted_board_cards = convert_list_to_card_list([convert_pbots_hand_to_twohandeval(card) for card in table_cards]) # in pbotseval form
max_flop_equity = max([HandEvaluator.evaluate_hand([Card(h[0][0], h[0][1]), Card(h[1][0], h[1][1])], converted_board_cards) for h in player_1_hand])
# if max_flop_equity > 0.99:
# print table_cards
# print player_1_hand
# print [HandEvaluator.evaluate_hand([Card(h[0][0], h[0][1]), Card(h[1][0], h[1][1])], converted_board_cards) for h in player_1_hand]
# print player_2_hand
# print [HandEvaluator.evaluate_hand([Card(h[0][0], h[0][1]), Card(h[1][0], h[1][1])], converted_board_cards) for h in player_2_hand]
p1_equities.append(max_flop_equity)
print len(p1_equities)
n, bins, patches = plt.hist(p1_equities, 100, normed=1, facecolor='green', alpha=0.75)
plt.title('We won post river')
plt.show()
def declareAction(self, state, minBet, seat_num):
holes = state.player_state[seat_num].cards
boards = state.table_state.board
my_chips = state.player_state[seat_num].chips
this_round = state.table_state.round
# Aggresive -tight
number_players = len([player for player in state.player_state if player.isSurvive])
my_raise_bet = (my_chips * self.bet_tolerance) / (1 - self.bet_tolerance)
my_call_bet = minBet
table_bet = state.table_state.total_bet
total_bet = state.player_state[seat_num].roundBet # how many chips you bet in this round
action = 'fold'
amount = 0
my_rank = HandEvaluator.evaluate_hand(holes, boards)
print "this_round:{}".format(this_round)
print "evaluate_hand:{}".format(my_rank)
print "pre_player_action:{}".format(state.table_state.last_action)
# if this_round == 'preflop':
if this_round == 'Deal':
table_odds = (1.0 * my_call_bet + total_bet) / (my_call_bet + table_bet)
print "call table_odds:{}".format(table_odds)
if my_rank > table_odds:
if my_rank > 0.5:
action = 'call'
amount = my_call_bet
# elif my_rank > 0.5 and my_call_bet <= my_chips * 0.7:
# action = 'call'
# amount = my_call_bet
# print "prevent allin"
elif my_rank > 0.3 and my_call_bet <= my_chips / 50.0:
action = 'call'
amount = my_call_bet
print "aggressive call"
else:
action = 'fold'
amount = 0
elif this_round == 'River':
# win_rate = self.get_win_prob(holes, boards, 80, number_players)
# print "win_rate:{}".format(win_rate)
# if win_rate > 0.9 or my_rank > 0.9:
if my_rank > 0.96:
action = 'allin'
amount = 0
elif my_rank > 0.9:
action = 'raise'
amount = my_raise_bet
# elif win_rate > 0.5 or my_rank > 0.75:
elif my_rank > 0.75:
action = 'call'
amount = my_call_bet
elif my_rank > 0.6:
table_odds = (1.0 * my_call_bet + total_bet) / (my_call_bet + table_bet)
print "call table_odds:{}".format(table_odds)
if my_rank > table_odds:
action = 'call'
amount = my_call_bet
else:
action = 'fold'
amount = 0
else:
action = 'fold'
amount = 0
else:
if my_rank > 0.55:
print "total_bet:{}".format(total_bet)
print "table_bet:{}".format(table_bet)
table_odds = (1.0 * my_raise_bet + total_bet) / (my_raise_bet + table_bet)
print "raise table_odds:{}".format(table_odds)
if my_rank > 0.85 and my_rank > table_odds:
action = 'raise'
amount = my_raise_bet
else:
table_odds = (1.0 * my_call_bet + total_bet) / (my_call_bet + table_bet)
print "call table_odds:{}".format(table_odds)
if my_rank > table_odds:
action = 'call'
amount = my_call_bet
else:
action = 'fold'
amount = 0
else:
action = 'fold'
amount = 0
# handle check
print("state.table_state.last_action: {}".format(state.table_state.last_action))
if action == 'fold':
if my_call_bet == 0:
action = 'call'
amount = my_call_bet
print "call for bet 0"
# elif self.pre_player_action == 'check' or self.pre_player_action == '':
elif state.table_state.last_action == 'check' or state.table_state.last_action == '':
action = 'check'
amount = 0
print "go check"
# elif this_round == 'preflop' and self.data['game']['bigBlind']['playerName'] == self.data['self']['playerName']:
# action = 'check'
# amount = 0
# print "go check for preflop"
return action, amount
from pokereval.card import Card from pokereval.hand_evaluator import HandEvaluator # Rank is 2-14 representing 2-A, while suit is 1-4 representing spades, hearts, diamonds, clubs # aceOfSpades = Card(14, 1) # twoOfDiamonds = Card(2, 3) hole = [Card(10, 2), Card(11, 2)] board = [Card(12, 2), Card(13, 1), Card(14, 2),Card(4, 1)] score = HandEvaluator.evaluate_hand(hole, board) print(score)
def run(self, input_socket, get_flop_probs, get_turn_probs, get_river_probs):
# Get a file-object for reading packets from the socket.
# Using this ensures that you get exactly one packet per read.
f_in = input_socket.makefile()
conv = create_pbots_hand_to_twohandeval_dict()
while True:
# Block until the engine sends us a packet.
data = f_in.readline().strip()
# If data is None, connection has closed.
if not data:
print "Gameover, engine disconnected."
break
# Here is where you should implement code to parse the packets from
# the engine and act on it. We are just printing it instead.
print data
data = data.split() # Split data into list
command = data[0]
if command == "NEWGAME":
hand = [""]*4 # Initialize hand to be empty
risk = 1
max_preflop_equity, max_flop_equity = 0, 0 # Flush all equities
elif command == "NEWHAND":
info = parse_NEWHAND(data)
myBank = info['myBank']
if PLOT_FLAG == True:
MADBot_delta.append(myBank)
otherbot_delta.append(info['otherBank'])
hand = info['holeCards']
hand_pairs = get_all_pairs(hand)
# converts engine's format to pokereval's format
converted_hand_pairs = [(convert_pbots_hand_to_twohandeval(hole[0], conv), convert_pbots_hand_to_twohandeval(hole[1], conv)) for hole in hand_pairs]
max_preflop_equity = max([HandEvaluator.evaluate_hand([Card(h[0][0], h[0][1]), Card(h[1][0], h[1][1])], []) for h in converted_hand_pairs])
elif command == "GETACTION":
info = parse_GETACTION(data)
rand = random.random()
if info['numBoardCards'] == 0:
safe = myBank > -3000
l, u = get_lower_and_upper_bounds(info["legalActions"][-1])[1]
if safe:
if info['potSize'] > 50:
s.send("CHECK\n")
else:
if max_preflop_equity > 0.99:
if rand >= 0.4:
s.send("RAISE:" + str(l) + "\n")
s.send("CALL\n")
else:
if max_preflop_equity >= 0.99 and info['potSize'] < 50:
s.send("CALL\n")
else:
s.send("CHECK\n")
elif info['numBoardCards'] == 3:
table_cards = info['boardCards']
features = get_omaha_features(hand, table_cards, convolution_function, play = 'flop')
probs = get_turn_probs(features.reshape(1,27))[0]
prob_winning = probs[0]
print "###### FLOP #####"
print hand
print table_cards
print prob_winning
cmd, (l, u) = get_lower_and_upper_bounds(info["legalActions"][-1])
if cmd == 'BET':
if prob_winning >= 0.8:
if rand > 0.3:
s.send(cmd+":" + str(u) + "\n")
else:
s.send(cmd+":" + str(l) + "\n")
elif prob_winning >= 0.7:
if rand < 0.2:
s.send(cmd+":" + str(u) + "\n")
elif rand < 0.6:
s.send(cmd+":" + str(l) + "\n")
else:
s.send("CALL\n")
elif prob_winning >= 0.6:
s.send("CALL\n")
else:
s.send("CHECK\n")
elif cmd == 'RAISE':
if prob_winning >= 0.85:
if rand > 0.3:
s.send(cmd+":" + str(u) + "\n")
else:
s.send(cmd+":" + str(l) + "\n")
elif prob_winning >= 0.75:
if rand < 0.2:
s.send(cmd+":" + str(u) + "\n")
elif rand < 0.6:
s.send(cmd+":" + str(l) + "\n")
else:
s.send("CALL\n")
elif prob_winning >= 0.7:
s.send("CALL\n")
else:
s.send("CHECK\n")
else:
if prob_winning >= 0.7:
s.send("CALL\n")
else:
s.send("CHECK\n")
elif info['numBoardCards'] == 4:
table_cards = info['boardCards']
features = get_omaha_features(hand, table_cards, convolution_function, play = 'turn')
probs = get_turn_probs(features.reshape(1,27))[0]
prob_winning = probs[0]
print "###### TURN #####"
print hand
print table_cards
print prob_winning
cmd, (l, u) = get_lower_and_upper_bounds(info["legalActions"][-1])
if cmd == 'BET':
if prob_winning >= 0.8:
if rand > 0.3:
s.send(cmd+":" + str(u) + "\n")
else:
s.send(cmd+":" + str(l) + "\n")
elif prob_winning >= 0.7:
if rand < 0.2:
s.send(cmd+":" + str(u) + "\n")
elif rand < 0.6:
s.send(cmd+":" + str(l) + "\n")
else:
s.send("CALL\n")
elif prob_winning >= 0.5:
s.send("CALL\n")
else:
s.send("CHECK\n")
elif cmd == 'RAISE':
if prob_winning >= 0.9:
if rand > 0.3:
s.send(cmd+":" + str(u) + "\n")
else:
s.send(cmd+":" + str(l) + "\n")
elif prob_winning >= 0.85:
if rand < 0.2:
s.send(cmd+":" + str(u) + "\n")
elif rand < 0.6:
s.send(cmd+":" + str(l) + "\n")
else:
s.send("CALL\n")
elif prob_winning >= 0.7:
s.send("CALL\n")
else:
s.send("CHECK\n")
else:
if prob_winning >= 0.7:
s.send("CALL\n")
else:
s.send("CHECK\n")
elif info['numBoardCards'] == 5:
table_cards = info['boardCards']
features = get_omaha_features(hand, table_cards, convolution_function, play = 'river')
probs = get_turn_probs(features.reshape(1,27))[0]
prob_winning = probs[0]
print "###### RIVER #####"
print hand
print table_cards
print prob_winning
cmd, (l, u) = get_lower_and_upper_bounds(info["legalActions"][-1])
print cmd
if cmd == 'BET':
if prob_winning >= 0.75:
if rand > 0.3:
s.send(cmd+":" + str(u) + "\n")
else:
s.send(cmd+":" + str(l) + "\n")
elif prob_winning >= 0.7:
if rand < 0.2:
s.send(cmd+":" + str(u) + "\n")
elif rand < 0.6:
s.send(cmd+":" + str(l) + "\n")
else:
s.send("CALL\n")
elif prob_winning >= 0.6:
s.send("CALL\n")
else:
s.send("CHECK\n")
elif cmd == 'RAISE':
if prob_winning >= 0.95:
if rand > 0.3:
s.send(cmd+":" + str(u) + "\n")
else:
s.send(cmd+":" + str(l) + "\n")
elif prob_winning >= 0.8:
if rand < 0.2:
s.send(cmd+":" + str(u) + "\n")
elif rand < 0.6:
s.send(cmd+":" + str(l) + "\n")
else:
s.send("CALL\n")
elif prob_winning >= 0.7:
s.send("CALL\n")
else:
s.send("CHECK\n")
else:
if prob_winning >= 0.7:
s.send("CALL\n")
else:
s.send("CHECK\n")
else:
s.send("CALL\n")
elif command == "REQUESTKEYVALUES":
# At the end, the engine will allow your bot save key/value pairs.
# Send FINISH to indicate you're done.
s.send("FINISH\n")
elif command == "HANDOVER":
hand = [""]*4 # Empty the hand
bankroll = int(data[1])
# risk = 1
# if bankroll < 100:
# diff = 100 - bankroll
# if (float(math.log(diff)/math.log(10))) == 0:
# risk = 1
# elif bankroll > -50:
# risk = 1.0 / (float(math.log(diff)/math.log(10)))**(2)
# else:
# risk = 1.0 / (float(math.log(diff)/math.log(10)))**2
# max_preflop_equity, max_flop_equity, max_turn_equity, max_river_equity = 0, 0, 0, 0 # Flush all equities
max_preflop_equity, max_flop_equity = 0, 0
# Clean up the socket.
print MADBot_delta
print otherbot_delta
# print "\n".join(MADBot_delta)
# print "=================================================="
# print "\n".join(otherbot_delta)
s.close()
#print board
board = []
players = []
scores = []
hands = []
for p in tab.players:
<<<<<<< HEAD
print p.player_number, p.hand.cards, Handevaluator.evalueate_hand(p.hand
=======
card1 = p.hand.cards[0]
card2 = p.hand.cards[1]
hand = [Card(card1[0],card1[1]), Card(card2[0],card2[1])]
score = HandEvaluator.evaluate_hand(hand, board)
players.append(p.player_number)
hands.append(hand)
scores.append(score)
#print(scores)
#print(hands)
# print(players)
# orbit[i] = np.column_stack((players,scores,hand))
print p.player_number,score, p.hand.cards
tab.flop()
flop1 = tab.community_cards[0]
flop2 = tab.community_cards[1]
flop3 = tab.community_cards[2]
