Ich habe versucht, Drakues Poker in Python zu implementieren

Einführung

Dieses Mal möchte ich Drakues Poker mithilfe des Decks in Vorheriger Artikel implementieren.

Normales Poker wird grundsätzlich zwischen Spielern gespielt,

• Echtzeit-Kampffunktion zwischen Spielern ist schwierig
• Keine Bluffs
• Lass es wie eine starke Karte aussehen und besiege deinen Gegner, um zu gewinnen
• Lässt den Gegner an eine schwache Karte denken und setzt mehr Geld auf den Gegner

Aus diesem Grund ist es kein Poker zwischen Spielern. Ich würde gerne ein Ein-Personen-Spiel wie Drakues Poker implementieren.

Spielfluss

Machen Sie eine Rolle im Poker → Verdoppeln Sie Ihre Punktzahl in einem Double-Up-Spiel Das ist der Grundfluss.

Funktionale Anforderungen

Basic

• Deck wird jedes Mal für Poker- und Double-Up-Spiele zurückgesetzt
• Die anfängliche Punktzahl des Spielers ist 0
• Das Double-Up-Spiel beginnt, wenn nach dem Ende des Pokers mehr als ein Rollenpaar vorhanden ist
• Kein Joker

Poker

1. 5 Karten werden ausgeteilt
2. Wählen Sie, um nacheinander zu ändern oder zu verlassen
3. Tauschen Sie die Karte aus, die Sie ändern möchten
4. Berechnung der Rolle mit 5 Karten nach dem Austausch
5. Beurteilen Sie die Rolle und entscheiden Sie die Punktzahl entsprechend der Rolle

Spiel verdoppeln

1. Es werden fünf Karten ausgeteilt (eine offen, vier verdeckt).
2. Wählen Sie aus den vier verdeckten Karten, die Ihrer Meinung nach stärker sind als die offene Karte
3. Wenn Sie stark sind, wird Ihre Punktzahl verdoppelt und Sie können das Doppelspiel erneut versuchen.
4. Wenn Sie schwach sind, erzielen Sie 0 Punkte und starten Sie beim Poker neu

Über Rollen und Partituren

• Dieses Mal werden wir es ohne Joker implementieren, also werden wir eine Fünf-Karte verwenden. In Drakue gibt es keinen königlichen Royal Straight Slime (Mark ist Slime)!

Implementierung

Wir haben die folgenden Klassen vorbereitet. Ich denke, es gibt andere gute Möglichkeiten. ..

Kartenklasse / Deckklasse

Ich habe den in diesem Artikel erstellten verwendet.

Spielerklasse

class Player:
    """
Punktzahl / Hand / Pokersieg des Spielers
    """

    def __init__(self):
        self.score = 0
        self.hands = []
        self.is_poker_win = True

    def draw_card(self, deck, num=1):
        """
Ziehe eine Karte aus dem Stapel und lege sie deiner Hand hinzu
* Auch wenn unterschiedliche Zahlen gezogen werden, ist dies in Ordnung

        Parameters
        ----------
        num : int, default 1
Häufigkeit, mit der eine Karte gezogen wird

        Examples
        --------
        >>> player.draw_card(2) #2 Unentschieden[♠︎-J, ♠︎-10]
        >>> player.draw_card(3) # [♦︎-9, ♣️-10, ♠︎-2]
        >>> print(player.hands)
        [♠︎-J, ♠︎-10, ♦︎-9, ♣️-10, ♠︎-2]
        """
        self.hands_store = deck.pick_card(num)
        self.hands.extend(self.hands_store)

Spielklasse

class Game:
    """
Hauptspiel

    Examples
    --------
    >>> game = Game()
    >>> game.main() #Spielstart (zeigt die Anfangsphase unten an)

    """

    RANKS = (*"23456789", "10", *"JQKA")
    VALUES = (range(2, 14 + 1))
    #Verknüpfen Sie die Anzeigemarke mit der Partitur
    RANK_TO_VALUES = dict(zip(RANKS, VALUES))

    def main(self):
        """
Ganzes Spiel (Poker+Chance verdoppeln)
        """
        can_play_game = True

        while can_play_game:

            #Die Spielerinformationen wurden für jedes Spiel zurückgesetzt
            player = Player()

            #Deck-Set (Anzahl der Sets bestimmen)=Baue das Deck für jedes Spiel neu
            deck = stock.Deck()
            poker = Poker(deck, player)
            poker.main_game()

            #Verdoppeln Sie die Chance mit einer Rolle
            print(player.is_poker_win)
            if player.is_poker_win:
                bonus_game = DoubleUp(player)
                bonus_game.main_game()

            #Spiel neu starten
            restart_msg = "Q beendet das Spiel, andernfalls beginnt das Spiel:"
            start_res = input(restart_msg)
            if start_res == 'Q':
                can_play_game = False


if __name__ == '__main__':
    game = Game()
    game.main()

Poker Klasse

Über das Rollenurteil

Die folgende Abbildung zeigt die Rollenbeurteilung.

class Poker:

    RANKS = (*"23456789", "10", *"JQKA")
    VALUES = (range(2, 14 + 1))
    #Verknüpfen Sie die Anzeigemarke mit der Partitur
    RANK_TO_VALUES = dict(zip(RANKS, VALUES))

    def __init__(self, deck, player):
        self.deck = deck
        self.player = player

    def change_hands(self, player_hands):
        """
Lassen Sie sie nacheinander Karten austauschen und die ausgetauschte Hand zurückgeben

        Parameters
        ----------
        player_hands : list
Spielerdeck vor dem Kartentausch

        Returns
        --------
        changed_hands : list
Spielerdeck nach dem Kartentausch
        """

        changed_hands = []

        #Wählen Sie entweder "Reiben" oder "Ändern" jeder Karte
        print("Enter \"y\" to replace the card.")

        for card_idx, change_card in enumerate(player_hands):
            change_card_msg = f"{change_card}："
            change_card_res = input(change_card_msg)

            #Wenn Sie es ändern möchten, ziehen Sie aus dem Deck und tauschen Sie die Karte aus
            if change_card_res == "y":
                #Zeichnen Sie vom Deck und überschreiben Sie
                change_card = self.deck.pick_card(1)[0]
                self.player.hands[card_idx] = change_card

            #Zum assoziativen Array hinzugefügt
            check_card_set = str(change_card).split("-")
            # ❤︎
            card_mark = check_card_set[0]
            # K
            card_rank = check_card_set[1]
            # 13
            card_number = self.RANK_TO_VALUES[card_rank]
            #Hinzufügen, um das Wörterbuch zu überprüfen
            changed_hands.append({
                "mark": card_mark,
                "rank": card_rank,
                "number": card_number
            })
        return changed_hands

    def calc_hand(self, check_hands):
        """
Berechnung der Rollen aus der Hand

        Parameters
        ----------
        check_hands : list
Spielerdeck nach dem Kartentausch

        Returns
        --------
        hand_results : dict
Status jeder Rolle im Deck des Spielers
        """

        #Blitz (gleiche Markierung)
        is_flash = True
        #Gerade (Nummern sind Seriennummern)
        is_straight = True
        #Die gleiche Zahl zählen
        same_number_count = 0
        same_number = 0
        #Anzahl der Paare (1 Paar oder 2 Paare)
        match_pair_count = 0

        #Sortieren Sie in aufsteigender Reihenfolge nach der Anzahl der Karten aus Ihrer Hand
        check_hands_sorted = sorted(check_hands, key=lambda x: x["number"])

        #Überprüfen Sie eine nach der anderen von 5 Karten
        for check_idx, check_card in enumerate(check_hands_sorted):

            #Überspringen Sie die erste Karte, da keine vorherige Karte vorhanden ist
            if check_idx == 0:
                continue

            #Vorherige Karte{'mark': '♠︎', 'rank': '4', 'number': 4}
            prev_card = check_hands_sorted[check_idx - 1]

            #Wenn die Markierungen vorne und hinten unterschiedlich sind, setzen Sie die Blitzbeurteilung auf Falsch.
            if is_flash and check_card["mark"] != prev_card["mark"]:
                is_flash = False

            #Wenn die Zahlen vorher und nachher nicht fortlaufend sind, setzen Sie das direkte Urteil auf Falsch.
            if is_straight and check_card["number"] != prev_card["number"] + 1:
                is_straight = False

            #Wenn die Zahlen vorher und nachher übereinstimmen, zählen Sie dieselbe Zahl+1
            if check_card["number"] == prev_card["number"]:
                #Anzahl der Übereinstimmungen+ 1
                same_number_count += 1

                #Letzte Karte
                if check_idx == 4:
                    if same_number_count == 1:
                        #Anzahl der Paare+ 1
                        match_pair_count += 1
                    else:
                        #3 Karten und 4 Karten
                        same_number = same_number_count + 1

            #Für verschiedene Nummern
            else:
                if same_number_count == 1:
                    #Anzahl der Paare+ 1
                    match_pair_count += 1
                elif same_number_count > 1:
                    #3 Karten und 4 Karten
                    same_number = same_number_count + 1
                #Zurücksetzen, da es sich um eine andere Nummer handelt
                same_number_count = 0

        #Zustand jeder Rolle in der Hand
        hand_results = {
            "is_flash": is_flash,
            "is_straight": is_straight,
            "same_number_count": same_number_count,
            "same_number": same_number,
            "match_pair_count": match_pair_count
        }
        return hand_results

    def showdown_hand(self, hand_status, check_hands):
        """
Bestimmen der Rolle aus dem Status der Rolle, Punkteberechnung

        Parameters
        ----------
        hand_status : dict
Der Status der Rolle des Spielers nach dem Austausch von Karten
        check_hands : list
Spielerhand

        Returns
        --------
        hand_result_msg : str
Urteilssatz der Rolle
        """

        #Ergebnis
        hand_result_msg = ""

        #Blitz und gerade
        if hand_status["is_flash"] and hand_status["is_straight"]:
            #Die kleinste Karte ist 10,Die größte Karte ist 14(A)
            if check_hands[0]["number"] == 10 and  \
                    check_hands[4]["number"] == 14:
                hand_result_msg = "Royal Straight Flush"
                self.player.score = 10000
            else:
                hand_result_msg = "Gerade bündig"
                self.player.score = 2000
        #4 Karten
        elif hand_status["same_number"] == 4:
            hand_result_msg = "4 Karten"
            self.player.score = 1000

        #3 Karten,Volles Hausurteil
        elif hand_status["same_number"] == 3:
            #3 Karten und 1 Paar
            if hand_status["match_pair_count"] == 1:
                hand_result_msg = "Volles Haus"
                self.player.score = 500
            else:
                hand_result_msg = "3 Karten"
                self.player.score = 250

        #Blitz
        elif hand_status["is_flash"]:
            hand_result_msg = "Blitz"
            self.player.score = 400

        #Gerade
        elif hand_status["is_straight"]:
            hand_result_msg = "Gerade"
            self.player.score = 300

        #2 Paar
        elif hand_status["match_pair_count"] == 2:
            hand_result_msg = "2 Paar"
            self.player.score = 200

        #1 Paar
        elif hand_status["match_pair_count"] == 1:
            hand_result_msg = "1 Paar"
            self.player.score = 150

        return hand_result_msg

    def main_game(self):
        """
Hauptspiel Poker
        """

        print("Poker Game start")

        #Ziehe zuerst 5 Karten
        self.player.draw_card(self.deck, 5)

        #Erste Kartenanzeige
        print(f"player's hands：{self.player.hands}")

        #Kartenaustauschphase
        check_hands = self.change_hands(self.player.hands)

        #Kartenanzeige nach dem Umtausch
        print(f"player's hands：{self.player.hands}")

        #Sortieren Sie in aufsteigender Reihenfolge nach der Nummer in Ihrer Hand
        check_hands_sorted = sorted(check_hands, key=lambda x: x["number"])

        #Berechnung der Rollen aus der Hand
        hand_results = self.calc_hand(check_hands_sorted)
        print(hand_results)
        #Rollenbeurteilung
        hand_result_msg = self.showdown_hand(hand_results, check_hands_sorted)

        #Verlieren, wenn es nichts gibt
        if hand_result_msg == "":
            hand_result_msg = "Es gab keine Rolle..."
            self.player.is_poker_win = False

        #Ergebnisausgabe
        print(hand_result_msg)

DoubleUp-Klasse

import re
from deck import stock


class DoubleUp:

    RANKS = (*"23456789", "10", *"JQKA")
    VALUES = (range(2, 14 + 1))
    #Verknüpfen Sie die Anzeigemarke mit der Partitur
    RANK_TO_VALUES = dict(zip(RANKS, VALUES))

    def __init__(self, player):
        self.player = player
        self.is_game_win = True

    def add_check_hands(self, player_hands):
        """
Zeigen Sie die Karten einzeln an und weisen Sie ihnen Nummern zu

        Parameters
        ----------
        player_hands : list
5 Karten in der Hand

        Returns
        --------
        check_hands : list
Spielerhand
        """

        check_hands = []
        for card_idx, card_val in enumerate(player_hands):

            #Zum assoziativen Array hinzugefügt
            check_card_set = str(card_val).split("-")
            # ❤︎
            card_mark = check_card_set[0]
            # K
            card_rank = check_card_set[1]
            # 13
            card_number = self.RANK_TO_VALUES[card_rank]
            #Hinzufügen, um das Wörterbuch zu überprüfen
            check_hands.append({
                "mark": card_mark,
                "rank": card_rank,
                "number": card_number
            })
            #Der erste kann nicht ausgewählt werden
            if card_idx >= 1:
                #ausblenden
                # print(f"{card_idx}：*-*")
                print(f"{card_idx}：{card_val}")

        return check_hands

    def win_judge_selected_card(self, input_res, check_hands):
        """
Game Win Judgement (Vergleiche ausgewählte Karte mit offener Karte)

        Parameters
        ----------
        input_res : str
Die im Befehl eingegebene Nummer
        check_hands : list
Spielerhand
        """

        if re.compile(r'^[1-4]+$').match(input_res) is not None:
            #Vergleich der Nummerngröße der Karte mit der ausgewählten Nummer und der offenen Karte
            if check_hands[int(input_res)]["number"] >= check_hands[0]["number"]:
                #Verdoppeln Sie die Punktzahl, wenn sie groß ist
                print("win!")
                self.player.score *= 2
            else:
                #Wenn klein,Erziele 0 und beginne erneut mit Poker
                print("lose..")
                self.player.score = 0
                self.is_game_win = False
        else:
            print("Ist nutzlos")

    def main_game(self):
        """
Verdoppeln Sie das Hauptspiel
        """

        while self.is_game_win:
            #Deckrekonstruktion
            self.deck = stock.Deck()
            print("double-Up Chance Game start")
            print(f"Now, your score is {self.player.score} points.")
            self.player.hands = []

            #Gib 5 Karten vom Stapel aus
            self.player.draw_card(self.deck, 5)

            #1 von 5 ist verdeckt, 4 verdeckt
            print(f"player's hands：{self.player.hands[0]}, *-*, *-*, *-*, *-*")

            #Zeigen Sie die Karten einzeln an und weisen Sie ihnen Nummern zu
            check_hands = self.add_check_hands(self.player.hands)

            #Wählen Sie eine der vier verdeckten Karten, die stärker ist als die Zahl auf der offenen Karte
            card_select_msg = f"Enter a card number that is stronger than {self.player.hands[0]}："
            card_select_res = input(card_select_msg)

            #Wählen Sie eine der Nummern 1 bis 4
            self.win_judge_selected_card(card_select_res, check_hands)

            print(self.player.score)

Bewegung

$ python main.py
Poker Game start

player's hands：[❤︎-4, ♠︎-9, ♣️-4, ♠︎-3, ♠︎-2]
Enter "y" to replace the card.
❤︎-4：
♠︎-9： y
♣️-4：
♠︎-3： y
♠︎-2： y
player's hands：[❤︎-4, ❤︎-K, ♣️-4, ♠︎-K, ♣️-6]
2 Paar

double-Up Chance Game start
Now, your score is 100 points.
player's hands：♠︎-6, *-*, *-*, *-*, *-*
1：*-*
2：*-*
3：*-*
4：*-*
Enter a card number that is stronger than ♠︎-6： 2
Selected card is ❤︎-12
win!
200

double-Up Chance Game start
Now, your score is 200 points.
player's hands：♠︎-K, *-*, *-*, *-*, *-*
1：*-*
2：*-*
3：*-*
4：*-*
Enter a card number that is stronger than ♠︎-K： 3
Selected card is ♦︎-2
lose..
0

Beende das Spiel mit Q, starte das Spiel ansonsten: Q.

• Alle diesmal erstellten Dateien werden auf hier veröffentlicht.