J'ai essayé d'implémenter le poker de Drakue en Python

introduction

Cette fois, j'aimerais implémenter le poker de Drakue en utilisant le deck de Article précédent.

Le poker normal se joue essentiellement entre les joueurs,

• La fonction de combat en temps réel entre les joueurs est difficile
• Pas de bluffs
• Faites en sorte que cela ressemble à une carte forte et abattez votre adversaire pour gagner
• Fait penser à l'adversaire une carte faible et mise plus d'argent sur l'adversaire

Pour cette raison, ce n’est pas du poker entre joueurs, J'aimerais mettre en place un jeu à une personne comme le poker de Drakue.

Flux de jeu

Jouez un rôle au poker → Doublez votre score dans une partie en double C'est le flux de base.

Exigences fonctionnelles

De base

• Le deck se réinitialise à chaque fois pour les parties de poker et de double
• Le score initial du joueur est de 0
• Le jeu en double commence s'il y a plus d'une paire de rôles après la fin du poker
• Pas de joker

poker

1. 5 cartes sont distribuées
2. Sélectionnez pour modifier ou laisser un par un
3. Échangez la carte que vous avez choisi de changer
4. Calcul du rôle avec 5 cartes après remplacement
5. Juger le rôle et décider du score en fonction du rôle

Double jeu

1. Cinq cartes sont distribuées (une face visible, quatre faces cachées)
2. Choisissez parmi les quatre cartes face cachée que vous pensez être plus fortes que la carte face recto
3. Si vous êtes fort, votre score sera doublé et vous pourrez réessayer le jeu du double.
4. Si faible, marquez 0, redémarrez du poker

À propos des rôles et des scores

• Cette fois, nous allons l'implémenter sans joker, donc cinq cartes, Il n'y a pas de slime royal droit supérieur (la marque est slime) dans Drakue!

la mise en oeuvre

Nous avons préparé les classes suivantes. Je pense qu'il existe d'autres bons moyens. ..

Classe de carte / classe de deck

J'ai utilisé celui créé dans cet article tel quel.

Classe de joueur

class Player:
    """
Score du joueur / main / drapeau de victoire au poker
    """

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

    def draw_card(self, deck, num=1):
        """
Piochez une carte du jeu et ajoutez-la à votre main
* Même si différents numéros sont tirés, c'est ok

        Parameters
        ----------
        num : int, default 1
Nombre de fois pour piocher une carte

        Examples
        --------
        >>> player.draw_card(2) #2 nuls[♠︎-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)

Classe de jeu

class Game:
    """
Jeu principal

    Examples
    --------
    >>> game = Game()
    >>> game.main() #Début du jeu (affiche la phase initiale ci-dessous)

    """

    RANKS = (*"23456789", "10", *"JQKA")
    VALUES = (range(2, 14 + 1))
    #Associer la marque d'affichage à la partition
    RANK_TO_VALUES = dict(zip(RANKS, VALUES))

    def main(self):
        """
Jeu entier (poker+Double chance)
        """
        can_play_game = True

        while can_play_game:

            #Réinitialisation des informations du joueur pour chaque partie
            player = Player()

            #Deck set (déterminer le nombre d'ensembles)=Reconstruire le deck pour chaque partie
            deck = stock.Deck()
            poker = Poker(deck, player)
            poker.main_game()

            #Doublez vos chances avec un rôle
            print(player.is_poker_win)
            if player.is_poker_win:
                bonus_game = DoubleUp(player)
                bonus_game.main_game()

            #Redémarrage du jeu
            restart_msg = "Q termine le jeu, sinon le jeu commence:"
            start_res = input(restart_msg)
            if start_res == 'Q':
                can_play_game = False


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

Cours de poker

À propos du jugement de rôle

La figure ci-dessous montre le jugement de rôle.

class Poker:

    RANKS = (*"23456789", "10", *"JQKA")
    VALUES = (range(2, 14 + 1))
    #Associer la marque d'affichage à la partition
    RANK_TO_VALUES = dict(zip(RANKS, VALUES))

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

    def change_hands(self, player_hands):
        """
Laissez-les échanger les cartes une par une et renvoyer la main échangée

        Parameters
        ----------
        player_hands : list
Deck de joueur avant l'échange de cartes

        Returns
        --------
        changed_hands : list
Deck du joueur après avoir échangé des cartes
        """

        changed_hands = []

        #Sélectionnez "Frotter" ou "Changer" chaque carte
        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)

            #Si vous voulez le changer, tirez dans le paquet et échangez la carte
            if change_card_res == "y":
                #Dessiner à partir du pont et écraser
                change_card = self.deck.pick_card(1)[0]
                self.player.hands[card_idx] = change_card

            #Ajouté au tableau associatif
            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]
            #Ajouter au dictionnaire de vérification
            changed_hands.append({
                "mark": card_mark,
                "rank": card_rank,
                "number": card_number
            })
        return changed_hands

    def calc_hand(self, check_hands):
        """
Calcul des rôles de la main

        Parameters
        ----------
        check_hands : list
Deck du joueur après avoir échangé des cartes

        Returns
        --------
        hand_results : dict
Statut de chaque rôle dans le deck du joueur
        """

        #Flash (même marque)
        is_flash = True
        #Droit (les numéros sont des numéros de série)
        is_straight = True
        #Compter le même nombre
        same_number_count = 0
        same_number = 0
        #Nombre de paires (1 paire ou 2 paires)
        match_pair_count = 0

        #Trier par ordre croissant en fonction du nombre de cartes de votre main
        check_hands_sorted = sorted(check_hands, key=lambda x: x["number"])

        #Vérifiez une par une parmi 5 cartes
        for check_idx, check_card in enumerate(check_hands_sorted):

            #Ignorer la première carte car il n'y a pas de carte précédente
            if check_idx == 0:
                continue

            #Carte précédente{'mark': '♠︎', 'rank': '4', 'number': 4}
            prev_card = check_hands_sorted[check_idx - 1]

            #Si les marques recto et verso sont différentes, définissez le jugement du flash sur Faux.
            if is_flash and check_card["mark"] != prev_card["mark"]:
                is_flash = False

            #Si les nombres ne sont pas continus avant et après, définissez le jugement direct sur Faux.
            if is_straight and check_card["number"] != prev_card["number"] + 1:
                is_straight = False

            #Si les nombres correspondent avant et après, comptez le même nombre+1
            if check_card["number"] == prev_card["number"]:
                #Nombre de matchs+ 1
                same_number_count += 1

                #Dernière carte
                if check_idx == 4:
                    if same_number_count == 1:
                        #Nombre de paires+ 1
                        match_pair_count += 1
                    else:
                        #3 cartes et 4 cartes
                        same_number = same_number_count + 1

            #Pour différents numéros
            else:
                if same_number_count == 1:
                    #Nombre de paires+ 1
                    match_pair_count += 1
                elif same_number_count > 1:
                    #3 cartes et 4 cartes
                    same_number = same_number_count + 1
                #Réinitialiser car il s'agit d'un numéro différent
                same_number_count = 0

        #État de chaque rôle dans la main
        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):
        """
Détermination du rôle à partir de l'état du rôle, calcul du score

        Parameters
        ----------
        hand_status : dict
L'état du rôle du joueur après l'échange de cartes
        check_hands : list
main du joueur

        Returns
        --------
        hand_result_msg : str
Jugement du rôle
        """

        #résultat
        hand_result_msg = ""

        #Flash et droit
        if hand_status["is_flash"] and hand_status["is_straight"]:
            #La plus petite carte est 10,La plus grande carte est de 14(A)
            if check_hands[0]["number"] == 10 and  \
                    check_hands[4]["number"] == 14:
                hand_result_msg = "quinte flush royale"
                self.player.score = 10000
            else:
                hand_result_msg = "Quinte flush"
                self.player.score = 2000
        #4 cartes
        elif hand_status["same_number"] == 4:
            hand_result_msg = "4 cartes"
            self.player.score = 1000

        #3 cartes,Jugement complet
        elif hand_status["same_number"] == 3:
            #3 cartes et 1 paire
            if hand_status["match_pair_count"] == 1:
                hand_result_msg = "Full house"
                self.player.score = 500
            else:
                hand_result_msg = "3 cartes"
                self.player.score = 250

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

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

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

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

        return hand_result_msg

    def main_game(self):
        """
Jeu principal de poker
        """

        print("Poker Game start")

        #Tirez d'abord 5 cartes
        self.player.draw_card(self.deck, 5)

        #Affichage initial de la carte
        print(f"player's hands：{self.player.hands}")

        #Phase d'échange de cartes
        check_hands = self.change_hands(self.player.hands)

        #Affichage de la carte après échange
        print(f"player's hands：{self.player.hands}")

        #Trier par ordre croissant en fonction du nombre dans votre main
        check_hands_sorted = sorted(check_hands, key=lambda x: x["number"])

        #Calcul des rôles de la main
        hand_results = self.calc_hand(check_hands_sorted)
        print(hand_results)
        #Jugement de rôle
        hand_result_msg = self.showdown_hand(hand_results, check_hands_sorted)

        #Perdre s'il n'y a rien
        if hand_result_msg == "":
            hand_result_msg = "Il n'y avait pas de rôle..."
            self.player.is_poker_win = False

        #Sortie de résultat
        print(hand_result_msg)

Classe DoubleUp

import re
from deck import stock


class DoubleUp:

    RANKS = (*"23456789", "10", *"JQKA")
    VALUES = (range(2, 14 + 1))
    #Associer la marque d'affichage à la partition
    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):
        """
Afficher les cartes une par une et attribuer des numéros

        Parameters
        ----------
        player_hands : list
5 cartes en main

        Returns
        --------
        check_hands : list
main du joueur
        """

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

            #Ajouté au tableau associatif
            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]
            #Ajouter au dictionnaire de vérification
            check_hands.append({
                "mark": card_mark,
                "rank": card_rank,
                "number": card_number
            })
            #Le premier ne peut pas être sélectionné
            if card_idx >= 1:
                #cacher
                # print(f"{card_idx}：*-*")
                print(f"{card_idx}：{card_val}")

        return check_hands

    def win_judge_selected_card(self, input_res, check_hands):
        """
Jugement gagnant du jeu (Comparez la carte sélectionnée avec la carte face visible)

        Parameters
        ----------
        input_res : str
Le numéro entré dans la commande
        check_hands : list
main du joueur
        """

        if re.compile(r'^[1-4]+$').match(input_res) is not None:
            #Comparaison de la taille du numéro de la carte avec le numéro sélectionné et la carte face visible
            if check_hands[int(input_res)]["number"] >= check_hands[0]["number"]:
                #Doublez le score s'il est grand
                print("win!")
                self.player.score *= 2
            else:
                #Si petit,Marquez 0 et recommencez au poker
                print("lose..")
                self.player.score = 0
                self.is_game_win = False
        else:
            print("Est inutile")

    def main_game(self):
        """
Jeu principal double
        """

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

            #Distribuez 5 cartes du deck
            self.player.draw_card(self.deck, 5)

            #1 sur 5 est placé face visible, 4 est face cachée
            print(f"player's hands：{self.player.hands[0]}, *-*, *-*, *-*, *-*")

            #Afficher les cartes une par une et attribuer des numéros
            check_hands = self.add_check_hands(self.player.hands)

            #Choisissez l'une des quatre cartes face cachée qui est plus forte que le nombre sur la carte face recto
            card_select_msg = f"Enter a card number that is stronger than {self.player.hands[0]}："
            card_select_res = input(card_select_msg)

            #Choisissez l'un des numéros 1 à 4
            self.win_judge_selected_card(card_select_res, check_hands)

            print(self.player.score)

mouvement

$ 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 paires

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

Terminez le jeu avec Q, démarrez le jeu sinon: Q

• Tous les fichiers créés cette fois sont postés sur ici.