21点游戏重组问题编辑

Question

我正在尝试做一个21点游戏，在每一个新的回合之前，程序检查以确保每一个玩家有7张牌。如果没有，甲板就会清理，重新填充，重新洗牌。我已经解决了大部分问题，但出于某种原因，在每次交易开始时，它都会不止一次地重新洗牌，我不知道为什么。请帮帮我。 以下是我目前所掌握的情况： （另外，导入的卡和游戏模块不是问题的一部分，我很确定我的问题出在BJ_Deck类的deal（）函数上。）

import cards, games     

class BJ_Card(cards.Card):
    """ A Blackjack Card. """
    ACE_VALUE = 1

    def get_value(self):
        if self.is_face_up:
            value = BJ_Card.RANKS.index(self.rank) + 1
            if value > 10:
                value = 10
        else:
            value = None
        return value

    value = property(get_value)


class BJ_Deck(cards.Deck):
    """ A Blackjack Deck. """
    def populate(self):
        for suit in BJ_Card.SUITS: 
            for rank in BJ_Card.RANKS: 
                self.cards.append(BJ_Card(rank, suit))

    def deal(self, hands, per_hand=1):
        for rounds in range(per_hand):
            if len(self.cards)>=7*(len(hands)):
                    print "Reshuffling the deck."
                    self.cards=[]
                    self.populate()
                    self.shuffle()
            for hand in hands:
                    top_card=self.cards[0]
                    self.give(top_card, hand)


class BJ_Hand(cards.Hand):
    """ A Blackjack Hand. """
    def __init__(self, name):
        super(BJ_Hand, self).__init__()
        self.name = name

    def __str__(self):
        rep = self.name + ":\t" + super(BJ_Hand, self).__str__()  
        if self.total:
            rep += "(" + str(self.total) + ")"        
        return rep

    def get_total(self):
        # if a card in the hand has value of None, then total is None
        for card in self.cards:
            if not card.value:
                return None

        # add up card values, treat each Ace as 1
        total = 0
        for card in self.cards:
              total += card.value

        # determine if hand contains an Ace
        contains_ace = False
        for card in self.cards:
            if card.value == BJ_Card.ACE_VALUE:
                contains_ace = True

        # if hand contains Ace and total is low enough, treat Ace as 11
        if contains_ace and total <= 11:
            # add only 10 since we've already added 1 for the Ace
            total += 10   

        return total

    total = property(get_total)

    def is_busted(self):
        return self.total > 21


class BJ_Player(BJ_Hand):
    """ A Blackjack Player. """
    def is_hitting(self):
        response = games.ask_yes_no("\n" + self.name + ", do you want a hit? (Y/N): ")
        return response == "y"

    def bust(self):
        print self.name, "busts."
        self.lose()

    def lose(self):
        print self.name, "loses."

    def win(self):
        print self.name, "wins."

    def push(self):
        print self.name, "pushes."


class BJ_Dealer(BJ_Hand):
    """ A Blackjack Dealer. """
    def is_hitting(self):
        return self.total < 17

    def bust(self):
        print self.name, "busts."

    def flip_first_card(self):
        first_card = self.cards[0]
        first_card.flip()


class BJ_Game(object):
    """ A Blackjack Game. """
    def __init__(self, names):      
        self.players = []
        for name in names:
            player = BJ_Player(name)
            self.players.append(player)

        self.dealer = BJ_Dealer("Dealer")

        self.deck = BJ_Deck()
        self.deck.populate()
        self.deck.shuffle()

    def get_still_playing(self):
        remaining = []
        for player in self.players:
            if not player.is_busted():
                remaining.append(player)
        return remaining

    # list of players still playing (not busted) this round
    still_playing = property(get_still_playing)

    def __additional_cards(self, player):
        while not player.is_busted() and player.is_hitting():
            self.deck.deal([player])
            print player
            if player.is_busted():
                player.bust()

    def play(self):
        # deal initial 2 cards to everyone
        self.deck.deal(self.players + [self.dealer], per_hand = 2)
        self.dealer.flip_first_card()    # hide dealer's first card
        for player in self.players:
            print player
        print self.dealer

        # deal additional cards to players
        for player in self.players:
            self.__additional_cards(player)

        self.dealer.flip_first_card()    # reveal dealer's first 

        if not self.still_playing:
            # since all players have busted, just show the dealer's hand
            print self.dealer
        else:
            # deal additional cards to dealer
            print self.dealer
            self.__additional_cards(self.dealer)

            if self.dealer.is_busted():
                # everyone still playing wins
                for player in self.still_playing:
                    player.win()                    
            else:
                # compare each player still playing to dealer
                for player in self.still_playing:
                    if player.total > self.dealer.total:
                        player.win()
                    elif player.total < self.dealer.total:
                        player.lose()
                    else:
                        player.push()

        # remove everyone's cards
        for player in self.players:
            player.clear()
        self.dealer.clear()


def main():
    print "\t\tWelcome to Blackjack!\n"

    names = []
    number = games.ask_number("How many players? (1 - 7): ", low = 1, high = 8)
    for i in range(number):
        name = raw_input("Enter player name: ")
        names.append(name)
    print

    game = BJ_Game(names)

    again = None
    while again != "n":
        game.play()
        again = games.ask_yes_no("\nDo you want to play again?: ")


main()
raw_input("\n\nPress the enter key to exit.")

既然有人决定称之为“心理调试”，那么我就告诉你模块是什么。 这是卡片模块：

^{pr2}$

类手（对象）： “一手扑克牌。” definit（自身）： 自我卡=[]

def __str__(self):
    if self.cards:
       rep = ""
       for card in self.cards:
           rep += str(card) + "\t"
    else:
        rep = "<empty>"
    return rep

def clear(self):
    self.cards = []

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

def give(self, card, other_hand):
    self.cards.remove(card)
    other_hand.add(card)

舱面（手）： “一副扑克牌。” 定义填充（自身）： 适合穿西装卡片。套装: 对于排名卡片.等级: 自我添加（牌（军衔、套装）

def shuffle(self):
    import random
    random.shuffle(self.cards)

def deal(self, hands, per_hand = 1):
    for rounds in range(per_hand):
        for hand in hands:
            if self.cards:
                top_card = self.cards[0]
                self.give(top_card, hand)
            else:
                print "Can't continue deal. Out of cards!"

如果名称==“main”： print“这是一个有扑克牌类的模块。” 原始输入（“\n\n按enter键退出。”）

游戏模块如下：

class Player(object):
""" A player for a game. """
def __init__(self, name, score = 0):
    self.name = name
    self.score = score

def __str__(self):
    rep = self.name + ":\t" + str(self.score)
    return rep

def ask_yes_no（问题）： “”“问一个是或不是问题。”“” 响应=无 响应不在（“y”，“n”）： 响应=原始输入（问题）。下限（） 返回响应

def ask_编号（问题，低，高）： “”“要求一个范围内的数字。”“” 响应=无 响应不在范围内（低，高）： 回答=int（原始输入（问题）） 返回响应

如果名称==“main”： print“您直接运行了这个模块（但没有‘导入’。” 原始输入（“\n\n按enter键退出。”）

Answer 1

你在循环中反复检查它，当你分发卡片时，我想牌堆正在减少（我看不到你的代码上的Deck.give方法来确定）。在

您可能只想检查一次，将检查移到循环之外。在

def deal(self, hands, per_hand=1):
    for rounds in range(per_hand):
        if len(self.cards) <= 7 * len(hands):
            print "Reshuffling the deck."
            self.cards = []
            self.populate()
            self.shuffle()
        for hand in hands:
            top_card=self.cards[0]
            self.give(top_card, hand)

Answer 2

for hand in hands:

你真的想对每只手都运行这个逻辑吗？在

Answer 3

Nosklo指出了一个问题（在循环内部检查），但是还有第二个问题。在

条件

if len(self.cards)>=7*(len(hands)):

正在检查牌的数量是否大于所需数量，如果是，则清除牌堆，填充和洗牌。在

当与循环内的检查相结合时，它将在每次开始下一轮时重新填充和洗牌。在

所以你可能想要这样的东西：

^{pr2}$