二十一點遊戲轉換問題編輯

Question

我想在每次新一輪之前製作一個二十一點遊戲，程序檢查以確保每個玩家有7張牌。如果沒有，甲板會清除，重新填充和重新洗牌。我遇到的大部分問題都沒有解決，但由於某種原因，在每筆交易開始時，它不止一次地重新洗牌，我無法弄清楚原因。請幫助。 這是我到目前爲止有： （PS進口卡和遊戲模塊不是問題的一部分，我確信我的問題在於我BJ_Deck類的交易（）函數。）

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.") 

由於有人決定稱之爲「心理調試」，我會繼續告訴你模塊是什麼。 這裏的卡模塊：

class Card(object): 
""" A playing card. """ 
RANKS = ["A", "2", "3", "4", "5", "6", "7", 
     "8", "9", "10", "J", "Q", "K"] 
SUITS = ["c", "d", "h", "s"] 

def __init__(self, rank, suit, face_up = True): 
    self.rank = rank 
    self.suit = suit 
    self.is_face_up = face_up 

def __str__(self): 
    if self.is_face_up: 
     rep = self.rank + self.suit 
    else: 
     rep = "XX" 
    return rep 

def flip(self): 
    self.is_face_up = not self.is_face_up 

類手（對象）： 「」 「的撲克牌一隻手 」「」 DEF 初始化（個體）： self.cards = []

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) 

類甲板（手）： 「」 「的一副撲克牌。 」「」 高清填充（個體經營）：用於西裝 在Card.SUITS：對於排名在Card.RANKS ： self.add（卡（等級，花色））

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!" 

如果名 == 「主要」： 打印 「這是班打牌的模塊。」 的raw_input（ 「\ n \ n按回車鍵退出」）

而這裏的遊戲模塊：

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 

高清ask_yes_no（問題）： 「」「問一個yes或no的問題。 「」」 響應=無 而響應不是（ 「Y」， 「N」）： 響應的raw_input =（問題）.lower（） 返回響應

DEF ask_number（問題，低，高）： 「」「在跑步中詢問一個號碼GE 「」 「 響應=無 而響應不在範圍內（低，高）： 響應= INT（的raw_input（問題）） 返回響應

如果名稱 ==」。主「： print「你直接運行這個模塊（並沒有'導入'）。」 raw_input（「\ n \ n按回車鍵退出。」）

Answer 1

Nosklo指出了一個問題（在循環中檢查它），但還有第二個問題。

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

被檢查是否卡的數量大於所需要的數目，並且如果這樣的條件下，將清除甲板，填充和混洗。

當與循環內部的檢查相結合時，它會在每次開始新一輪時重新填充和洗牌甲板。

所以你可能會是這樣的：

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

Answer 2

你一遍又一遍地檢查它，在循環中，當你分發卡片時，卡組正在縮小，我想（可以在您的代碼中看不到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 3

for hand in hands:

你真的要運行每手是什麼邏輯？