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,

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

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

Rollenname Kartenstatus Beispiel einer Hand Ergebnis
1 Paar Ein Paar der gleichen Nummer [♣️-4, ♠︎-4, ♦︎-Q, ♠︎-K, ❤︎-5] 50
2 Paar Zwei Paare derselben Nummer [♣️-4, ♠︎-4, ♦︎-Q, ♠︎-Q, ❤︎-5] 100
3 Karten 3 gleiche Nummern [♣️-4, ♠︎-4, ♦︎-4, ♠︎-Q, ❤︎-5] 200
Gerade Die Zahlen sind fortlaufend [♣️-3, ♠︎-4, ♦︎-5, ♠︎-6, ❤︎-7] 300
Blitz Alle Marken sind gleich [♠︎-3, ♠︎-4, ♠︎-5, ♠︎-Q, ♠︎-9] 400
Volles Haus 3 gleiche Nummern+1 Paar [♠︎-3, ♠︎-4, ♠︎-5, ♠︎-Q, ♠︎-9] 500
Vier Karten 4 gleiche Nummern [♠︎-4, ♦︎-4, ♠︎-4, ♣️-4, ❤︎-9] 1000
Gerade bündig Blitz und gerade [♠︎-4, ♠︎-5, ♠︎-6, ♠︎-7, ♠︎-8] 2000
Royal Straight Flush Blitz und gerade [♠︎-10, ♠︎-J, ♠︎-Q, ♠︎-K, ♠︎-A] 10000

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.

poker.png

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.

Recommended Posts

Ich habe versucht, Drakues Poker in Python zu implementieren
Ich habe versucht, PLSA in Python zu implementieren
Ich habe versucht, Permutation in Python zu implementieren
Ich habe versucht, PLSA in Python 2 zu implementieren
Ich habe versucht, ADALINE in Python zu implementieren
Ich habe versucht, PPO in Python zu implementieren
Ich habe versucht, TOPIC MODEL in Python zu implementieren
Ich habe versucht, eine selektive Sortierung in Python zu implementieren
Ich habe versucht, einen Pseudo-Pachislot in Python zu implementieren
Ich habe versucht, GA (genetischer Algorithmus) in Python zu implementieren
Ich habe versucht, einen eindimensionalen Zellautomaten in Python zu implementieren
Ich habe versucht, die Mail-Sendefunktion in Python zu implementieren
Ich habe versucht, das Blackjack of Trump-Spiel mit Python zu implementieren
Ich habe versucht, ein missverstandenes Gefangenendilemma in Python zu implementieren
Ich habe versucht, die Bayes'sche lineare Regression durch Gibbs-Sampling in Python zu implementieren
Ich habe versucht, StarGAN (1) zu implementieren.
Ich habe versucht, Trumps Kartenspiel in Python zu implementieren
Ich habe versucht, die in Python installierten Pakete grafisch darzustellen
Ich möchte Timeout einfach in Python implementieren
Ich habe versucht, Mine Sweeper auf dem Terminal mit Python zu implementieren
Ich habe versucht, künstliches Perzeptron mit Python zu implementieren
Ich habe versucht zusammenzufassen, wie man Pandas von Python benutzt
Ich habe versucht, die Zusammenführungssortierung in Python mit möglichst wenigen Zeilen zu implementieren
Ich habe versucht, ein scheinbar Windows-Snipper-Tool mit Python zu implementieren
Ich habe versucht, Deep VQE zu implementieren
Ich habe versucht, Python zu berühren (Installation)
Ich habe versucht, eine kontroverse Validierung zu implementieren
Ich habe versucht, Realness GAN zu implementieren
Ich habe Line Benachrichtigung in Python versucht
Ich habe versucht, API list.csv mit Python aus swagger.yaml zu erstellen
Ich habe versucht "Wie man eine Methode in Python dekoriert"
Ich habe eine Stoppuhr mit tkinter mit Python gemacht
Ich habe versucht, die Behandlung von Python-Ausnahmen zusammenzufassen
Ich habe versucht, Autoencoder mit TensorFlow zu implementieren
Python3-Standardeingabe habe ich versucht zusammenzufassen
Ich habe versucht, die Bayes'sche Optimierung von Python zu verwenden
Ich wollte ABC159 mit Python lösen
Ich habe versucht, CVAE mit PyTorch zu implementieren
[Python] Ich habe versucht, TF-IDF stetig zu berechnen
Ich habe versucht, Python zu berühren (grundlegende Syntax)
[Python] Ich habe versucht, den kollektiven Typ (Satz) auf leicht verständliche Weise zusammenzufassen.
Ich habe versucht, einen Formatierer zu entwickeln, der Python-Protokolle in JSON ausgibt
Ich habe versucht, AtCoders Depth Priority Search (DFS) in Python zu lösen (Ergebnis: TLE ...)
Ich habe versucht, das Lesen von Dataset mit PyTorch zu implementieren
Ich möchte Dunnetts Test in Python machen
Versuchen Sie, Oni Mai Tsuji Miserable mit Python zu implementieren
Ich möchte mit Python ein Fenster erstellen
Ich habe versucht, mit Python ein Tippspiel zu spielen
So implementieren Sie Shared Memory in Python (mmap.mmap)
Ich habe versucht, Keras in TFv1.1 zu integrieren
Ich habe versucht, "Birthday Paradox" mit Python zu simulieren
Ich habe die Methode der kleinsten Quadrate in Python ausprobiert
Geschrieben "Einführung in die Effektüberprüfung" in Python
Ich habe versucht, LLVM IR mit Python auszugeben
Ich möchte verschachtelte Dicts in Python zusammenführen
Ich habe versucht, das Verhalten von E / A-Eventlets in Python nicht zu blockieren
Ich habe versucht, die Herstellung von Sushi mit Python zu automatisieren
Ich habe versucht, ein Python 3-Modul in C hinzuzufügen