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 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)