Рубрики
Без рубрики

Blackjack Python построить игру в блэкджек

В этом руководстве мы осмотрим, как создать командную строку игры для игры в блэкджек, используя Python! Эй… Теги с учебником, Python, начинающим, Ооп.

В этом руководстве мы осмотрим, как создать командную строку игры для игры в блэкджек, используя Python! Вы получите построить игру от начала до конца, и когда вы закончите, у вас будет полностью функционирующая игра, чтобы играть из командной строки.

Потрясая игру, мы рассмотрим несколько удобных концепций Python, такие как объектно-ориентированные программирование с использованием классов и как управлять игровой петлей. Этот учебник также извлекается со всего курса по созданию игры в блэкджек, используя графическую пользовательскую среду (GUI), которую вы можете проверить здесь если тебе интересно.

Звук веселый? Давай сделаем это!

Blackjack – это азартная игра, которая требует только колода открыток. Цель игры состоит в том, чтобы стать как можно ближе к руке на сумму 21 баллов, когда дилер переворачивает свои карты – но перейти и вы выходите!

В блэкджек, пронумерованные карты (2 по 10) стоят своего значения лица, картинки (Джек, королева и король) стоят 10, а туз стоит либо 1 или 11 в зависимости от ваших других карт. Чтобы начать руку, игроки размещают свои ставки и имеют дело с двумя картами лицом вверх. Они могут выбрать «ударить» (получить другую карту) или «палку» (остаться с их текущей рукой), поскольку они пытаются получить как можно ближе к 21. Если они решили поразить и пройти 21, они «бюст» и теряют руку (и деньги, которые они делают!).

Игроки сталкиваются с дилером, который начинается с одной карты лицом вниз, и один лицом вверх. Когда все игроки решили придерживаться или выровняли, дилер затем переворачивает свою скрытую карту, либо попадает в палки, их цель, чтобы получить высшую руку, чем любой из игроков.

Если дилер бюст, они выплачивают ценность парика каждого игрока к этому игроку, при условии, что игрок еще не разогнал. Им также нужно выплатить, если они не получит более высокую руку, чем игрок.

Есть много других правил (конечно!) что вы можете Читайте на Если вы заинтересованы, но вышеизложенное это все, что вам нужно знать, чтобы построить эту игру.

Хорошо, давайте начнем с некоторыми кодировкой!

Если у вас еще нет Python установлен на вашем компьютере, вам нужно будет делать это на основе инструкций здесь Отказ Если вы предпочитаете избежать этого, вы можете получить онлайн-кодирующую песочницу с Python и другие необходимые библиотеки, предварительно установленные здесь (Войти обязательно).

Прежде чем начать кодирование нашей игры Blackjack, важно, чтобы мы охватываем, как мы будем использовать объектно-ориентированные программирование, поскольку нам нужно будет использовать классы для нашей игры.

Начнем с определения классов, которые будут использоваться для того, чтобы разделить различные аспекты игры в блэкджек. Мы будем моделировать три компонента игры:

  • Карта : Базовая игральная карта. Карта принадлежит костюму (сердца ♥, алмазы ♦, пики ♠, или клубы ♣) и стоит определенного значения.
  • Палуба : Коллекция карт. Палуба сокращается, поскольку карты нарисованы и содержит 52 уникальных карт.
  • Рука : Присвоенные карты каждого игрока. Рука – это то, что определяет счет каждого игрока и, таким образом, кто победит.

Начнем с простейшей концепции: Карта Отказ

Карта Класс станет первым классом, который мы определяем, поскольку оба наших других занятия нужно будет использовать его. Создайте файл Python под названием Blackjack.py Затем добавьте следующий код:

import random

class Card:
    def __init__(self, suit, value):
        self.suit = suit
        self.value = value

    def __repr__(self):
        return " of ".join((self.value, self.suit))

Единственный импорт, который нам понадобится для нашей игры, это Случайные модуль. Это позволит нам перетасовать нашу виртуальную колоду карточек в начале каждой игры.

Наш первый класс будет одним из представлять игровые карты. Каждая карта будет иметь костюм (сердца, бриллианты, пики и клубы) и значение (ACE через царь). Мы определяем __repr__ Функция, чтобы изменить, как отображается карта, когда мы звоним Печать в теме. Наша функция вернет стоимость и исправление, например, Король пиков . Это все, что нам нужно сделать для Карта Действительно

Далее, нам нужно создать Палуба Из этих Карта классы.

Палуба Нужно содержать 52 уникальных карт и должен быть в состоянии перемешать себя. Это также нужно будет иметь возможность справиться с картами и уменьшением размера, поскольку карты удалены. Создать Палуба класс в Blackjack.py Файл, используя код ниже:

class Deck:
    def __init__(self):
        self.cards = [Card(s, v) for s in ["Spades", "Clubs", "Hearts",
                      "Diamonds"] for v in ["A", "2", "3", "4", "5", "6", 
                      "7", "8", "9", "10", "J", "Q", "K"]]

    def shuffle(self):
        if len(self.cards) > 1:
            random.shuffle(self.cards)

    def deal(self):
        if len(self.cards) > 1:
            return self.cards.pop(0)

При создании экземпляра Палуба Нам просто нужно иметь коллекцию каждой возможной карты. Мы достигаем этого, используя понимание списка, содержащие списки каждого костюма и стоимости. Мы передаем каждую комбинацию к инициализации для нашего Карта класс для создания 52 уникальных Карта экземпляры.

Наше Палуба должен быть в состоянии быть перетасовываться так, чтобы каждая игра была другая. Мы используем Shuffle Функция в Случайные Библиотека, чтобы сделать это для нас (как фитинг). Чтобы избежать любых потенциальных ошибок, мы будем перенастроить только палубу, которая все еще имеет два или более карт в ней, так как перетасовка одна или нулевые карты бессмыслены.

После перетасовки нам тоже нужно будет разобраться на картах. Мы используем поп Функция списка (которая является структурой данных, удерживающая наши карты), чтобы вернуть верхнюю карту и удалить ее с колоды, чтобы она нельзя разобраться снова.

Вот и это для Палуба класс! Окончательный класс утилиты, который будет создан для нашей игры на работу, это Рука Отказ У всех игроков есть рука карт, и каждая рука стоит численное значение, основанное на карточках, которые он содержит.

А Рука Класс должен будет содержать карты, как Палуба класс делает. Это также будет присвоено значение по правилам игры на основе каких карт. Поскольку рука дилера должна отображать только одну карту, мы также отслеживаем ли Рука принадлежит дилеру, чтобы удовлетворить это правило.

Начните с ниже, чтобы создать Рука класс в Blackjack.py файл:

class Hand:
    def __init__(self, dealer=False):
        self.dealer = dealer
        self.cards = []
        self.value = 0

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

Очень похоже на Палуба , а Рука проведет свои карты как список Карта экземпляры. При добавлении карты в руку мы просто добавляем Карта Пример к нашему карты список.

В пределах Рука Класс, расчет в настоящее время проведенного карты Значение – это то, где правила игры приходят в игру больше всего:

    def calculate_value(self):
        self.value = 0
        has_ace = False
        for card in self.cards:
            if card.value.isnumeric():
                self.value += int(card.value)
            else:
                if card.value == "A":
                    has_ace = True
                    self.value += 11
                else:
                    self.value += 10

        if has_ace and self.value > 21:
            self.value -= 10

    def get_value(self):
        self.calculate_value()
        return self.value

Вы можете отметить, что вышеуказанный код уже с отступом. Это намеренно и сделано ниже! Таким образом, вам не нужно выполнять самих отступов и может сосредоточиться на чтении инструкций и кода вместо того, чтобы преследовать ошибки пробела.

В этом коде мы сначала инициализируем ценность рук до 0 И предположим, что у игрока нет туза (поскольку это особый случай).

Затем мы петлю через Карта Экземпляры и попытайтесь добавить их значение в качестве номера для всего игрока, используя следующую логику:

  1. Если значение карты является численным, мы добавляем его значение стоимости этой руки ( Self.Value ).
  2. Если это не численно, мы проверяем, является ли карта тузом. Если это так, мы добавляем 11 на ценность по руке и установить has_ace Флаг к Правда Отказ
  3. Если это не туз, мы просто добавляем 10 к ценности руки.

Как только это сделано, мы проверяем, был ли туз и увеличение 11 Очки принесли ценность руки над 21 Отказ Если это так, мы заставляем туз стоит 1 вместо того, чтобы вычитаться 10 от ценности по руке.

Теперь нам нужен какой-то способ отображать карты каждой руки, поэтому мы используем простой функцию для печати каждой карты в руке, а также значение рук игрока. Первая карта дилера находится вниз, поэтому мы печатаем скрытый вместо:

    def display(self):
        if self.dealer:
            print("hidden")
            print(self.cards[1])
        else:
            for card in self.cards:
                print(card)
            print("Value:", self.get_value())

Теперь, когда у нас есть все наши базовые структуры данных, пришло время для основной игровой петли!

Мы определим главный цикл игры в пределах своей Играть Метод, так что начать игру, вам просто нужно будет создать экземпляр Игра класс и звонок .играть () в теме:

class Game:
    def __init__(self):
        pass

    def play(self):
        playing = True

        while playing:
            self.deck = Deck()
            self.deck.shuffle()

            self.player_hand = Hand()
            self.dealer_hand = Hand(dealer=True)

            for i in range(2):
                self.player_hand.add_card(self.deck.deal())
                self.dealer_hand.add_card(self.deck.deal())

            print("Your hand is:")
            self.player_hand.display()
            print()
            print("Dealer's hand is:")
            self.dealer_hand.display()

Приведенный выше код довольно длительный, так что давайте сломаемся вниз:

  • Мы начинаем с нашей петли с логией ( играя ), которая будет использоваться для отслеживания того, все еще играем в игру.
  • Если мы есть, нам нужен перетасованный Палуба и два Рука экземпляры – один для дилера и один для игрока.
  • Мы используем Диапазон Функция, чтобы иметь дело с двумя карточками каждого игрока и дилера. Наше Сделка Метод вернет Карта экземпляр, который передается на Add_Card Метод нашего Рука экземпляры.
  • Наконец, мы поставляем руки к нашему игроку. Мы можем использовать Дисплей Метод на нашем Рука экземпляры для печати этого на экран.

Это отмечает конец кода, который должен работать в начале каждой новой игры. Теперь мы входим в цикл, которая будет работать, пока победитель не будет решен. Мы снова контролируем это с логией ( Game_over ):

            game_over = False

            while not game_over:
                player_has_blackjack, dealer_has_blackjack = self.check_for_blackjack()

Перед продолжением, нам сначала нужно проверить за блэкджек. Если любой игрок был нанесен ACE и картинной карточкой, их рука будет содержать 21 Итак, они автоматически выигрывают. Давайте создадим метод, чтобы сделать это (под Play Метод):

    def check_for_blackjack(self):
        player = False
        dealer = False
        if self.player_hand.get_value() == 21:
            player = True
        if self.dealer_hand.get_value() == 21:
            dealer = True

        return player, dealer

Нам нужно отслеживать, какой игрок может быть блэкджек, поэтому мы будем держать логию для игрока ( Player ) и дилер ( Дилер ).

Далее вернитесь к пока не игра_over петля внутри Играть () метод. Нам нужно проверить, итоги ли либо рука 21 , что мы сделаем, используя два Если заявления. Если либо имеет значение рук 21 Их булева изменена на Правда Отказ

Если любой из логиков – Правда Затем у нас есть победитель, и распечатаю победителя на экран и Продолжить Таким образом, нарушая нас из игрового цикла. Чтобы сделать это, добавьте ниже прямо под Player_has_blackjack, .check_for_blackjackjack () Линия кода:

                if player_has_blackjack or dealer_has_blackjack:
                    game_over = True
                    self.show_blackjack_results(
                        player_has_blackjack, dealer_has_blackjack)
                    continue

Мы должны еще раз приостановить создать метод show_blackjack_results () , который будет распечатать победителя на экран. Мы делаем это, добавив код ниже под check_for_blackjackack Метод:

    def show_blackjack_results(self, player_has_blackjack, dealer_has_blackjack):
        if player_has_blackjack and dealer_has_blackjack:
            print("Both players have blackjack! Draw!")

        elif player_has_blackjack:
            print("You have blackjack! You win!")

        elif dealer_has_blackjack:
            print("Dealer has blackjack! Dealer wins!")

Если ни у одного игрока не было блэкджека, игровая петля будет продолжаться.

Теперь игрок может сделать выбор – независимо от того, добавлять больше карт в их руку (ударить) или отправить свою текущую руку (палку). Чтобы сделать это, добавьте ниже на Играть Метод:

                choice = input("Please choose [Hit / Stick] ").lower()
                while choice not in ["h", "s", "hit", "stick"]:
                    choice = input("Please enter 'hit' or 'stick' (or H/S) ").lower()

Мы используем вход Функция для сбора выбора от пользователя. Это всегда будет возвращать нам строку, содержащую текст, который пользователь, набранный в командную строку.

Поскольку у нас есть строка, мы можем отбросить вход пользователя в строчные, используя Нижнее Функция, чтобы избежать необходимости проверки комбинаций верхнего и нижнего региона при расстановке их ответа.

Если их вклад не распознан, мы просто будем продолжать просить его снова, пока оно не будет:

                if choice in ['hit', 'h']:
                    self.player_hand.add_card(self.deck.deal())
                    self.player_hand.display()

Если игрок выбрал ударить, им нужно будет добавить дополнительную карту в их руку. Это делается так же, как и раньше с сделка () а также add_card () методы.

Поскольку их полное изменилось, нам теперь нужно проверить, являются ли они более допустимыми пределами 21 Отказ Давайте определим метод, который делает это сейчас:

    def player_is_over(self):
        return self.player_hand.get_value() > 21

Этот метод просто проверяет, стоит ли значение рук игрока 21 и возвращает информацию как логический.

Теперь, обратно в Играть Метод, добавьте следующее внутри Если выбор в [«Хит», «H»] блокировать:

                    if self.player_is_over():
                        print("You have lost!")
                        game_over = True

Если рука игрока имеет значение над 21 , они потеряли, поэтому игровая петля должна сломаться, и мы устанавливаем game_over к Правда (Указание того, что дилер выиграл).

Хорошо, теперь давайте справимся, когда игрок решит придерживаться рукой. Если они это сделают, пришло время для их оценки сравнивать с дилером. Чтобы сделать это, добавьте ниже, выровненный с Если выбор в [«Хит», «H»] утверждение:

                else:
                    player_hand_value = self.player_hand.get_value()
                    dealer_hand_value = self.dealer_hand.get_value()

                    print("Final Results")
                    print("Your hand:", player_hand_value)
                    print("Dealer's hand:", dealer_hand_value)

                    if player_hand_value > dealer_hand_value:
                        print("You Win!")
                    elif player_hand_value == dealer_hand_value:
                        print("Tie!")
                    else:
                        print("Dealer Wins!")
                    game_over = True

Мы используем еще Заявление здесь, потому что мы уже установили, что ответ пользователя был либо ударен, либо палкой, и мы только что проверили удары. Это означает, что мы попадем только в этот блок, когда пользователь хочет придерживаться.

Значение как игрок, так и руку дилера печатаются на экран, чтобы дать окончательные результаты. Затем мы сравним значения каждой руки, чтобы увидеть, что выше.

Если рука игрока является более высокой ценностью, чем дилер, мы печатаем Ты победил! . Если баллы равны, то у нас есть галстук, поэтому мы печатаем Галстук! . В противном случае дилер должен иметь высшую руку, чем игрок, поэтому мы показываем Дилер выигрывает! .

Это завершает логику, необходимую для пользователя, чтобы играть в одну игру. Теперь давайте позволим им играть в другую игру, добавив следующие в конце Играть Способ, снаружи в то время как петля:

            again = input("Play Again? [Y/N] ")
            while again.lower() not in ["y", "n"]:
                again = input("Please enter Y or N ")
            if again.lower() == "n":
                print("Thanks for playing!")
                playing = False
            else:
                game_over = False

Мы еще раз используем комбинацию Нижнее и а в то время как петля, чтобы обеспечить наш ответ – y или n Отказ Если игрок отвечает с n Мы благодарим их за игру и установили наши Играть Логический до Ложь Таким образом, нарушив нас из основной игровой петли и заканчивая программой. Если нет, они, должно быть, ответили на y Итак, мы устанавливаем game_over к Ложь И позвольте нашу главную петлю снова запуститься. Это отвезут нас прямо на вершину на Self.Deck () Чтобы создать совершенно новую игру.

Мы завершили игру! Теперь пришло время запустить этот код. Для этого мы просто создаем экземпляр Игра Класс в конце файла и позвоните Играть () Метод:

if __name__ == "__main__":
    game = Game()
    game.play()

Теперь у нас есть игра, придайте ему игру. Вы можете начать игру, набрав Python3 Blackjack.py В вашу командную строку (или нажатие синей кнопки «Запустить», если вы используете ранее песочницу).

Вы должны увидеть что-то вроде следующего, напечатанного на экран:

workspace $ python3 blackjack.py
Your hand is:
A of Diamonds
5 of Clubs
Value: 16

Dealer's hand is:
hidden
A of Clubs
Please choose [Hit / Stick] H
A of Diamonds
5 of Clubs
10 of Hearts
Value: 16
Please choose [Hit / Stick] H
A of Diamonds
5 of Clubs
10 of Hearts
2 of Clubs
Value: 18
Please choose [Hit / Stick] S
Final Results
Your hand: 18
Dealer's hand: 16
You Win!
Play Again? [Y/N] N
Thanks for playing!

Поздравляю на протяжении прохождения в этом руководстве! В нем мы покрыли, как построить удобные концепции, такие как объектно-ориентированные программирование, дизайн потока игр и даже основы блэкджека.

Если вы застряли, можно найти полное решение для этого проекта здесь Отказ Вы также можете запустить онлайн-кодирующую песочницу с помощью предварительной загрузки здесь Отказ

Два ограничения этой игры заключаются в том, что дилер никогда не ударит, и нет концепции ставок. Не стесняйтесь добавлять эти функции себя, если вы хотите! Поскольку дилер обязан ударить или придерживаться определенных ценностей для рук, вы можете разработать программу, которая точно имитирует дилер.

Вы также можете проверить Полный курс За этим руководством, если вы хотите!

Оригинал: “https://dev.to/nexttech/build-a-blackjack-command-line-game-3o4b”