blackjack.py

import random
import copy


#constant
NUM_DECK = 6  #Number of decks
NUM_PLAYER = 1  #Number of players

INITIAL_CHIP = 1000  #Initial chip
MINIMUM_BET = 100


class Card:
    '''
Generate card
Numbers: A, 2-10, J, Q, K
Suits: spades, hearts, diamonds, clubs
    '''
    SUITS = '♠♥♦♣'
    RANKS = range(1, 14)  #Normal Rank
    SYMBOLS = "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"
    POINTS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10]  #Points for BlackJack

    def __init__(self, suit, rank):
        self.suit = suit
        self.rank = rank
        self.index = suit + self.SYMBOLS[rank - self.RANKS[0]]
        self.point = self.POINTS[rank - self.RANKS[0]]

    def __repr__(self):
        return self.index


class Deck:
    '''
Deck with shuffled cards (generate deck)
    '''
    def __init__(self):
        self.cards = [Card(suit, rank) \
            for suit in Card.SUITS \
            for rank in Card.RANKS]

        if NUM_DECK > 1:
            temp_cards = copy.deepcopy(self.cards)
            for i in range(NUM_DECK - 1):
                self.cards.extend(temp_cards)
        random.shuffle(self.cards)

    def draw(self, n=1):
        '''
A function that subtracts the specified number of cards from the deck
        '''
        cards = self.cards[:n]
        del self.cards[:n]  #Delete the drawn card from the deck
        return cards

    def shuffle(self):
        '''
Shuffle the deck
        '''
        random.shuffle(self.cards)
        return

    def count_cards(self):
        """
Return the remaining number of decks
        """
        count = len(self.cards)
        return count


class Hand:
    """
Hand class
    """
    def __init__(self):
        self.hand = []
        self.is_soft_hand = False

    def add_card(self, card):
        self.hand.append(card)

    def check_soft_hand(self):
        """
Check if it is a soft hand (hand including A)
        """
        hand_list = []
        for i in range(len(self.hand)):
            hand_list.append(self.hand[i].point)
        hand_list.sort()  #Sort your hand in ascending order

        if hand_list[0] == 1 and sum(hand_list[1:]) < 11:  #With a soft hand
            self.is_soft_hand = True
        else:
            self.is_soft_hand = False

    def sum_point(self):
        """
Returns the total value of points
        """
        self.check_soft_hand()
        hand_list = []

        for i in range(len(self.hand)):
            hand_list.append(self.hand[i].point)
        hand_list.sort()  #Sort your hand in ascending order
        s1 = 0  #Initial value when counting A as 1
        for i in range(len(self.hand)):
            s1 += self.hand[i].point

        if self.is_soft_hand == True:  #With a soft hand
            s2 = 11  #Count the first A as 11
            for i in range(len(hand_list)-1):
                s2 += hand_list[i+1]
            s = [s1, s2]
        else:
            s = [s1]

        return s

    def calc_final_point(self):
        """
Returns the final point not BUST
        """
        temp_point = self.sum_point()
        if max(temp_point) > 22:
            p = temp_point[0]  #If the one with the larger points is BUST, the one with the smaller points
        else:
            p = max(temp_point)
        return p

    def is_bust(self):
        """
Determine if it is BUST
        """
        if min(self.sum_point()) > 21:  #If the smaller point exceeds 21
            return True
        else:
            return False

    def deal(self, card):
        """
Add the Dealed card to your hand
        """
        for i in range(len(card)):
            self.add_card(card[i])

    def hit(self, card):
        #Hit one by one
        if len(card) == 1:
            self.add_card(card[0])
        else:
            print("The number of cards is incorrect")


class Player:
    def __init__(self):
        self.hand = Hand()
        self.chip = Chip()
        self.done = False  #Flag indicating the end of the player's turn
        self.hit_flag = False  #Flag indicating whether Player has selected Hit
        self.is_human = True  # True:People play, False:Auto play

    def init_player(self):
        self.hand = Hand()
        self.done = False
        self.hit_flag = False

    def deal(self, card):
        self.hand.deal(card)

    def hit(self, card):
        #Add 1 card to your hand
        self.hand.hit(card)
        self.hit_flag = True

    def stand(self):
        #End of turn
        self.done = True

    def double_down(self, card):
        #Double the bet and hit only once to end the turn
        self.chip.balance -= self.chip.bet
        self.chip.bet = self.chip.bet * 2
        self.hand.hit(card)
        self.done = True  #Make it a rule that you can hit only once after double down

    def surrender(self):
        #Halve the Bet (return half of the bet to hand) and end the turn
        # self.chip.balance += int(self.chip.bet / 2)
        self.chip.bet = int(self.chip.bet / 2)
        self.chip.balance += self.chip.bet
        self.done = True

    def insurance(self):
        #Unimplemented
        pass

    def split(self):
        #Unimplemented
        pass


class Dealer:
    def __init__(self):
        self.hand = Hand()

    def init_dealer(self):
        self.hand = Hand()

    def deal(self, card):
        self.hand.deal(card)

    def hit(self, card):
        self.hand.hit(card)


class Chip:
    def __init__(self):
        self.balance = INITIAL_CHIP
        self.bet = 0

    def bet_chip(self, bet):
        #If you hang Chip, reduce from hand
        self.balance -= bet
        self.bet = bet

    def pay_chip_win(self):
        #When you win, you get twice as much as BET
        self.balance += self.bet * 2

    def pay_chip_lose(self):
        #When you lose, you lose all BET
        self.balance = self.balance

    def pay_chip_push(self):
        #When drawing, return by the amount of BET
        self.balance += self.bet


class AI:
    def select_random1(self):
        r = random.randint(0, 1)
        if r > 0.5:
            selection = 'h'  # hit
        else:
            selection = 's'  # stand

        return selection

    def select_random2(self, hand):
        if hand <= 11:
            selection = 'h'
        else:
            r = random.randint(0, 1)
            if r > 0.5:
                selection = 'h'  # hit
            else:
                selection = 's'  # stand

        return selection

    def select_random3(self, hand, n):
        if hand < 11:
            selection = 'h'  # hit
        elif hand == 11 and n == 2:
            selection = 'd'  # double down
        elif hand == 16 and n == 2:
            selection = 'r'  # surrender
        elif hand > 17:
            selection = 's'  # stand
        else:
            r = random.randint(0, 1)
            if r > 0.5:
                selection = 'h'  # hit
            else:
                selection = 's'  # stand

        return selection


class Game:
    def __init__(self):
        self.game_mode = 0  # 0:Waiting for start, 1:In-game, 2:Game over
        self.deck = Deck()
        self.player = Player()
        self.dealer = Dealer()
        self.judgment = 0
        self.game_count = 0
        self.start()

        self.message_on = True #self.player.is_human  # True:Display a message on the console, False:Do not display messages on the console

    def start(self):
        self.deck.shuffle()
        self.game_mode = 1
        self.player = Player()
        self.dealer = Dealer()
        self.game_count = 0

    def reset_game(self):
        self.player.init_player()
        self.dealer.init_dealer()
        self.game_count += 1

    def bet(self, bet):
        self.player.chip.bet_chip(bet=bet)
        if self.message_on:
            print("$" + str(self.player.chip.bet) + "I bet")
            print("The rest$" + str(self.player.chip.balance))

    #Deal cards
    def deal(self, n=2):
        '''
Deal cards
        '''
        card = self.deck.draw(n)
        self.player.deal(card)
        # print(self.player.hand.hand)

        card = self.deck.draw(n)
        self.dealer.deal(card)
        # print(self.dealer.hand.hand)

        self.judgment = 0   #Judgment of victory or defeat
        self.player.done = False
        self.show_card()

    #Player's turn
    def player_turn(self):
        '''
Player turn
        '''
        if self.player.hand.calc_final_point() == 21:  #If the total is 21, immediately go to Dealer's turn
            self.player.done = True

        while not self.player.done and not self.player.hand.is_bust():
            if self.player.is_human is True:
                action = input("Hit(h) or Stand(s) or Double down(d) or Surrender(r): ")
            elif self.player.is_human is True and self.player.hit_flag:
                action = input("Hit(h) or Stand(s): ")  #Hit after hit/stand only
            else:
                action = AI().select_random3(hand=self.player.hand.calc_final_point(), n=len(self.player.hand.hand))

            self.player_step(action=action)

    def player_step(self, action):
        if action == 'h':  # Hit
            card = self.deck.draw(1)
            self.player.hit(card)
            self.show_card()
            if self.player.hand.calc_final_point() == 21:  #No more hits when the total score reaches 21
                self.player.done = True
            if self.player.hand.is_bust():
                self.player.done = True
                self.judgment = -1  #If Player BUST, lose immediately
                if self.message_on:
                    print("Player BUST")

        elif action == 's':  # Stand
            self.player.stand()

        elif action == 'd' and self.player.hit_flag is False:  # Double down.Yes if Hit is not selected
            card = self.deck.draw(1)
            if self.player.chip.balance >= self.player.chip.bet:  #Double Down is possible if the balance is more than the bet amount
                self.player.double_down(card)
                self.show_card()
                if self.message_on:
                    print("Double down has been selected. Doubled the bet")
                    print("The rest$" + str(self.player.chip.balance))
                if self.player.hand.is_bust():
                    self.player.done = True
                    self.judgment = -1  #If Player BUST, lose immediately
                    if self.message_on:
                        print("Player BUST")
            else:  #Hit if the balance is less than the bet amount
                print("Hit because there are not enough chips")
                self.player.hit(card)
                self.show_card()
                if self.player.hand.calc_final_point() == 21:  #No more hits when the total score reaches 21
                    self.player.done = True
                if self.player.hand.is_bust():
                    self.player.done = True
                    self.judgment = -1  #If Player BUST, lose immediately
                    if self.message_on:
                        print("Player BUST")

        elif action == 'r' and self.player.hit_flag is False:  # Surrender.Yes if Hit is not selected
            self.player.surrender()
            self.judgment = -1  #Lost because I chose Surrender
            if self.message_on:
                print("Surrender selected")

        else:
            if self.message_on:
                print("Choose the right option")

    def show_card(self):
        '''
Show player card
        '''
        if self.message_on:
            print("Player's turn")
            print("Player : " + str(self.player.hand.hand) + " = " +
                  str(self.player.hand.sum_point()) + ", soft card : " + str(self.player.hand.is_soft_hand))
            print("Dealer : " + str(self.dealer.hand.hand[0].index) +
                  ", ? = " + str(self.dealer.hand.hand[0].point))
        else:
            pass

    def dealer_turn(self):
        '''
Dealer turn
        '''
        if self.judgment == -1:
            return
        self.open_dealer()
        while self.dealer.hand.calc_final_point() < 17 and self.judgment == 0:
            card = self.deck.draw(1)
            self.dealer.hit(card)
            self.open_dealer()
        if self.dealer.hand.calc_final_point() > 21:
            self.judgment = 1
            if self.message_on:
                print("Dealer BUST")

    def open_dealer(self):
        '''
Open a hole card
        '''
        if self.message_on:
            print("Dealer's turn")
            print("Player : " + str(self.player.hand.hand) + " = " +
                  str(self.player.hand.calc_final_point()))
            print("Dealer : " + str(self.dealer.hand.hand) + " = " +
                  str(self.dealer.hand.calc_final_point()))
        else:
            pass

    def judge(self):
        '''
Judgment of victory or defeat
        '''
        if self.judgment == 0 and self.player.hand.calc_final_point() > \
                self.dealer.hand.calc_final_point():
            self.judgment = 1
        elif self.judgment == 0 and self.player.hand.calc_final_point() < \
                self.dealer.hand.calc_final_point():
            self.judgment = -1
        elif self.judgment == 0 and self.player.hand.calc_final_point() == \
                self.dealer.hand.calc_final_point():
            self.judgment = 0

        if self.message_on:
            self.show_judgement()

    def pay_chip(self):
        previous_chip = self.player.chip.balance
        if self.judgment == 1:  # Player win
            self.player.chip.pay_chip_win()
        elif self.judgment == -1:  # Player lose
            self.player.chip.pay_chip_lose()
        elif self.judgment == 0:  # Push
            self.player.chip.pay_chip_push()
        if self.message_on:
            print("Player's chips$" + str(self.player.chip.balance))

        reward = self.player.chip.balance - previous_chip  #Rewards earned in this game
        return reward

    def check_chip(self):
        if self.player.chip.balance < MINIMUM_BET:
            self.game_mode = 2
            if self.message_on:
                print("The game ends because the chips are below the Minimum Bet")

    def show_judgement(self):
        '''
Display of victory or defeat
        '''
        if self.message_on:
            print("")
            if self.judgment == 1:
                print("Player wins")
            elif self.judgment == -1:
                print("Player loses")
            elif self.judgment == 0:
                print("draw")
            print("")
        else:
            pass

    def ask_next_game(self):
        '''
Ask if you want to continue the game
        '''
        if self.player.is_human == True:
            while self.game_mode == 1:
                player_input = input("Do you want to continue? y/n: ")
                if player_input == 'y':
                    break
                elif player_input == 'n':
                    self.game_mode = 2
                    break
                else:
                    print('y/Please enter n')
        else:
            pass  #Continue with automatic play
        print('The number of remaining cards' + str(self.deck.count_cards()))
        print("")

    def check_deck(self):
        '''
Check the remaining number of cards and shuffle if there are few
        '''
        if self.deck.count_cards() < NUM_PLAYER * 10 + 5:
            self.deck = Deck()
            if self.message_on:
                print("Initialized the deck")
                print('The number of remaining cards' + str(self.deck.count_cards()))
                print("")


def main():
    game = Game()
    game.start()
    while game.game_mode == 1:
        game.reset_game()       #Reset various
        game.bet(bet=100)       #bet
        game.deal()             #Deal cards
        game.player_turn()      #Player turn
        game.dealer_turn()      #Dealer turn
        game.judge()            #Judgment of victory or defeat
        game.pay_chip()         #Tip settlement
        game.check_chip()       #Check the player's balance
        game.ask_next_game()    #Ask if you want to continue the game
        game.check_deck()       #Check the number of remaining cards

    print("Exit BlackJack")
    print(str(game.game_count) + "I played the game times")

    return game.player.chip, game.game_count


if __name__ == '__main__':
    main()

Recommended Posts