blackjack.py

import random
import copy


#Konstante
NUM_DECK = 6  #Anzahl der Decks
NUM_PLAYER = 1  #Anzahl der Spieler

INITIAL_CHIP = 1000  #Anfänglicher Chip
MINIMUM_BET = 100


class Card:
    '''
Karte generieren
Zahlen: A, 2-10, J, Q, K.
Ruß: Spaten, Herz, Diamant, Keule
    '''
    SUITS = '♠♥♦♣'
    RANKS = range(1, 14)  #Normaler Rang
    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]  #Punkte für 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 mit gemischten Karten (Deck generieren)
    '''
    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):
        '''
Eine Funktion, die die angegebene Anzahl von Blättern vom Deck subtrahiert
        '''
        cards = self.cards[:n]
        del self.cards[:n]  #Lösche die gezogene Karte aus dem Stapel
        return cards

    def shuffle(self):
        '''
Mische das Deck
        '''
        random.shuffle(self.cards)
        return

    def count_cards(self):
        """
Geben Sie die verbleibende Anzahl von Decks zurück
        """
        count = len(self.cards)
        return count


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

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

    def check_soft_hand(self):
        """
Überprüfen Sie, ob es sich um eine weiche Hand handelt (Hand einschließlich A).
        """
        hand_list = []
        for i in range(len(self.hand)):
            hand_list.append(self.hand[i].point)
        hand_list.sort()  #Sortieren Sie Ihre Hand in aufsteigender Reihenfolge

        if hand_list[0] == 1 and sum(hand_list[1:]) < 11:  #Mit einer weichen Hand
            self.is_soft_hand = True
        else:
            self.is_soft_hand = False

    def sum_point(self):
        """
Gibt den Gesamtwert der Punkte zurück
        """
        self.check_soft_hand()
        hand_list = []

        for i in range(len(self.hand)):
            hand_list.append(self.hand[i].point)
        hand_list.sort()  #Sortieren Sie Ihre Hand in aufsteigender Reihenfolge
        s1 = 0  #Anfangswert beim Zählen von A als 1
        for i in range(len(self.hand)):
            s1 += self.hand[i].point

        if self.is_soft_hand == True:  #Mit einer weichen Hand
            s2 = 11  #Zähle das erste A als 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):
        """
Gibt den Endpunkt nicht BUST zurück
        """
        temp_point = self.sum_point()
        if max(temp_point) > 22:
            p = temp_point[0]  #Wenn der mit den größeren Punkten BUST ist, der mit den kleineren Punkten
        else:
            p = max(temp_point)
        return p

    def is_bust(self):
        """

        """
        if min(self.sum_point()) > 21:  #Wenn der kleinere Punkt 21 überschreitet
            return True
        else:
            return False

    def deal(self, card):
        """
Fügen Sie die ausgegebene Karte Ihrer Hand hinzu
        """
        for i in range(len(card)):
            self.add_card(card[i])

    def hit(self, card):
        #Schlagen Sie einen nach dem anderen
        if len(card) == 1:
            self.add_card(card[0])
        else:
            print("Die Anzahl der Karten ist falsch")


class Player:
    def __init__(self):
        self.hand = Hand()
        self.chip = Chip()
        self.done = False  #Flagge, die das Ende des Zuges des Spielers anzeigt
        self.hit_flag = False  #Flag, das angibt, ob der Spieler Treffer ausgewählt hat
        self.is_human = True  # True:Die Leute spielen, falsch:Automatisches Abspielen

    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):
        #Füge deiner Karte 1 Karte hinzu
        self.hand.hit(card)
        self.hit_flag = True

    def stand(self):
        #Ende der Runde
        self.done = True

    def double_down(self, card):
        #Verdoppeln Sie den Einsatz und treffen Sie nur einmal, um den Zug zu beenden
        self.chip.balance -= self.chip.bet
        self.chip.bet = self.chip.bet * 2
        self.hand.hit(card)
        self.done = True  #Machen Sie es sich zur Regel, dass Sie nach dem Double-Down nur einmal treffen können

    def surrender(self):
        #Halbieren Sie den Einsatz (geben Sie die Hälfte des Einsatzes zurück) und beenden Sie den Zug
        # 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):
        #Nicht implementiert
        pass

    def split(self):
        #Nicht implementiert
        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):
        #Wenn Sie Chip hängen, reduzieren Sie von Hand
        self.balance -= bet
        self.bet = bet

    def pay_chip_win(self):
        #Wenn Sie gewinnen, erhalten Sie doppelt so viel wie BET
        self.balance += self.bet * 2

    def pay_chip_lose(self):
        #Wenn Sie verlieren, verlieren Sie alle WETTEN
        self.balance = self.balance

    def pay_chip_push(self):
        #Geben Sie beim Zeichnen den Betrag von BET zurück
        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:Warten auf den Start, 1:Im Spiel, 2:Spiel ist aus
        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:Zeigen Sie auf der Konsole die Meldung Falsch an:Zeigen Sie keine Nachrichten auf der Konsole an

    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) + "ich wette")
            print("Der Rest$" + str(self.player.chip.balance))

    #Karten austeilen
    def deal(self, n=2):
        '''
Karten austeilen
        '''
        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   #Urteil über Sieg oder Niederlage
        self.player.done = False
        self.show_card()

    #Spieler ist an der Reihe
    def player_turn(self):
        '''
Spieler an der Reihe
        '''
        if self.player.hand.calc_final_point() == 21:  #Wenn die Summe 21 ist, ist der Händler sofort an der Reihe
            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): ")  #Treffer für Treffer/nur stehen
            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:  #Keine Treffer mehr, wenn die Gesamtpunktzahl 21 erreicht
                self.player.done = True
            if self.player.hand.is_bust():
                self.player.done = True
                self.judgment = -1  #Wenn Spieler BUST, verlieren Sie sofort
                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.Ja, wenn Treffer nicht ausgewählt ist
            card = self.deck.draw(1)
            if self.player.chip.balance >= self.player.chip.bet:  #Double Down ist möglich, wenn der Kontostand den Einsatzbetrag übersteigt
                self.player.double_down(card)
                self.show_card()
                if self.message_on:
                    print("Double Down wurde ausgewählt. Verdoppelte die Wette")
                    print("Der Rest$" + str(self.player.chip.balance))
                if self.player.hand.is_bust():
                    self.player.done = True
                    self.judgment = -1  #Wenn Spieler BUST, verlieren Sie sofort
                    if self.message_on:
                        print("Player BUST")
            else:  #Treffen Sie, wenn der Kontostand unter dem Einsatz liegt
                print("Hit, weil es nicht genug Chips gibt")
                self.player.hit(card)
                self.show_card()
                if self.player.hand.calc_final_point() == 21:  #Keine Treffer mehr, wenn die Gesamtpunktzahl 21 erreicht
                    self.player.done = True
                if self.player.hand.is_bust():
                    self.player.done = True
                    self.judgment = -1  #Wenn Spieler BUST, verlieren Sie sofort
                    if self.message_on:
                        print("Player BUST")

        elif action == 'r' and self.player.hit_flag is False:  # Surrender.Ja, wenn Treffer nicht ausgewählt ist
            self.player.surrender()
            self.judgment = -1  #Verloren, weil ich mich für Surrender entschieden habe
            if self.message_on:
                print("Übergabe ausgewählt")

        else:
            if self.message_on:
                print("Wählen Sie die richtige Option")

    def show_card(self):
        '''
Spielerkarte anzeigen
        '''
        if self.message_on:
            print("Spieler ist an der Reihe")
            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):
        '''
Händler ist an der Reihe
        '''
        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):
        '''
Öffne eine Hole Card
        '''
        if self.message_on:
            print("Händler ist an der Reihe")
            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):
        '''
Urteil über Sieg oder Niederlage
        '''
        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("Ballbesitz-Chip des Spielers$" + str(self.player.chip.balance))

        reward = self.player.chip.balance - previous_chip  #In diesem Spiel verdiente Belohnungen
        return reward

    def check_chip(self):
        if self.player.chip.balance < MINIMUM_BET:
            self.game_mode = 2
            if self.message_on:
                print("Das Spiel endet, weil der Chip unter dem Mindesteinsatz liegt")

    def show_judgement(self):
        '''
Anzeige von Sieg oder Niederlage
        '''
        if self.message_on:
            print("")
            if self.judgment == 1:
                print("Spieler gewinnt")
            elif self.judgment == -1:
                print("Spieler verliert")
            elif self.judgment == 0:
                print("zeichnen")
            print("")
        else:
            pass

    def ask_next_game(self):
        '''
Fragen Sie, ob Sie das Spiel fortsetzen möchten
        '''
        if self.player.is_human == True:
            while self.game_mode == 1:
                player_input = input("Wollen Sie fortfahren? y/n: ")
                if player_input == 'y':
                    break
                elif player_input == 'n':
                    self.game_mode = 2
                    break
                else:
                    print('y/Bitte geben Sie n ein')
        else:
            pass  #Fahren Sie mit der automatischen Wiedergabe fort
        print('Die Anzahl der verbleibenden Karten' + str(self.deck.count_cards()))
        print("")

    def check_deck(self):
        '''
Überprüfen Sie die verbleibende Anzahl von Karten und mischen Sie, wenn es nur wenige gibt
        '''
        if self.deck.count_cards() < NUM_PLAYER * 10 + 5:
            self.deck = Deck()
            if self.message_on:
                print("Das Deck wurde initialisiert")
                print('Die Anzahl der verbleibenden Karten' + str(self.deck.count_cards()))
                print("")


def main():
    game = Game()
    game.start()
    while game.game_mode == 1:
        game.reset_game()       #Verschiedene zurücksetzen
        game.bet(bet=100)       #Wette
        game.deal()             #Karten austeilen
        game.player_turn()      #Spieler an der Reihe
        game.dealer_turn()      #Händler ist an der Reihe
        game.judge()            #Urteil über Sieg oder Niederlage
        game.pay_chip()         #Abrechnung von Chips
        game.check_chip()       #Überprüfen Sie das Guthaben des Spielers
        game.ask_next_game()    #Fragen Sie, ob Sie das Spiel fortsetzen möchten
        game.check_deck()       #Überprüfen Sie die Anzahl der verbleibenden Karten

    print("Beenden Sie BlackJack")
    print(str(game.game_count) + "Ich habe die Spielzeiten gespielt")

    return game.player.chip, game.game_count


if __name__ == '__main__':
    main()

Recommended Posts