def takeAction(player, action, data):
global current_md5
global hand
global board
# print(action)
# print(data)
if action == "__new_peer":
# calcuate md5 by player name
# current_md5 = "70be3acc4a99a780e1b405e1ff7971c5"
current_md5 = hashlib.md5(player).hexdigest()
print('MD5 of Current User: '******'playerName']:
card_list = player_info['cards']
for card in card_list:
hand.append(Card.new(convertToDeucesCard(card)))
print("****** My hand cards ******")
Card.print_pretty_cards(hand)
print("***************************")
elif action == "__bet":
takeActionByDeuces(player, action, data)
elif action == "__action":
if len(data['game']['board']) == 0:
takeActionByHand(player, action, data)
else:
takeActionByDeuces(player, action, data)
def bet():
actions = []
maxRaise = 0
for player in curState.curPlayers:
action = player.callAI(curState, actions)
actions.append([player, action])
if action[0][0] == "raise" and action[0][1] > maxRaise:
maxRaise = action[0][1]
for action in actions:
if maxRaise > action[1][1]:
curState.curPlayers.remove(action[0])
else:
action[0].money -= maxRaise
curState.pot += maxRaise
print("Player Actions: ")
for action in actions:
print(
str(action[0]) + ":\n " + str(action[1][0]) + ", maxbid: " +
str(action[1][1]))
print("Pot: " + str(curState.pot))
print("Current Players: ")
for player in curState.curPlayers:
print(player)
print(" Hand: ")
Card.print_pretty_cards(player.curHand)
print(" Money: " + str(player.money))
def get_bet(self, data):
roundnum = data['game']['roundName']
players = data['game']['players']
chips = data['self']['chips']
hands = data['self']['cards']
self.raise_count = data['game']['raiseCount']
self.my_step = data['game']['betCount']
self.my_chips = chips
self.my_name = data['self']['playerName']
self.number_players = len(players)
self.my_call_bet = data['self']['minBet']
self.my_raise_bet = self.my_call_bet * 2
self.hole = []
for card in (hands):
card = convert_card_str(card)
card = Card.new(card)
self.hole.append(card)
print ("...roundnum: ", format(roundnum), " -> force bet")
print ('...my_call_bet:', format(self.my_call_bet), "my_raise_bet", format(self.my_raise_bet), "my_chips", format(self.my_chips), "table bet", format(self.table_bet))
Card.print_pretty_cards (self.hole)
Card.print_pretty_cards (self.board)
if roundnum == 'Deal' and self.my_step == 0:
print ("...Force to bet!")
action = 'call'
amount = self.my_call_bet
self.my_step += 1
self.total_bet += amount
return action, amount
else:
return self.get_action(data)
def combat_power(self, hole, board_input, ppl, max_time = 1): Card.print_pretty_cards(hole+board_input) count = 0 count_win = 0 b_len = len(board_input) t_start = time.time() while True: self.deck.shuffle() board = board_input + self.dealer(5-b_len, hole+board_input) rank_my = self.evaluator.evaluate(hole, board) b_win = True player = [] rank = [] for i in range(ppl-1): player.append(self.dealer(2, hole+board)) rank.append(self.evaluator.evaluate(player[i], board)) if rank_my > rank[i]: b_win = False if b_win: count_win += 1 count += 1 t_end = time.time() if t_end - t_start > max_time: break return float(count_win)/float(count)
def print_player_hand(self):
try:
Card.print_pretty_cards(self.player_cards + self.flop_cards)
except TypeError, e:
print(
'ERROR: Something went wrong. Make sure that all required cards are defined.'
)
def print_opponent_cards(self):
try:
Card.print_pretty_cards(self.opponent_cards)
except TypeError, e:
print(
'ERROR: Something went wrong. Make sure that all required cards are defined.'
)
def deal(cardAmt):
draw = deck.draw(cardAmt)
if isinstance(draw, int):
curState.board.append(deck.draw(cardAmt))
else:
curState.board.extend(deck.draw(cardAmt))
print "Board: "
print Card.print_pretty_cards(curState.board)
def evaluate(evaluator, allCardsObjectOnBoard, cardObject1, cardObject2):
try:
# return 1
return evaluator.evaluate(allCardsObjectOnBoard,
[cardObject1, cardObject2])
except:
Card.print_pretty_cards(allCardsObjectOnBoard)
Card.print_pretty_cards([cardObject1, cardObject2])
raise ValueError("chcek last cards, some problem with eval")
def deal_hole_cards(self):
for p in self.players:
p.hand = self.deck.draw(2)
p.hand = sorted(p.hand, reverse=False)
if p.id == "HUMAN":
print("Your hand: \t")
Card.print_pretty_cards(p.hand)
print("")
def queryOpenAction(_hand, _minimumPotAfterOpen, _playersCurrentBet,
_playersRemainingChips):
poker_hand = []
########### EVALUATE HAND ###########
print '=== EVALUATION ==='
for n in _hand:
poker_hand.append(Card.new(n))
Card.print_pretty_cards(poker_hand)
score = DEUCES_EVALUATOR.evaluate([], poker_hand)
rank = DEUCES_EVALUATOR.class_to_string(
DEUCES_EVALUATOR.get_rank_class(score))
print "Rank = " + rank
########### / EVALUATE HAND ###########
########### ESTIMATE WIN CHANCE ###########
chance = round(
(float(1) -
Evaluator.get_five_card_rank_percentage(DEUCES_EVALUATOR, score)), 2)
print "Chance to win =", chance * 100, "%"
########### / ESTIMATE WIN CHANCE ###########
########### ACTION DEPENDS ON WIN CHANCE ###########
print("======= OPENING ACTION =======")
# chance to win < 22%: Bet 1 coin up to 2% of stack size
if (chance < 0.22):
action = ClientBase.BettingAnswer.ACTION_OPEN, \
int(random.randint(0, round(0.05 * _playersRemainingChips) + 1) + _minimumPotAfterOpen)
# chance to win < 33%: Bet 1 coin up to 10% of stack size
elif (chance < 0.33):
action = ClientBase.BettingAnswer.ACTION_OPEN, \
int(random.randint(0, round(0.1 * _playersRemainingChips) + 1) + _minimumPotAfterOpen)
# chance to win < 66%: Bet 15% of stack size up to 20% of stack size
elif (chance < 0.66):
action = ClientBase.BettingAnswer.ACTION_OPEN, \
int(random.randint(round(0.15 * _playersRemainingChips),
round(0.2 * _playersRemainingChips) + 1) + _minimumPotAfterOpen)
# If chance is higher - check remaining chip stack:
else:
# Chip stack < 40: Go all in
if (_playersRemainingChips < 0.4):
action = ClientBase.BettingAnswer.ACTION_ALLIN
# Otherwise: Bet 25% of stack size up to 30% of stack size
else:
action = ClientBase.BettingAnswer.ACTION_OPEN, \
int(random.randint(round(0.25 * _playersRemainingChips),
round(0.3 * _playersRemainingChips) + 1) + _minimumPotAfterOpen)
print 'GermanWings:', action
return action
def compare_hands_and_set_winner(self):
min_rank = 8000
top_player = None
for player in self.round_rotation.players:
Card.print_pretty_cards(player.hand.cards + self.shared_cards)
player_rank = self.evaluator.evaluate(player.hand.cards,
self.shared_cards)
if player_rank < min_rank:
min_rank = player_rank
top_player = player
self.set_winner(top_player)
def handRank(self):
scores = []
for i in range(2):
if self.player_list[i].folded == False:
strength = self.evaluator.evaluate(self.table, self.player_list[i].hand)
scores.append([i, strength])
print self.player_list[i].name + ": " + self.evaluator.class_to_string(self.evaluator.get_rank_class(strength))
Card.print_pretty_cards(self.player_list[i].hand)
scores = sorted(scores,key=itemgetter(1))
groups = groupby(scores, itemgetter(1))
result = [[item[0] for item in data] for (key, data) in groups]
for i in result[0]:
print self.player_list[i].name + " wins!"
return result
def rounds(self, round_num):
if round_num == 1:
print("The Flop")
self.table += self.deck.draw(3)
elif round_num == 2:
print("The Turn")
self.table += [self.deck.draw(1)]
elif round_num == 3:
print("The River")
self.table += [self.deck.draw(1)]
else:
print("Showdown")
Card.print_pretty_cards(self.table)
for i in range(len(self.player_list)):
self.strengths[i].append(self.player_list[i].calc_hand_strength(self))
def evaluate(output_file, hand_cards, length, original_length, count):
print("Start: " + Card.print_pretty_cards(hand_cards))
potential_times.append(time.time())
remaining_cards = copy.deepcopy(cards)
for card in hand_cards:
remaining_cards.remove(card)
for card_combo in itertools.combinations(remaining_cards,
length - original_length):
possible_hand = hand_cards + list(card_combo)
output_file.write(
str(
evaluator.evaluate(possible_hand[0:2],
possible_hand[2:len(possible_hand)])) + ",")
if len(hand_cards) == original_length:
print("potential calc complete")
difference = time.time() - potential_times.pop()
print("Time: " + str(difference))
print("pre-return calculations")
pre_return.append(time.time())
print(count)
return
def display(self):
for i in range(self.n_players):
if self.ins[i]:
status = "in"
elif self.all_ins[i]:
status = "all in"
else:
status = "out"
print("player %d: \t Money: %d \t Bets: %d \t Status: %s " %
(i, self.money[i], self.bets[i], status))
Card.print_pretty_cards(self.hands[i])
print("board:")
Card.print_pretty_cards(self.board)
def get_action(self, data):
roundnum = data['game']['roundName']
players = data['game']['players']
chips = data['self']['chips']
hands = data['self']['cards']
self.raise_count = data['game']['raiseCount']
self.my_step = data['game']['betCount']
self.my_chips = chips
self.my_name = data['self']['playerName']
self.number_players = len(players)
self.my_call_bet = data['self']['minBet']
if self.my_call_bet == 0:
self.my_raise_bet = 0
else:
self.my_raise_bet = roundup(chips / 3, self.my_call_bet)
self.hole = []
for card in (hands):
card = convert_card_str(card)
card = Card.new(card)
self.hole.append(card)
print ("...roundnum: ", format(roundnum))
print ('...my_call_bet:', format(self.my_call_bet), "my_raise_bet", format(self.my_raise_bet), "my_chips", format(self.my_chips), "table bet", format(self.table_bet))
Card.print_pretty_cards (self.hole)
Card.print_pretty_cards (self.board)
action, amount = self.pokerbot.declareAction(
self.hole, self.board, roundnum, self.my_raise_bet, self.my_call_bet, self.table_bet,
self.number_players, self.raise_count, self.my_step, self.my_chips, self.total_bet)
self.total_bet += amount
if action == 'bet':
self.raise_count += 1
self.my_step += 1
elif action == 'call':
self.my_step += 1
return action, amount
def worker():
while True:
this_hand = q.get()
with open(
"hands/" +
Card.print_pretty_cards(this_hand).replace(" ", "_") + ".txt",
"w") as output_file:
result = evaluate(output_file, this_hand, 5, 2, 0)
output_file.close()
q.task_done()
def pretty(self):
print 'Front:'
Card.print_pretty_cards(self.front.cards)
print 'Mid:'
Card.print_pretty_cards(self.mid.cards)
print 'Back:'
Card.print_pretty_cards(self.back.cards)
def pretty(self):
print 'Front:'
Card.print_pretty_cards(self.front.cards)
print 'Mid:'
Card.print_pretty_cards(self.mid.cards)
print 'Back:'
Card.print_pretty_cards(self.back.cards)
def bet():
actions = []
maxRaise = 0
for player in curState.curPlayers:
action = player.callAI(curState)
actions.append([player, action])
if action[0][0] == "raise" and action[0][1] > maxRaise:
maxRaise = action[0][1]
for action in actions:
if maxRaise > action[1][1]:
curState.curPlayers.remove(action[0])
else:
action[0].money -= maxRaise
curState.pot += maxRaise
print "Stage: " + curState.curStage
print "Player Actions: " + str(actions)
print "Pot: " + str(curState.pot)
print "Current Players: "
for player in curState.curPlayers:
print " Hand: "
Card.print_pretty_cards(player.curHand)
print " Money: " + str(player.money)
def post_flop(players):
print('Post Flop')
deck = Deck()
player_hand, remaining_post_players = draw_count(deck.cards, 2)
adversary_hands = list()
for i in range(players):
adversary_hand, remaining_post_players = draw_count(
remaining_post_players, 2)
adversary_hands.append(adversary_hand)
player_hand_str = cards_to_str(player_hand)
flop, remaining_post_board = draw_count(remaining_post_players, 3)
print('Flop')
Card.print_pretty_cards(flop)
print()
print('Player hand')
Card.print_pretty_cards(player_hand)
print()
print('Number of adversaries: {}'.format(players))
print()
raw_input('Press enter to continue...')
outcome_counts_by_string = defaultdict(int)
draw_combos = draw_combinations(remaining_post_board, 2)
total = len(draw_combos)
for remaining, (turn, river) in draw_combos:
board = flop + [turn, river]
player_score = evaluator.evaluate(board, player_hand)
player_class = evaluator.get_rank_class(player_score)
player_class_string = evaluator.class_to_string(player_class)
validation_func = CLASS_STRING_TO_VALIDATION_FUNC[player_class_string]
if not validation_func(player_hand_str, cards_to_str(board)):
continue
outcome_counts_by_string[player_class_string] += 1
outcome_percentages_by_string = dict()
for outcome, count in outcome_counts_by_string.iteritems():
outcome_percentages_by_string[outcome] = (count / total) * 100
outcome_percentages_by_string = Counter(outcome_percentages_by_string)
print('Adversary hands')
for adversary_hand in adversary_hands:
Card.print_pretty_cards(adversary_hand)
print()
print('Outcomes')
outcomes_limit = 10
outcomes = outcome_percentages_by_string.most_common(outcomes_limit)
for outcome, percentage in outcomes:
print('{} ({}% percentage)'.format(outcome, percentage))
raw_input('Press enter to continue...')
call('clear', shell=True)
def choose_action(self, game_state, possible_actions):
while True:
board, hand, _, _ = game_state
print('Your hand is:')
Card.print_pretty_cards(hand)
print('You have %d chips remaining.' % self.stack_size)
filtered = [
'"%s" to %s' % (k, v)
for k, v in HoldEmAction.DESCRIPTIONS.iteritems()
if k in possible_actions
]
action = raw_input('Enter %s: ' % ', '.join(filtered))
if action == 'f':
return HoldEmAction.FOLD
elif action == 'c':
return HoldEmAction.CHECK
elif action == 'b':
return HoldEmAction.BET
else:
print('Unknown action "%s", please try again.' % action)
def play_single_hand(self):
stages = ['PREFLOP', 'FLOP', 'TURN', 'RIVER']
## Preflop
self.stage = stages[0]
self.deal_hole_cards()
self.take_blinds_and_ante()
self.request_player_actions()
if human_player:
print(self.stage, "POT: ", self.current_pot)
print("")
Card.print_pretty_cards(self.board)
## Flop
self.stage = stages[1]
self.board += self.deck.draw(3)
self.request_player_actions()
if human_player:
print(self.stage, "POT: ", self.current_pot)
print("")
Card.print_pretty_cards(self.board)
# River
self.stage = stages[2]
self.board += [self.deck.draw(1)]
self.request_player_actions()
if human_player:
print(self.stage, "POT: ", self.current_pot)
print("")
Card.print_pretty_cards(self.board)
# Turn
self.stage = stages[3]
self.board += [self.deck.draw(1)]
self.request_player_actions()
if human_player:
print(self.stage, "POT: ", self.current_pot)
print("")
Card.print_pretty_cards(self.board)
# self.players[0].display_game_state(self, [])
# Cleanup by allocating chips to winner
self.redistribute_pot()
def display_game_state(self, table, round_actions):
evaluator = Evaluator()
if len(table.board) > 0:
p_score = evaluator.evaluate(table.board, self.hand)
p_class = evaluator.get_rank_class(p_score)
p_string = evaluator.class_to_string(p_class)
else:
p_string = ""
os.system('clear')
print(round_actions)
print("")
print("Pot: ", table.current_pot)
print("Board: ", end="")
Card.print_pretty_cards(table.board)
print("")
print("Your hand: ", end="")
Card.print_pretty_cards(self.hand)
print("%s \n" % (p_string))
print("Your stack: %d" % self.stack)
print("")
print("Current bet: ", table.current_bet)
def printState(self):
print('Current Game State')
print('currentPlayer: {}'.format(self.state['currentPlayer']))
print('player1Hand:')
Card.print_pretty_cards(self.state['player1Hand'])
print('player2Hand:')
Card.print_pretty_cards(self.state['player2Hand'])
print('player1legalActions:{}'.format(self.state['player1legalActions']))
print('communityCards')
Card.print_pretty_cards(self.state['communityCards'])
print('player1Bets: {}'.format(self.state['player1Bets']))
print('player2Bets: {}'.format(self.state['player2Bets']))
print('player1Stack: {}'.format(self.state['player1Stack']))
print('player2Stack: {}'.format(self.state['player2Stack']))
print('player1Fold: {}'.format(self.state['player1Fold']))
print('player2Fold: {}'.format(self.state['player2Fold']))
def simmulate(self):
p1, p2 = self.players
for i, stage in enumerate(('PREFLOP', 'FLOP', 'TURN', 'RIVER')):
print(f'----{stage}----')
print(f'The pot is currently at: ${self.pot[i]}')
if stage is 'PREFLOP':
print(f'{p1} draws: ', end='')
Card.print_pretty_cards(p1.cards)
print(f'{p2} draws: ', end='')
Card.print_pretty_cards(p2.cards)
else:
print('The board is currently: ', end='')
Card.print_pretty_cards(self.board[:2 + i])
for a1, a2 in zip_longest(p1.actions[i], p2.actions[i]):
if a1 is not None:
print(f'> {p1.name} {TexasGame.ACTIONS[a1]}')
if a2 is not None:
print(f'> {p2.name} {TexasGame.ACTIONS[a2]}')
if a1 == 'f' or a2 == 'f':
break
print('----Results----')
print(f'{self.winner.name} wins ${self.winner.pot_won}!\n')
# create a card
card = Card.new('Qh')
# create a board and hole cards
board = [
Card.new('2h'),
Card.new('2s'),
Card.new('Jc')
]
hand = [
Card.new('Qs'),
Card.new('Th')
]
# pretty print cards to console
Card.print_pretty_cards(board + hand)
# create an evaluator
evaluator = Evaluator()
# and rank your hand
rank = evaluator.evaluate(board, hand)
print("Rank for your hand is: %d" % rank)
# or for random cards or games, create a deck
print("Dealing a new hand...")
deck = Deck()
board = deck.draw(5)
player1_hand = deck.draw(2)
player2_hand = deck.draw(2)
def print_deuces_card(cards):
Card.print_pretty_cards(cards)
def dealCards(self):
for i in range(0, self.player_num):
self.player_list[i].hand = self.deck.draw(2)
Card.print_pretty_cards(self.player_list[i].hand)
def takeActionByDeuces(player, action, data):
global hand
global board
board = []
board_cards = data['game']['board']
for card in board_cards:
board.append(Card.new(convertToDeucesCard(card)))
print("****** Cards Information ******")
Card.print_pretty_cards(hand)
Card.print_pretty_cards(board)
print("*******************************")
evaluator = Evaluator()
value = evaluator.evaluate(board, hand)
print("Evaluation: {}".format(value))
# calculate value of hand cards
if len(board) == 5:
board_value = evaluator.evaluate(board, [])
gap = abs(value - board_value)
print("(5 Board Cards) Gap: {}".format(gap))
if gap < 20:
take_action_fold(player)
return
elif len(board) == 4:
v1 = evaluator.evaluate(board, [hand[0]])
v2 = evaluator.evaluate(board, [hand[1]])
gap1 = abs(value - v1)
gap2 = abs(value - v2)
max_gap = max(gap1, gap2)
print("(4 Board Cards) V1: {}, V2: {}, Gap1: {}, Gap2: {}, Max Gap: {}".format(v1, v2, gap1, gap2, max_gap))
if max_gap < 20:
take_action_fold(player)
return
if value < 1000:
print(">>> bet: 1000")
ws.send(json.dumps({
"eventName": "__action",
"data": {
"action": "bet",
"playerName": player,
"amount": 1000
}
}))
elif value < 2000:
print(">>> bet: 500")
ws.send(json.dumps({
"eventName": "__action",
"data": {
"action": "bet",
"playerName": player,
"amount": 500
}
}))
elif value < 3000:
print(">>> bet: 300")
ws.send(json.dumps({
"eventName": "__action",
"data": {
"action": "bet",
"playerName": player,
"amount": 300
}
}))
elif value < 4000:
print(">>> bet: 100")
ws.send(json.dumps({
"eventName": "__action",
"data": {
"action": "bet",
"playerName": player,
"amount": 100
}
}))
elif value < 5500:
print(">>> bet: 50")
ws.send(json.dumps({
"eventName": "__action",
"data": {
"action": "bet",
"playerName": player,
"amount": 50
}
}))
elif value < 6800:
print(">>> call")
ws.send(json.dumps({
"eventName": "__action",
"data": {
"action": "call",
"playerName": player
}
}))
else:
print(">>> fold")
ws.send(json.dumps({
"eventName": "__action",
"data": {
"action": "fold",
"playerName": player
}
}))
from deuces import Card, Evaluator, Deck
# create a card
card = Card.new("Qh")
# create a board and hole cards
board = [Card.new("2h"), Card.new("2s"), Card.new("Jc")]
hand = [Card.new("Qs"), Card.new("Th")]
# pretty print cards to console
Card.print_pretty_cards(board + hand)
# create an evaluator
evaluator = Evaluator()
# and rank your hand
rank = evaluator.evaluate(board, hand)
print "Rank for your hand is: %d" % rank
# or for random cards or games, create a deck
print "Dealing a new hand..."
deck = Deck()
board = deck.draw(5)
player1_hand = deck.draw(2)
player2_hand = deck.draw(2)
print "The board:"
Card.print_pretty_cards(board)
print "Player 1's cards:"
Card.print_pretty_cards(player1_hand)
def take_action(ws, event_name, data):
global MY_SITE
global HAND_CARDS
global BOARD_CARDS
global MINBET
if event_name in ["__game_prepare", "__game_start"]:
pass
elif event_name == "__new_round":
my_site, online_player_number = get_my_site(data)
hand_cards = [player for player in data['players'] if player['playerName'] == name_md5][0]['cards']
HAND_CARDS = [Card.new('{}{}'.format(hand_card[0], str.lower(hand_card[-1]))) for hand_card in hand_cards]
if my_site == 1:
MY_SITE = SB
return
elif my_site == 2:
MY_SITE = BB
return
elif online_player_number >= 8:
if my_site <= 4:
MY_SITE = UTG
return
if online_player_number - my_site >= 2:
MY_SITE = MP
return
if online_player_number - my_site >= 1:
MY_SITE = CO
return
else:
MY_SITE = BTN
return
else:
if my_site <= 3:
MY_SITE = UTG
return
if online_player_number - my_site >= 2:
MY_SITE = MP
return
if online_player_number - my_site >= 1:
MY_SITE = CO
return
else:
MY_SITE = BTN
return
elif event_name == "__bet":
BOARD_CARDS = [Card.new('{}{}'.format(card[0], str.lower(card[-1]))) for card in data['game']['board']]
MINBET = data['self']['minBet']
Card.print_pretty_cards(HAND_CARDS + BOARD_CARDS)
win_prob = poker_deuces.calculate_winning_probability(HAND_CARDS, BOARD_CARDS, len(
[player for player in data['game']['players'] if not player['folded']]), SAMPLE_COUNT)
print('my winning probability: {}%'.format(win_prob * 100))
ws.send(json.dumps({
"eventName": "__action",
"data": {
"action": "bet"
}
}))
elif event_name == "__action":
BOARD_CARDS = [Card.new('{}{}'.format(card[0], str.lower(card[-1]))) for card in data['game']['board']]
MINBET = data['self']['minBet']
Card.print_pretty_cards(HAND_CARDS + BOARD_CARDS)
win_prob = poker_deuces.calculate_winning_probability(HAND_CARDS, BOARD_CARDS, len([player for player in data['game']['players'] if not player['folded']]), SAMPLE_COUNT)
print('my winning probability: {}%'.format(win_prob * 100))
ws.send(json.dumps({
"eventName": "__action",
"data": {
"action": "call"
}
}))
elif event_name == "__show_action":
BOARD_CARDS = [Card.new('{}{}'.format(card[0], str.lower(card[-1]))) for card in data['table']['board']]
# MINBET = data['action']['amount']
win_prob = poker_deuces.calculate_winning_probability(HAND_CARDS, BOARD_CARDS, len(
[player for player in data['players'] if not player['folded']]), SAMPLE_COUNT)
Card.print_pretty_cards(HAND_CARDS + BOARD_CARDS)
print('my winning probability: {}%'.format(win_prob * 100))
elif event_name == "__round_end":
MY_SITE = None
MINBET = None
HAND_CARDS = []
BOARD_CARDS = []
print('Round End')
elif event_name == "__game_over":
print('Game Over')
os._exit(0)
else:
pass
def __str__ (self):
return Card.print_pretty_cards(self.hand)
hand_value = 0
account_value = 0
score = 0
rank = 0
def card_allocation_module(no_of_players):
print "\nReceived input is : ", no_of_Players
return [0]
no_of_Players= raw_input("Enter your input: ");
player=[Player() for i in range(int(no_of_Players))]
for i in range(int(no_of_Players)):
player[i].hand_value=deck.draw(2)
Card.print_pretty_cards(player[i].hand_value)
##for i in range(int(no_of_Players)):
## print "\nplayer[",i,"].hand_value=",player[i].hand_value
## print "player[",i,"].account_value=",player[i].account_value
## print "player[",i,"].score=",player[i].score
card_allocation_module(no_of_Players)
print "\n"
##player[0].hand_value=deck.draw(2)
##player[1].hand_value=deck.draw(2)
Card.print_pretty_cards(board)
##Card.print_pretty_cards(player[0].hand_value)
##Card.print_pretty_cards(player[1].hand_value)
# new deck
deck = Deck()
deck.shuffle()
evaluator = Evaluator()
print "\nFirst we deal 2 cards to each team..."
ans3 = raw_input("\nHit <enter> to see the hands: ")
# random board and hands
hand1 = deck.draw(2)
hand2 = deck.draw(2)
hand3 = deck.draw(2)
hand4 = deck.draw(2)
leftovers = deck.draw(44)
# print the hands
_=os.system("clear")
print "%s TEAM has hand " % team1
Card.print_pretty_cards(hand1)
print "\n%s TEAM has hand " % team2
Card.print_pretty_cards(hand2)
print "\n%s TEAM has hand " % team3
Card.print_pretty_cards(hand3)
print "\n%s TEAM has hand " % team4
Card.print_pretty_cards(hand4)
print "\nWow nice hands!"
ans4 = raw_input("\nHit <enter> to continue: ")
_=os.system("clear")
# simulate boards
print "Now let's simulate boards..."
# win/tie counts
wins1 = 0
wins2 = 0
wins3 = 0
#go through betting stages
for stage in range(0, len(curState.stages)):
curState.curStage = curState.stages[stage]
if curState.curStage == "flop":
deal(3)
elif curState.curStage == "turn":
deal(1)
elif curState.curStage == "river":
deal(1)
bet()
#check if only one player is left
if len(curState.curPlayers) == 1:
print "Round Over"
curState.curPlayers[0].money += curState.pot
print "Winner: "
Card.print_pretty_cards(curState.curPlayers[0].curHand)
print "New Stack: " + str(curState.curPlayers[0].money)
break
#If river check who won
if curState.curStage == "river":
print "Round Over"
scores = []
for player in curState.curPlayers:
scores.append(
evaluator.evaluate(curState.board, player.curHand))
winner = scores.index(min(scores))
curState.curPlayers[winner].money += curState.pot
print "Winner: "
Card.print_pretty_cards(curState.curPlayers[winner].curHand)
print "New Stack: " + str(curState.curPlayers[winner].money)
break
from __future__ import division
import pickle
from deuces import Card, Evaluator, Deck
test = pickle.load(open("preflop_scores.p", "rb"))
pre_flop = test.copy()
for key in pre_flop:
pre_flop[key] = pre_flop[key][0] / pre_flop[key][1]
results = sorted(pre_flop.items(), key=lambda x: x[1], reverse=True)
for i in range(0, 30):
Card.print_pretty_cards(list(results[i][0]))
print "Winning Percentage: " + str(results[i][1] * 100)
def dealCards(self):
for i in range(2):
self.player_list[i].hand = self.deck.draw(2)
print self.player_list[i].name
Card.print_pretty_cards(self.player_list[i].hand)
