Esempio n. 1
0
    def run_main_loop(self):
        active_players = self.get_active_players()
        dealer = self.dealer
        while len(active_players) > 0:
            for player in active_players:
                if player.will_hit():
                    self.deal_card(player)
                    if player.hand.get_score() > 21:
                        self.end_player_turn(player, 'L')
                else:
                    self.stand(player)
            active_players = self.get_active_players()
            logger.info('[ROUND] {0} active players left'.format(
                len(active_players)))

        while dealer.will_hit():
            self.deal_card(dealer)
        dealer_score = dealer.hand.get_score()

        for player in self.get_standing_players():
            player_score = player.hand.get_score()
            if dealer_score > 21:
                result = 'W'
            else:
                if player_score == dealer_score:
                    result = 'D'
                elif player_score > dealer_score:
                    result = 'W'
                else:
                    result = 'L'
            self.end_player_turn(player, result)
Esempio n. 2
0
    def start_round(self):
        logger.info('[START]')
        logger.info('[CARDS] {0}'.format(
            list(card.value for card in self.deck.cards)))

        self.deal_starting_hands()
        self.pay_out_naturals()
        self.run_main_loop()
        results = self.generate_round_results()
        self.reset_records()
        return results
Esempio n. 3
0
 def deal_card(self, player, face_up=True):
     card = self.deck.deal()
     logger.info('[HIT] ({0}) {1}'.format(player, card))
     player.hand.add_card(card)
     if face_up:
         self.notify_players(card, player == self.dealer)
     if self.shuffle_counter > self.max_deals:
         self.notify_players_shuffle()
         self.deck.shuffle()
         self.shuffle_counter = 0
     self.shuffle_counter += 1
Esempio n. 4
0
 def run(self, rounds):
     game = self.game
     player_results = dict()
     for i in range(rounds):
         logger.info('[GAME] Round {0} start'.format(i))
         results = game.start_round()
         if i == 0:
             for player_result in results:
                 player_results[player_result.player] = [player_result]
         else:
             for player_result in results:
                 player_results[player_result.player].append(player_result)
         logger.info('[GAME] Round {0} end'.format(i))
     return player_results
Esempio n. 5
0
    def end_player_turn(self, player, result, natural=False):
        """
        End turn with provided result and split bets accordingly.

        Arguments:
        player  -- Currently playing
        result  -- ['W', 'L', 'D'] for win, loss or draw
        natural -- Indicates if the player has a natural 21
        """
        logger.info('[RESULT] {0}: {1}'.format(player, result))
        bet = self.player_records[player].bet
        if result == 'W':
            if natural:
                bet = bet * 1.5
            self.dealer.pay(player, bet)
        elif result == 'L':
            player.pay(self.dealer, bet)

        self.set_player_finished(player, result)
Esempio n. 6
0
 def stand(self, player):
     self.player_records[player].is_standing = True
     logger.info('[STAND] ({0})'.format(player))
Esempio n. 7
0
 def pay(self, player, bet):
     logger.info('[BET] {0} gave {1} chips to {2}.'.format(
         self, bet, player))
     self.balance -= bet
     player.balance += bet