def respond(self):
"""Based on your game state variables (see the __init__), make a
decision and return an action. If you return an illegal action, the
engine will automatically check/fold you
"""
if self.hands_played != self.hand_counter:
self.hand_counter = self.hands_played
# reset stuff
self.percentiles = {}
# self.last contains the last hand
# define self.hand_history as [] in __init__
# or you can't append to this list
# self.hand_history.append(self.last)
# see other templates for a modular way of determining an action
if not self.board.board:
self.percentiles['preflop'] = HandEvaluator.evaluate_hand(self.hand, self.board.cards)
return self.preflop_strategy()
elif self.board:
if len(self.board.board) == 3:
self.percentiles['flop'] = HandEvaluator.evaluate_hand(self.hand, self.board.cards)
return Check()
elif len(self.board.board) == 4:
self.percentiles['turn'] = HandEvaluator.evaluate_hand(self.hand, self.board.cards)
return Check()
elif len(self.board.board) == 5:
self.percentiles['river'] = HandEvaluator.evaluate_hand(self.hand, self.board.cards)
return Check()
return Check()
def respond(self):
"""Based on your game state variables (see the __init__), make a
decision and return an action. If you return an illegal action, the
engine will automatically check/fold you
"""
if self.debug:
print(self.name)
print('self.hand',self.hand)
print('self.board',self.board)
print('self.stack',self.stack)
print('self.pip',self.pip)
print('self.button',self.button)
print('self.opponent',self.opponent)
print('self.bb',self.bb)
print('self.sb',self.sb)
print('self.hands_played',self.hands_played)
print('self.legal',self.legal)
print('self.pot',self.pot)
# self.last contains the last hand
# define self.hand_history as [] in __init__
# or you can't append to this list
# self.hand_history.append(self.last)
# see other templates for a modular way of determining an action
if not self.board.board:
if 'preflop' not in self.percentiles:
self.percentiles['preflop'] = HandEvaluator.evaluate_hand(self.hand)
if self.debug:
print('preflop percentile ',self.percentiles['preflop'])
self.opponent_previous_pip=0
return self.strategy(2, self.percentiles['preflop'])
elif self.board:
if len(self.board.board) == 3:
if 'flop' not in self.percentiles:
self.percentiles['flop'] = HandEvaluator.evaluate_hand(self.hand, self.board.cards)
if self.debug:
print('flop percentile ',self.percentiles['flop'])
self.opponent_previous_pip=0
return self.strategy(3, self.percentiles['flop'])
elif len(self.board.board) == 4:
if 'turn' not in self.percentiles:
self.percentiles['turn'] = HandEvaluator.evaluate_hand(self.hand, self.board.cards)
if self.debug:
print('turn percentile ',self.percentiles['turn'])
self.opponent_previous_pip=0
return self.strategy(4, self.percentiles['turn'])
elif len(self.board.board) == 5:
if 'river' not in self.percentiles:
self.percentiles['river'] = HandEvaluator.evaluate_hand(self.hand, self.board.cards)
if self.debug:
print('river percentile ',self.percentiles['river'])
self.opponent_previous_pip=0
return self.strategy(5, self.percentiles['river'])
if self.debug:
print('Something screwed up, so we are checking (1)')
ok = raw_input('press enter\n')
return Check()
def respond(self):
"""Based on your game state variables (see the __init__), make a
decision and return an action. If you return an illegal action, the
engine will automatically check/fold you
"""
if self.hands_played != self.hand_counter:
self.hand_counter = self.hands_played
self.percentiles = {}
self.slowplay_flag = False
# see other templates for a modular way of determining an action
if not self.board.board:
if 'preflop' not in self.percentiles:
self.percentiles['preflop'] = HandEvaluator.evaluate_hand(
self.hand)
self.played_this_street = 0
if self.button:
self.opponent_previous_pip = 2
else:
self.opponent_previous_pip = 1
self.played_this_street += 1
return self.strategy(2, self.percentiles['preflop'])
elif self.board:
if len(self.board.board) == 3:
if 'flop' not in self.percentiles:
self.percentiles['flop'] = HandEvaluator.evaluate_hand(
self.hand, self.board.cards)
self.played_this_street = 0
self.opponent_previous_pip = 0
self.played_this_street += 1
return self.strategy(3, self.percentiles['flop'])
elif len(self.board.board) == 4:
if 'turn' not in self.percentiles:
self.percentiles['turn'] = HandEvaluator.evaluate_hand(
self.hand, self.board.cards)
self.played_this_street = 0
self.opponent_previous_pip = 0
self.played_this_street += 1
return self.strategy(4, self.percentiles['turn'])
elif len(self.board.board) == 5:
if 'river' not in self.percentiles:
self.percentiles['river'] = HandEvaluator.evaluate_hand(
self.hand, self.board.cards)
self.played_this_street = 0
self.opponent_previous_pip = 0
self.played_this_street += 1
return self.strategy(5, self.percentiles['river'])
return Check()
def respond(self):
"""Based on your game state variables (see the __init__), make a
decision and return an action. If you return an illegal action, the
engine will automatically check/fold you
"""
if self.hands_played != self.hand_counter:
self.hand_counter = self.hands_played
self.percentiles = {}
self.slowplay_flag = False
# see other templates for a modular way of determining an action
if not self.board.board:
if 'preflop' not in self.percentiles:
self.percentiles['preflop'] = HandEvaluator.evaluate_hand(self.hand)
self.played_this_street = 0
if self.button:
self.opponent_previous_pip=2
else:
self.opponent_previous_pip=1
self.played_this_street += 1
return self.strategy(2, self.percentiles['preflop'])
elif self.board:
if len(self.board.board) == 3:
if 'flop' not in self.percentiles:
self.percentiles['flop'] = HandEvaluator.evaluate_hand(self.hand, self.board.cards)
self.played_this_street = 0
self.opponent_previous_pip=0
self.played_this_street += 1
return self.strategy(3, self.percentiles['flop'])
elif len(self.board.board) == 4:
if 'turn' not in self.percentiles:
self.percentiles['turn'] = HandEvaluator.evaluate_hand(self.hand, self.board.cards)
self.played_this_street = 0
self.opponent_previous_pip=0
self.played_this_street += 1
return self.strategy(4, self.percentiles['turn'])
elif len(self.board.board) == 5:
if 'river' not in self.percentiles:
self.percentiles['river'] = HandEvaluator.evaluate_hand(self.hand, self.board.cards)
self.played_this_street = 0
self.opponent_previous_pip=0
self.played_this_street += 1
return self.strategy(5, self.percentiles['river'])
return Check()
def respond(self):
"""Based on your game state variables (see the __init__), make a
decision and return an action. If you return an illegal action, the
engine will automatically check/fold you
"""
if not self.board.board:
hand_data = HandEvaluator.evaluate_preflop_hand(self.hand)
elif self.board:
hand_data = HandEvaluator.evaluate_hand(self.board.cards + list(self.hand))
if len(self.board.board) == 3:
return Check()
elif len(self.board.board) == 4:
return Check()
elif len(self.board.board) == 5:
return Check()
# always return Check() as last resort, because it beats Fold()
return Check()
def respond(self):
"""Based on your game state variables (see the __init__), make a
decision and return an action. If you return an illegal action, the
engine will automatically check/fold you
"""
if self.hands_played != self.hand_counter:
self.hand_counter = self.hands_played
# reset stuff
self.percentiles = {}
# self.last contains the last hand
# define self.hand_history as [] in __init__
# or you can't append to this list
# self.hand_history.append(self.last)
# see other templates for a modular way of determining an action
if not self.board.board:
self.percentiles['preflop'] = HandEvaluator.evaluate_hand(
self.hand, self.board.cards)
return self.preflop_strategy()
elif self.board:
if len(self.board.board) == 3:
self.percentiles['flop'] = HandEvaluator.evaluate_hand(
self.hand, self.board.cards)
return Check()
elif len(self.board.board) == 4:
self.percentiles['turn'] = HandEvaluator.evaluate_hand(
self.hand, self.board.cards)
return Check()
elif len(self.board.board) == 5:
self.percentiles['river'] = HandEvaluator.evaluate_hand(
self.hand, self.board.cards)
return Check()
return Check()
def poker_player():
while True:
time.sleep(1) # sleep .25 seconds to not spam
resp = json.loads(get())
players = resp["players_at_table"]
pot = 0
for player in players:
pot += player['current_bet']
amountToCall = resp["call_amount"]
#print players['player_name']
hand = resp["hand"]
card1 = hand[0]
card2 = hand[1]
s11 = str_to_rank(card1[0])
s12 = str_to_suit(card1[1])
c1 = Card(s11, s12)
s21 = str_to_rank(card2[0])
s22 = str_to_suit(card2[1])
c2 = Card(s21, s22)
hole = [c1, c2]
stack = resp["stack"]
board = []
cc = resp["community_cards"]
c = resp["call_amount"]
#potodds = c / (pot + c)
#handrank = rankHand(hand)
#print "hand rank: ", handrank
if resp["your_turn"]:
if len(cc) != 0:
for card in cc:
s11 = str_to_rank(card[0])
s12 = str_to_suit(card[1])
#print s11, s12
c = Card(s11, s12)
board.append(c)
print board
score = HandEvaluator.evaluate_hand(hole, board)
print 'score', score
action = None
amount = 0
betting_phase = resp["betting_phase"]
if score >= 0.87:
action = 'raise'
amount = 0.15 * stack
elif score >= 0.75: #call
action = 'call'
else:
action = 'fold'
print "action: " + action
print "amount: ", amount
#logging.info("action: ", action)
#logging.info("bet amount: ", amount)
post(action, amount)
def respond(self):
"""Based on your game state variables (see the __init__), make a
decision and return an action. If you return an illegal action, the
engine will automatically check/fold you
"""
if self.debug:
print(self.name)
print('self.hand', self.hand)
print('self.board', self.board)
print('self.stack', self.stack)
print('self.pip', self.pip)
print('self.button', self.button)
print('self.opponent', self.opponent)
print('self.bb', self.bb)
print('self.sb', self.sb)
print('self.hands_played', self.hands_played)
print('self.legal', self.legal)
print('self.pot', self.pot)
if self.hands_played != self.hand_counter:
self.hand_counter = self.hands_played
# reset stuff
self.percentiles = {}
self.opponent_percentiles = {}
#self.evaluate_opponent()
# self.last contains the last hand
# define self.hand_history as [] in __init__
# or you can't append to this list
# self.hand_history.append(self.last)
# see other templates for a modular way of determining an action
if not self.board.board:
if 'preflop' not in self.percentiles:
self.percentiles['preflop'] = HandEvaluator.evaluate_hand(
self.hand)
if self.debug:
print('preflop percentile ', self.percentiles['preflop'])
self.opponent_previous_pip = 0
return self.strategy(2, self.percentiles['preflop'])
elif self.board:
if len(self.board.board) == 3:
if 'flop' not in self.percentiles:
self.percentiles['flop'] = HandEvaluator.evaluate_hand(
self.hand, self.board.cards)
if self.debug:
print('flop percentile ', self.percentiles['flop'])
self.opponent_previous_pip = 0
return self.strategy(3, self.percentiles['flop'])
elif len(self.board.board) == 4:
if 'turn' not in self.percentiles:
self.percentiles['turn'] = HandEvaluator.evaluate_hand(
self.hand, self.board.cards)
if self.debug:
print('turn percentile ', self.percentiles['turn'])
self.opponent_previous_pip = 0
return self.strategy(4, self.percentiles['turn'])
elif len(self.board.board) == 5:
if 'river' not in self.percentiles:
self.percentiles['river'] = HandEvaluator.evaluate_hand(
self.hand, self.board.cards)
if self.debug:
print('river percentile ', self.percentiles['river'])
self.opponent_previous_pip = 0
return self.strategy(5, self.percentiles['river'])
if self.debug:
print('Something screwed up, so we are checking (1)')
ok = raw_input('press enter\n')
return Check()
for j in range(1, 4 + 1):
full_deck.append(Card(i, j))
for i in range(n):
deck = list(full_deck)
random.shuffle(deck)
hand = []
board = []
for j in range(2):
hand.append(deck.pop(0))
for j in range(5):
board.append(deck.pop(0))
hands.append(hand)
boards.append(board)
return boards, hands
N = 10000
cumtime = 0.0
boards, hands = setup(N)
for i in range(len(boards)):
start = time.time()
HandEvaluator.evaluate_hand(hands[i], boards[i])
cumtime += (time.time() - start)
avg = float(cumtime / N)
print("[*] Pokerhand-eval: Average time per evaluation: %f" % avg)
print("[*] Pokerhand-eval: Evaluations per second = %f" % (1.0 / avg))
def evaluate_opponent(self):
if self.hands_played >= 1:
last_pot = 0.0
self_bet_for_round = 0
opponent_bet_for_round = 0
opponent_bet_strength_preflop = []
opponent_bet_strength_flop = []
opponent_bet_strength_turn = []
opponent_bet_strength_river = []
street = 'preflop'
# obtain opponent's betting behavior from the previous round, and determine strength of hand if there's a showdown
#
for play in self.last[1]:
if play[0] == self.name:
if isinstance(play[1], Post):
last_pot = last_pot + play[1].amount
self_bet_for_round = play[1].amount
elif isinstance(play[1], Bet):
last_pot = last_pot + play[1].amount
self_bet_for_round = play[1].amount
elif isinstance(play[1], Raise):
last_pot = last_pot - self_bet_for_round + play[
1].amount
self_bet_for_round = play[1].amount
elif isinstance(play[1], Call):
last_pot = last_pot + opponent_bet_for_round - self_bet_for_round
self_bet_for_round = opponent_bet_for_round
elif play[0] == self.opponent['name']:
strength_of_bet = zeros(0)
if isinstance(play[1], Post):
last_pot = last_pot + play[1].amount
opponent_bet_for_round = play[1].amount
elif isinstance(play[1], Bet):
last_pot = last_pot + play[1].amount
opponent_bet_for_round = play[1].amount
opponent_bet_strength = play[1].amount / last_pot
elif isinstance(play[1], Raise):
last_pot = last_pot - opponent_bet_for_round + play[
1].amount
opponent_bet_strength = (
play[1].amount - opponent_bet_for_round) / last_pot
opponent_bet_for_round = play[1].amount
elif isinstance(play[1], Call):
last_pot = last_pot + self_bet_for_round - opponent_bet_for_round
opponent_bet_strength = (
self_bet_for_round -
opponent_bet_for_round) / last_pot
opponent_bet_for_round = self_bet_for_round
elif isinstance(play[1], Check):
opponent_bet_strength = 0.0
elif isinstance(play[1], Show):
#print play[1].hand
#print last_board
opponent_hand_strength_preflop = HandEvaluator.evaluate_hand(
play[1].hand, [])
opponent_hand_strength_flop = HandEvaluator.evaluate_hand(
play[1].hand, last_board[0:3])
opponent_hand_strength_turn = HandEvaluator.evaluate_hand(
play[1].hand, last_board[0:4])
opponent_hand_strength_river = HandEvaluator.evaluate_hand(
play[1].hand, last_board)
opponent_hand_strength = [
opponent_hand_strength_preflop,
opponent_hand_strength_flop,
opponent_hand_strength_turn,
opponent_hand_strength_river
]
opponent_bet_strength = [
opponent_bet_strength_preflop,
opponent_bet_strength_flop,
opponent_bet_strength_turn,
opponent_bet_strength_river
]
for i in xrange(0, 4):
for j in xrange(0, len(opponent_bet_strength[i])):
self.opponent_showdown_hand_strength.append(
opponent_hand_strength[i])
self.opponent_showdown_bet_strength.append(
opponent_bet_strength[i][j])
if len(self.opponent_showdown_hand_strength
) > self.p6:
self.opponent_showdown_hand_strength = self.opponent_showdown_hand_strength[
-self.p6:]
self.opponent_showdown_bet_strength = self.opponent_showdown_bet_strength[
-self.p6:]
degree = 1
if len(self.opponent_showdown_hand_strength
) > self.p6 / 2:
self.coeff = polyfit(
self.opponent_showdown_hand_strength,
self.opponent_showdown_bet_strength,
degree)
self.corr = corrcoef(
self.opponent_showdown_hand_strength,
self.opponent_showdown_bet_strength)[0,
1]
# store first coefficient, which estimate's opponent's A
self.opponent_showdown_potodds_estimate = self.coeff[
0]
else:
self.corr = 0
if isinstance(play[1], Bet) or isinstance(play[1], Raise):
if street == 'preflop':
opponent_bet_strength_preflop.append(
opponent_bet_strength)
elif street == 'flop':
opponent_bet_strength_flop.append(
opponent_bet_strength)
elif street == 'turn':
opponent_bet_strength_turn.append(
opponent_bet_strength)
elif street == 'river':
opponent_bet_strength_river.append(
opponent_bet_strength)
self.opponent_bet_history = append(
self.opponent_bet_history, strength_of_bet)
elif play[0] == 'Dealer':
self_bet_for_round = 0
opponent_bet_for_round = 0
if len(play[1].cards) == 12:
street = 'flop'
elif len(play[1].cards) == 16:
street = 'turn'
elif len(play[1].cards) == 20:
street = 'river'
card_string = play[1].cards
last_board_string = play[1].cards
last_board = []
for i in xrange(0, 5):
str_pos = 4 * i + 1
if card_string[str_pos] == 'A':
card_rank = 14
elif card_string[str_pos] == 'K':
card_rank = 13
elif card_string[str_pos] == 'Q':
card_rank = 12
elif card_string[str_pos] == 'J':
card_rank = 11
elif card_string[str_pos] == 'T':
card_rank = 10
else:
card_rank = int(card_string[str_pos])
str_pos = 4 * i + 2
if card_string[str_pos] == 's':
card_suit = 1
elif card_string[str_pos] == 'h':
card_suit = 2
elif card_string[str_pos] == 'd':
card_suit = 3
elif card_string[str_pos] == 'c':
card_suit = 4
last_board.append(Card(card_rank, card_suit))
for j in range(1, 4 + 1):
full_deck.append(Card(i, j))
for i in range(n):
deck = list(full_deck)
random.shuffle(deck)
hand = []
board = []
for j in range(2):
hand.append(deck.pop(0))
for j in range(5):
board.append(deck.pop(0))
hands.append(hand)
boards.append(board)
return boards, hands
N = 10000
cumtime = 0.0
boards, hands = setup(N)
for i in range(len(boards)):
start = time.time()
HandEvaluator.evaluate_hand(hands[i], boards[i])
cumtime += (time.time() - start)
avg = float(cumtime / N)
print "[*] Pokerhand-eval: Average time per evaluation: %f" % avg
print "[*] Pokerhand-eval: Evaluations per second = %f" % (1.0 / avg)
def evaluate_opponent(self):
if self.hands_played >= 1:
last_pot = 0.0
self_bet_for_round = 0
opponent_bet_for_round = 0
opponent_bet_strength_preflop = []
opponent_bet_strength_flop = []
opponent_bet_strength_turn = []
opponent_bet_strength_river = []
street = 'preflop'
# obtain opponent's betting behavior from the previous round, and determine strength of hand if there's a showdown
#
for play in self.last[1]:
if play[0] == self.name:
if isinstance(play[1],Post):
last_pot = last_pot + play[1].amount
self_bet_for_round = play[1].amount
elif isinstance(play[1],Bet):
last_pot = last_pot + play[1].amount
self_bet_for_round = play[1].amount
elif isinstance(play[1],Raise):
last_pot = last_pot - self_bet_for_round + play[1].amount
self_bet_for_round = play[1].amount
elif isinstance(play[1],Call):
last_pot = last_pot + opponent_bet_for_round - self_bet_for_round
self_bet_for_round = opponent_bet_for_round
elif play[0] == self.opponent['name']:
strength_of_bet = zeros(0)
if isinstance(play[1],Post):
last_pot = last_pot + play[1].amount
opponent_bet_for_round = play[1].amount
elif isinstance(play[1],Bet):
last_pot = last_pot + play[1].amount
opponent_bet_for_round = play[1].amount
opponent_bet_strength = play[1].amount/last_pot
elif isinstance(play[1],Raise):
last_pot = last_pot - opponent_bet_for_round + play[1].amount
opponent_bet_strength = (play[1].amount - opponent_bet_for_round)/last_pot
opponent_bet_for_round = play[1].amount
elif isinstance(play[1],Call):
last_pot = last_pot + self_bet_for_round - opponent_bet_for_round
opponent_bet_strength = (self_bet_for_round - opponent_bet_for_round)/last_pot
opponent_bet_for_round = self_bet_for_round
elif isinstance(play[1],Check):
opponent_bet_strength = 0.0
elif isinstance(play[1],Show):
#print play[1].hand
#print last_board
opponent_hand_strength_preflop = HandEvaluator.evaluate_hand(play[1].hand,[])
opponent_hand_strength_flop = HandEvaluator.evaluate_hand(play[1].hand,last_board[0:3])
opponent_hand_strength_turn = HandEvaluator.evaluate_hand(play[1].hand,last_board[0:4])
opponent_hand_strength_river = HandEvaluator.evaluate_hand(play[1].hand,last_board)
opponent_hand_strength = [opponent_hand_strength_preflop,opponent_hand_strength_flop,
opponent_hand_strength_turn,opponent_hand_strength_river]
opponent_bet_strength = [opponent_bet_strength_preflop,opponent_bet_strength_flop,
opponent_bet_strength_turn,opponent_bet_strength_river]
for i in xrange(0,4):
for j in xrange(0,len(opponent_bet_strength[i])):
self.opponent_showdown_hand_strength.append(opponent_hand_strength[i])
self.opponent_showdown_bet_strength.append(opponent_bet_strength[i][j])
if len(self.opponent_showdown_hand_strength) > self.p6:
self.opponent_showdown_hand_strength = self.opponent_showdown_hand_strength[-self.p6:]
self.opponent_showdown_bet_strength = self.opponent_showdown_bet_strength[-self.p6:]
degree = 1
if len(self.opponent_showdown_hand_strength) > self.p6/2:
self.coeff = polyfit(self.opponent_showdown_hand_strength,self.opponent_showdown_bet_strength,degree)
self.corr = corrcoef(self.opponent_showdown_hand_strength,self.opponent_showdown_bet_strength)[0,1]
# store first coefficient, which estimate's opponent's A
self.opponent_showdown_potodds_estimate = self.coeff[0]
else:
self.corr = 0
if isinstance(play[1],Bet) or isinstance(play[1],Raise):
if street == 'preflop':
opponent_bet_strength_preflop.append(opponent_bet_strength)
elif street == 'flop':
opponent_bet_strength_flop.append(opponent_bet_strength)
elif street == 'turn':
opponent_bet_strength_turn.append(opponent_bet_strength)
elif street == 'river':
opponent_bet_strength_river.append(opponent_bet_strength)
self.opponent_bet_history = append(self.opponent_bet_history,strength_of_bet)
elif play[0] == 'Dealer':
self_bet_for_round = 0
opponent_bet_for_round = 0
if len(play[1].cards) == 12:
street = 'flop'
elif len(play[1].cards) == 16:
street = 'turn'
elif len(play[1].cards) == 20:
street = 'river'
card_string = play[1].cards
last_board_string = play[1].cards
last_board = []
for i in xrange(0,5):
str_pos = 4*i+1
if card_string[str_pos] == 'A':
card_rank = 14
elif card_string[str_pos] == 'K':
card_rank = 13
elif card_string[str_pos] == 'Q':
card_rank = 12
elif card_string[str_pos] == 'J':
card_rank = 11
elif card_string[str_pos] == 'T':
card_rank = 10
else:
card_rank = int(card_string[str_pos])
str_pos = 4*i+2
if card_string[str_pos] == 's':
card_suit = 1
elif card_string[str_pos] == 'h':
card_suit = 2
elif card_string[str_pos] == 'd':
card_suit = 3
elif card_string[str_pos] == 'c':
card_suit = 4
last_board.append(Card(card_rank,card_suit))
from sys import stdin
from hand_evaluator import HandEvaluator
# inspired by http://suffe.cool/poker/evaluator.html
if __name__ == "__main__":
evaluator = HandEvaluator()
for line in stdin:
try:
print(evaluator.evaluate(line.strip()))
except Exception as e:
print('Error: {}'.format(str(e)))
def respond(self):
"""Based on your game state variables (see the __init__), make a
decision and return an action. If you return an illegal action, the
engine will automatically check/fold you
"""
if self.debug:
print(self.name)
print("self.hand", self.hand)
print("self.board", self.board)
print("self.stack", self.stack)
print("self.pip", self.pip)
print("self.button", self.button)
print("self.opponent", self.opponent)
print("self.bb", self.bb)
print("self.sb", self.sb)
print("self.hands_played", self.hands_played)
print("self.legal", self.legal)
print("self.pot", self.pot)
if self.hands_played != self.hand_counter:
self.hand_counter = self.hands_played
# reset stuff
self.percentiles = {}
self.opponent_percentiles = {}
# self.evaluate_opponent()
# self.last contains the last hand
# define self.hand_history as [] in __init__
# or you can't append to this list
# self.hand_history.append(self.last)
# see other templates for a modular way of determining an action
if not self.board.board:
if "preflop" not in self.percentiles:
self.percentiles["preflop"] = HandEvaluator.evaluate_hand(self.hand)
if self.debug:
print("preflop percentile ", self.percentiles["preflop"])
self.opponent_previous_pip = 0
return self.strategy(2, self.percentiles["preflop"])
elif self.board:
if len(self.board.board) == 3:
if "flop" not in self.percentiles:
self.percentiles["flop"] = HandEvaluator.evaluate_hand(self.hand, self.board.cards)
if self.debug:
print("flop percentile ", self.percentiles["flop"])
self.opponent_previous_pip = 0
return self.strategy(3, self.percentiles["flop"])
elif len(self.board.board) == 4:
if "turn" not in self.percentiles:
self.percentiles["turn"] = HandEvaluator.evaluate_hand(self.hand, self.board.cards)
if self.debug:
print("turn percentile ", self.percentiles["turn"])
self.opponent_previous_pip = 0
return self.strategy(4, self.percentiles["turn"])
elif len(self.board.board) == 5:
if "river" not in self.percentiles:
self.percentiles["river"] = HandEvaluator.evaluate_hand(self.hand, self.board.cards)
if self.debug:
print("river percentile ", self.percentiles["river"])
self.opponent_previous_pip = 0
return self.strategy(5, self.percentiles["river"])
if self.debug:
print("Something screwed up, so we are checking (1)")
ok = raw_input("press enter\n")
return Check()
def calculateResult(cepheusSmallBlind, board):
history = connection.bet_his
totalBank = [0, 0] ### first small blind, second big blind
for i in range(len(history)):
if i == 0:
for j in range(2):
totalBank[j] += preflop_br[history[i]][j]
elif i == 1:
for j in range(2):
totalBank[j] += flop_br[history[i]][j]
elif i == 2:
for j in range(2):
totalBank[j] += turn_br[history[i]][j]
else:
for j in range(2):
totalBank[j] += river_br[history[i]][j]
result = [0, 0]
if cepheusSmallBlind:
result = totalBank
else:
result[1] = totalBank[0]
result[0] = totalBank[1]
for i in range(1, 4):
if len(history) == i:
a = len(history[i - 1]) % 2
if a == 1: ## small blind loses
if cepheusSmallBlind:
bankroll[0] -= result[0]
bankroll[1] += result[0]
else:
bankroll[0] += result[1]
bankroll[1] -= result[1]
else: ## small blind wins
if cepheusSmallBlind: ## cepheus wins
bankroll[0] += result[1]
bankroll[1] -= result[1]
else:
bankroll[0] -= result[0]
bankroll[1] += result[0]
if len(history) == 4:
if history[3][-1] == "f":
a = len(history[3]) % 1
if a == 1: #small blind loses
if cepheusSmallBlind:
bankroll[0] -= result[0]
bankroll[1] += result[0]
else:
bankroll[0] += result[1]
bankroll[1] -= result[1]
else: ## small blind wins
if cepheusSmallBlind: ## cepheus wins
bankroll[0] += result[1]
bankroll[1] -= result[1]
else:
bankroll[0] -= result[0]
bankroll[1] += result[0]
else: ## show down
cepheusList = []
playerList = []
for i in range(board):
cepheusList.append(i)
playerList.append(i)
for i in range(2):
cepheusList.append(cepheusHoleCards[i])
playerList.append(playerHoleCards[i])
evalResult = he.Seven()
cepheusRank = evalResult.evaluate_rank(cepheusList)
playerRank = evalResult.evaluate_rank(playerList)
if cepheusRank < playerRank: # cepheus wins
bankroll[0] += result[1]
bankroll[1] -= result[1]
elif cepheusRank > playerRank:
bankroll[0] -= result[0]
bankroll[1] += result[0]
