def create_deck_of_cards(self) -> [Card]:
deck = []
for i in range(0, self.number_of_card_colors):
for value in card_values.keys():
card = Card(value=value, color=i)
deck.append(card)
return deck
def test_faceUp_all_cards(self):
name = 'Jun'
balance = 200
player = Player(name, balance)
card1 = Card('Heart', 1, False, 1)
card2 = Card('Spade', 5, False, 5)
player.add_hand(card1)
player.add_hand(card2)
expected_hand = [['FaceDown'], ['FaceDown']]
self.assertEqual(player.show_hand(), expected_hand)
player.faceUp_all_cards()
expected_hand = [['Heart', 1], ['Spade', 5]]
self.assertEqual(player.show_hand(), expected_hand)
def __init__(self, monster=None, target=Target.UneCibleAuChoix()):
if not monster:
from Card import Card
monster = Card('Mouton', 1, 1)
self.monster = monster
self.level = 1
self.monster.parent = self
self.parent = None
self.target = target
def __init__(self):
self.cards = []
for value in [
"02", "03", "04", "05", "06", "07", "08", "09", "10", "11",
"12", "13", "01"
]:
for suit in ["s", "h", "d", "c"]:
newcard = Card(value, suit)
self.cards.append(newcard)
def list_cards(self):
if self._cards:
return self._cards
else:
self._cards = []
for card_json in self._cards_json:
self._cards.append(Card(card_json))
return self._cards
def new_stack(self):
cards = []
for _ in range(8):
for i in range(1, 14):
for j in range(1, 5):
card = Card(i, j)
cards.append(card)
random.shuffle(cards)
return cards
def get_cards(self, nb_players=4):
cards = [
Card(level, price, prestige, bonus)
for level, price, prestige, bonus in game.get_cards()
]
l1 = [c for c in cards if c.level == 0]
l2 = [c for c in cards if c.level == 1]
l3 = [c for c in cards if c.level == 2]
return l1, l2, l3
def load_cards(self):
with open('cards.json', 'r') as cards:
card_dict = json.load(cards)
for c in card_dict:
props = c.values()
self.cards.append(Card(*props))
pass
def expose_my_cards(self,yourcards):
expose_card=[]
for card in self.my_hand_cards:
if card==Card("AH"):
expose_card.append(card.toString())
message = "Expose Cards:{}".format(expose_card)
system_log.show_message(message)
system_log.save_logs(message)
return expose_card
def checkForStraightFlush(self):
highestCard = self.determineHighestCard()
if highestCard.CARD < 6:
return False
for i in range(highestCard.CARD, highestCard.CARD - 5, -1):
card = Card(highestCard.SUITE, i)
if not self.containsCard(card):
return False
return True
def split(self):
"""If player successfully split the hand, Create another player called splitPlayer"""
if not self.playing:
print("Bet for new round first. [split called]")
return False
card = self.player.splitHand()
if card is not None: # if split is legal
self.splitPlayer = BJSplit(self.player.betAmt, card)
self.splitting = True
c1 = Card(self.dealer.draw())
c2 = Card(self.dealer.draw())
self.splitPlayer.addCard(c1)
self.player.addCard(c2)
return True
return False
def create_deck(self):
self.deck = []
for card in get_cards():
self.deck += [
Card(question=card.question) for i in range(card.lives)
]
self.message.set('Shuffling cards')
shuffle(self.deck)
def fill(self):
suits = ["Hearts", "Diamonds", "Clubs", "Spades"]
ranks = [9, 10, 11, 12, 13, 14]
for rank in ranks:
for suit in suits:
if rank == 9:
self.deck.append(Bower(rank, suit))
else:
self.deck.append(Card(rank, suit))
def refillDeck(self):
'''
As per problem statement, value of a card is defined as the
multiple of their suite and rank values.
'''
self._cards.clear()
for suite in list(Suite):
for rank in list(Rank):
self._cards.append(Card(suite, rank))
def __init__(self):
"""post: Creates a 52 card deck in standard order"""
cards = []
for suit in Card.SUITS:
for rank in Card.RANKS:
cards.append(Card(rank, suit))
self.cards = cards
self.L = len(self.cards)
def __init__(self, is_pinochle=False):
self.deck = []
self.is_pinochle = is_pinochle # we need to know if we're using a pinochle deck for later ordering
# A pinochle deck may be formed by combining two normal decks of cards and removing cards 2-8, for a total of 48 cards.
# In addition, pinochle uses unconventional card ordering, namely (from lowest to highest): 9, Jack, Queen, King, 10, Ace.
if is_pinochle:
ordered_values = [x for x in list(Card.Values) if x.value not in range(2, 8 + 1)]
ordered_values.sort(key=Deck.cmp_to_key(Deck.pinochle_order_comparison))
for suit in Card.Suits:
for value in ordered_values:
self.deck.append(Card(suit=suit, value=value))
self.deck.append(Card(suit=suit, value=value))
else: # classic 52-card deck
for suit in Card.Suits:
for value in Card.Values:
self.deck.append(Card(suit=suit, value=value))
def remove_card(self):
card = self.shuffled_cards[self.cards_dealt]
self.cards_dealt += 1
row = int(card / 4)
col = card % 4
self.deck[row][col] = 1
return Card(row + 2, Deck.NUM_TO_SUIT[col])
def __init__(self):
self.cards = []
with open('/usr/SuecaPY/src/deck.json') as json_file:
data = json.load(json_file)
buffer = data['buffer']
for p in data['deck']:
suit = p['suit']
value = p['number']
self.cards.append(Card(suit, value, buffer))
def __init__(self):
self.deck = []
suits = ["Spades", "Clubs", "Hearts", "Diamonds"]
values = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
# Creates all 52 combinations of cards for deck
for suit in suits:
for rank in values:
self.deck.append(Card(suit, rank))
def createDeck(self):
for i in range(1, 5):
for x in range(1, 14):
if x > 10:
face_card = Card.getFaceCard(x)
else:
face_card = None
self.deck.append(Card(x, Card.getSuite(i), face_card))
self.shuffleDeck()
def register(self):
name = input("请输入姓名：")
phone_num = input("请输入电话：")
pwd = self.get_pwd()
usr_id = self.get_id()
card = Card(usr_id, pwd, 10)
person = Person(name, usr_id, phone_num, card)
self.usr_dict[usr_id] = person #注意可以等于一个类!!!!!!!!
print("恭喜您开卡成功！姓名：%s，卡号：%s, 余额%s" % (name, usr_id, card.count))
def __init__(self, level=1, monster=None):
if not monster:
from Card import Card
monster = Card('Mouton', 1, 1)
self.monster = monster
self.level = level
self.parent = None
self.has_target = False
self.target = None
def __init__(self):
self.deck = []
shapes = {1: "Diamond", 2: "Spade", 3: "Heart", 4: "Club"}
while len(self.deck) < 52:
new_card = Card(randint(1, 13), shapes[randint(1, 4)])
if new_card not in self.deck:
self.deck.append(new_card)
else:
continue
def compute_sequences(hand):
sequences = []
for suit in {card.suit for card in hand.cards}:
temp = sorted([card.rank for card in hand.cards if card.suit == suit])
for group in consecutive_groups(temp):
sequence = [Card(rank, suit) for rank in list(group)]
if len(sequence) >= 4:
sequences.append(sequence)
return sequences
def __init__(self): """Gera deck de cartas """ if not(self.is_empty()): self.delete_deck() for suit in SUITS: for rank in RANKS: self.cards.append(Card(suit, rank))
def main():
# create the townCrier Card
# cost = 1 and name = 'Town Crier'
townCrier = Minion(1, 'TownCrier', 1, 2)
redbandWasp = Minion(2, 'Redband Wasp', 1, 3)
warpath = Card(2, 'Warpath')
townCrier.printMinionInfo()
redbandWasp.printMinionInfo()
def __init__(self, suits, ranks):
self.cards = []
self.suits = suits
self.ranks = ranks
for i in suits:
for j in ranks:
self.cards.append(Card(i, j))
def test_not_straight(self):
hand = Hand([
Card('2', '♦'),
Card('8', '♦'),
Card('4', '♦'),
Card('5', '♦'),
Card('A', '♠')
])
self.assertFalse(hand.has_straight())
hand = Hand([
Card('A', '♠'),
Card('8', '♦'),
Card('4', '♦'),
Card('5', '♦'),
Card('A', '♠')
])
self.assertFalse(hand.has_straight())
def test_06(self):
# Set up
presetCards = [Card(3, 8), Card(2, 5), Card(2, 8),
Card(3, 9), Card(0, 8)]
deck = Deck(presetCards=presetCards)
player = Player()
dealer = Dealer()
# run
player.SaveACard(deck.DealACard())
dealer.SaveACard(deck.DealACard())
player.SaveACard(deck.DealACard())
dealer.SaveACard(deck.DealACard())
dealer.SaveACard(deck.DealACard())
# check
self.assertEqual(player.totalPoints, 16)
self.assertEqual(dealer.totalPoints, 22)
self.assertTrue(dealer.burst)
def build_deck(self):
for family in card_families:
for card in suite:
face_img_path = f'{face_card_img_folder}{card}_of_{family}.png'
card = Card(suite[card], face_img_path, card_back_img)
card.create_card_images()
self.deck.append(card)
self.shuffle_deck(52)
self.shuffle_deck(52)
