blackjack.py

import random
import copy


#constant
NUM_DECK = 6  #Nombre de ponts
NUM_PLAYER = 1  #Nombre de joueurs

INITIAL_CHIP = 1000  #Puce initiale
MINIMUM_BET = 100


class Card:
    '''
Générer une carte
Numéros: A, 2-10, J, Q, K
Suie: pique, coeurs, diamants, clubs
    '''
    SUITS = '♠♥♦♣'
    RANKS = range(1, 14)  #Rang normal
    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 pour Black Jack

    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 avec des cartes mélangées (générer un 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):
        '''
Une fonction qui soustrait le nombre spécifié de feuilles du jeu
        '''
        cards = self.cards[:n]
        del self.cards[:n]  #Supprimer la carte piochée du paquet
        return cards

    def shuffle(self):
        '''
Mélangez le jeu
        '''
        random.shuffle(self.cards)
        return

    def count_cards(self):
        """
Renvoie le nombre restant de jeux
        """
        count = len(self.cards)
        return count


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

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

    def check_soft_hand(self):
        """
Vérifiez s'il s'agit d'une main douce (main comprenant A)
        """
        hand_list = []
        for i in range(len(self.hand)):
            hand_list.append(self.hand[i].point)
        hand_list.sort()  #Triez votre main par ordre croissant

        if hand_list[0] == 1 and sum(hand_list[1:]) < 11:  #D'une main douce
            self.is_soft_hand = True
        else:
            self.is_soft_hand = False

    def sum_point(self):
        """
Renvoie la valeur totale des points
        """
        self.check_soft_hand()
        hand_list = []

        for i in range(len(self.hand)):
            hand_list.append(self.hand[i].point)
        hand_list.sort()  #Triez votre main par ordre croissant
        s1 = 0  #Valeur initiale lors du comptage de A comme 1
        for i in range(len(self.hand)):
            s1 += self.hand[i].point

        if self.is_soft_hand == True:  #D'une main douce
            s2 = 11  #Comptez le premier A comme 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):
        """
Renvoie le dernier point pas BUST
        """
        temp_point = self.sum_point()
        if max(temp_point) > 22:
            p = temp_point[0]  #Si celui avec les plus gros points est BUST, celui avec les plus petits points
        else:
            p = max(temp_point)
        return p

    def is_bust(self):
        """
Déterminez si c'est BUST
        """
        if min(self.sum_point()) > 21:  #Si le point le plus petit dépasse 21
            return True
        else:
            return False

    def deal(self, card):
        """
Ajoutez la carte distribuée à votre main
        """
        for i in range(len(card)):
            self.add_card(card[i])

    def hit(self, card):
        #Frappez un par un
        if len(card) == 1:
            self.add_card(card[0])
        else:
            print("Le nombre de cartes est incorrect")


class Player:
    def __init__(self):
        self.hand = Hand()
        self.chip = Chip()
        self.done = False  #Drapeau indiquant la fin du tour du joueur
        self.hit_flag = False  #Drapeau indiquant si le joueur a sélectionné Hit
        self.is_human = True  # True:Les gens jouent, faux:Lecture automatique

    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):
        #Ajoutez 1 carte à votre main
        self.hand.hit(card)
        self.hit_flag = True

    def stand(self):
        #Fin de tour
        self.done = True

    def double_down(self, card):
        #Doublez la mise et ne frappez qu'une seule fois pour terminer le tour
        self.chip.balance -= self.chip.bet
        self.chip.bet = self.chip.bet * 2
        self.hand.hit(card)
        self.done = True  #Faites-en une règle selon laquelle vous ne pouvez toucher qu'une seule fois après avoir doublé

    def surrender(self):
        #Réduire de moitié la mise (remettre la moitié de la mise en main) et terminer le tour
        # 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):
        #Non mis en œuvre
        pass

    def split(self):
        #Non mis en œuvre
        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):
        #Si vous accrochez Chip, réduisez de la main
        self.balance -= bet
        self.bet = bet

    def pay_chip_win(self):
        #Lorsque vous gagnez, vous obtenez deux fois plus que BET
        self.balance += self.bet * 2

    def pay_chip_lose(self):
        #Quand tu perds, tu perds tous les paris
        self.balance = self.balance

    def pay_chip_push(self):
        #Lors du tirage, retournez par le montant de 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:En attente de démarrage, 1:En jeu, 2:Jeu terminé
        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:Afficher un message sur la console, False:Ne pas afficher de messages sur la 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) + "je parie")
            print("Le reste$" + str(self.player.chip.balance))

    #Distribuer des cartes
    def deal(self, n=2):
        '''
Distribuer des cartes
        '''
        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   #Jugement de victoire ou de défaite
        self.player.done = False
        self.show_card()

    #Tour du joueur
    def player_turn(self):
        '''
Tour du joueur
        '''
        if self.player.hand.calc_final_point() == 21:  #Si le total est de 21, passez immédiatement au tour du croupier
            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): ")  #Coup après coup/se tenir debout seulement
            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:  #Lorsque le score total atteint 21, vous ne pouvez plus frapper
                self.player.done = True
            if self.player.hand.is_bust():
                self.player.done = True
                self.judgment = -1  #Si le joueur BUST, perd immédiatement
                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.Oui si Hit n'est pas sélectionné
            card = self.deck.draw(1)
            if self.player.chip.balance >= self.player.chip.bet:  #Double Down est possible si le solde est supérieur au montant du pari
                self.player.double_down(card)
                self.show_card()
                if self.message_on:
                    print("Le double vers le bas a été sélectionné. Double la mise")
                    print("Le reste$" + str(self.player.chip.balance))
                if self.player.hand.is_bust():
                    self.player.done = True
                    self.judgment = -1  #Si le joueur BUST, perd immédiatement
                    if self.message_on:
                        print("Player BUST")
            else:  #Frapper si le solde est inférieur au pari
                print("Frappez parce qu'il n'y a pas assez de jetons")
                self.player.hit(card)
                self.show_card()
                if self.player.hand.calc_final_point() == 21:  #Lorsque le score total atteint 21, vous ne pouvez plus frapper
                    self.player.done = True
                if self.player.hand.is_bust():
                    self.player.done = True
                    self.judgment = -1  #Si le joueur BUST, perd immédiatement
                    if self.message_on:
                        print("Player BUST")

        elif action == 'r' and self.player.hit_flag is False:  # Surrender.Oui si Hit n'est pas sélectionné
            self.player.surrender()
            self.judgment = -1  #Perdu parce que j'ai choisi Surrender
            if self.message_on:
                print("Remise sélectionnée")

        else:
            if self.message_on:
                print("Choisissez la bonne option")

    def show_card(self):
        '''
Afficher la carte du joueur
        '''
        if self.message_on:
            print("Tour du joueur")
            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):
        '''
Tour du concessionnaire
        '''
        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):
        '''
Ouvrez une carte fermée
        '''
        if self.message_on:
            print("Tour du concessionnaire")
            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):
        '''
Jugement de victoire ou de défaite
        '''
        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("Puce de possession du joueur$" + str(self.player.chip.balance))

        reward = self.player.chip.balance - previous_chip  #Récompenses gagnées dans ce jeu
        return reward

    def check_chip(self):
        if self.player.chip.balance < MINIMUM_BET:
            self.game_mode = 2
            if self.message_on:
                print("Le jeu se termine car le jeton est en dessous de la mise minimum")

    def show_judgement(self):
        '''
Affichage de la victoire ou de la défaite
        '''
        if self.message_on:
            print("")
            if self.judgment == 1:
                print("Le joueur gagne")
            elif self.judgment == -1:
                print("Le joueur perd")
            elif self.judgment == 0:
                print("dessiner")
            print("")
        else:
            pass

    def ask_next_game(self):
        '''
Demandez si vous souhaitez continuer le jeu
        '''
        if self.player.is_human == True:
            while self.game_mode == 1:
                player_input = input("Voulez-vous continuer? y/n: ")
                if player_input == 'y':
                    break
                elif player_input == 'n':
                    self.game_mode = 2
                    break
                else:
                    print('y/Veuillez entrer n')
        else:
            pass  #Continuer avec la lecture automatique
        print('Le nombre de cartes restantes' + str(self.deck.count_cards()))
        print("")

    def check_deck(self):
        '''
Vérifiez le nombre de cartes restantes et mélangez s'il y en a peu
        '''
        if self.deck.count_cards() < NUM_PLAYER * 10 + 5:
            self.deck = Deck()
            if self.message_on:
                print("Initialisation du deck")
                print('Le nombre de cartes restantes' + str(self.deck.count_cards()))
                print("")


def main():
    game = Game()
    game.start()
    while game.game_mode == 1:
        game.reset_game()       #Réinitialiser divers
        game.bet(bet=100)       #pari
        game.deal()             #Distribuer des cartes
        game.player_turn()      #Tour du joueur
        game.dealer_turn()      #Tour du concessionnaire
        game.judge()            #Jugement de victoire ou de défaite
        game.pay_chip()         #Règlement des copeaux
        game.check_chip()       #Vérifiez le solde du joueur
        game.ask_next_game()    #Demandez si vous souhaitez continuer le jeu
        game.check_deck()       #Vérifiez le nombre de cartes restantes

    print("Quitter BlackJack")
    print(str(game.game_count) + "J'ai joué les temps de jeu")

    return game.player.chip, game.game_count


if __name__ == '__main__':
    main()

Recommended Posts