def prepare_help_cards_to_print(help_cards): while len(help_cards) % 4 != 0: help_cards.append(Card.empty_card()) brochure = help_cards if BROCHURE: brochure = [] while len(help_cards) > 0: brochure.append(help_cards.pop(1)) brochure.append(help_cards.pop(0)) brochure.append(help_cards.pop(-2)) brochure.append(help_cards.pop(-1)) pairs = [ TwoSidedCard(brochure[2 * i], brochure[2 * i + 1]) for i in range(len(brochure) // 2) ] if not BROCHURE: pairs = [ TwoSidedCard(brochure[i], Card.empty_card()) for i in range(len(brochure)) ] cards = [] for page in range(int(ceil(len(pairs) / 4))): for i, help_card in enumerate(pairs[page * 4:page * 4 + 4]): cards.append(help_card) if i in [1, 3]: for _ in range(i + 1): cards.append(TwoSidedCard.empty_card()) return cards
def test_equality(self): x = Card('Spades', 'Ace') y = Card('Diamonds', 'King') z = Card('Spades', 'Ace') self.assertNotEqual(x, y) self.assertEqual(x, z)
def test_straight_flush_to_straight_flush_comparison(self): player = Player("player", ManualActionCollector()) player2 = Player("Player2", ManualActionCollector()) suit = Suit.DIAMONDS suit1 = Suit.CLUBS hand1 = [ Card(Number.THREE, suit1), Card(Number.FOUR, suit1), Card(Number.FIVE, suit1), Card(Number.SIX, suit1), Card(Number.SEVEN, suit1) ] hand2 = [ Card(Number.TWO, suit), Card(Number.THREE, suit), Card(Number.FOUR, suit), Card(Number.FIVE, suit), Card(Number.SIX, suit) ] round_result = RoundResult( [HandResult(hand1, player), HandResult(hand2, player2)]) winning_hand_result = round_result.find_winning_hands()[0] winning_hand = winning_hand_result.cards self.assertTrue(set(hand1).issubset(winning_hand)) self.assertEqual(player, winning_hand_result.player, "Wrong Winning Player")
def test_create_card(self): card = Card(9, 'DIAMONDS') self.assertEqual(9, card.rank) self.assertEqual('DIAMONDS', card.suit) card = Card('JACK', 'SPADES') self.assertEqual('SPADES', card.suit) self.assertEqual(11, card.rank)
def test_is_legit_bad_rank_5_card(self): self.assertFalse( Cards.is_legit_hand([ Card(1, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(5, 'DIAMONDS') ]))
def __init__(self, jokers=False, shuffle=True): self.cards = [] for suit, ranks in suits.items(): if suit != 'Wild': for rank in ranks: self.cards.append(Card(suit, rank)) elif suit == 'Wild' and jokers: self.cards.extend(\ [ Card('Wild', 'Joker') for x in range(jokers)]) self.shuffle()
def is_better(a: Card, b: Card): a.power_resolve() b.power_resolve() # Is card _a_ better than card _b_? if self.resolved_order() == Order.defense: # Lower is better. return a.power < b.power else: # Higher is better. return a.power > b.power
def test_card(self): self.assertEqual( self.cards_db[4], Card(green_cost=3, level=CardLevel.ONE, discount=CoinTypes.GREEN)) self.assertEqual( self.cards_db[12], Card(blue_cost=2, red_cost=2, level=CardLevel.TWO, discount=CoinTypes.RED))
def test_flush_check(self): suit = Suit.DIAMONDS card = Card(Number.ACE, suit) card1 = Card(Number.TWO, suit) card2 = Card(Number.TEN, suit) card3 = Card(Number.KING, suit) card4 = Card(Number.JACK, suit) flush = [card, card1, card2, card3, card4] flush_result = HandResult(flush) self.assertTrue(flush_result.hand_type == HandType.FLUSH, "Expected Flush")
def test_high_card(self): suit = Suit.DIAMONDS suit1 = Suit.CLUBS card = Card(Number.QUEEN, suit) card1 = Card(Number.TEN, suit) card2 = Card(Number.FIVE, suit1) card3 = Card(Number.THREE, suit1) card4 = Card(Number.JACK, suit1) high_card = [card, card1, card2, card3, card4] high_card_result = HandResult(high_card) self.assertTrue(high_card_result.hand_type == HandType.HIGH_CARD, "Expected High Card")
def test_full_house(self): suit = Suit.DIAMONDS suit1 = Suit.CLUBS card = Card(Number.THREE, suit) card1 = Card(Number.TEN, suit) card2 = Card(Number.TEN, suit1) card3 = Card(Number.THREE, suit1) card4 = Card(Number.TEN, Suit.HEARTS) full_house = [card, card1, card2, card3, card4] full_house_result = HandResult(full_house) self.assertTrue(full_house_result.hand_type == HandType.FULL_HOUSE, "Expected Full House")
def test_four_of_a_kind(self): suit = Suit.DIAMONDS suit1 = Suit.CLUBS card = Card(Number.TEN, Suit.SPADES) card1 = Card(Number.TEN, suit) card2 = Card(Number.TEN, suit1) card3 = Card(Number.THREE, suit1) card4 = Card(Number.TEN, Suit.HEARTS) four_of_a_kind = [card, card1, card2, card3, card4] four_of_a_kind_result = HandResult(four_of_a_kind) self.assertTrue(four_of_a_kind_result.hand_type == HandType.QUADS, "Expected Quads")
def test_two_pair(self): suit = Suit.DIAMONDS suit1 = Suit.CLUBS card = Card(Number.QUEEN, suit) card1 = Card(Number.TEN, suit) card2 = Card(Number.QUEEN, suit1) card3 = Card(Number.TEN, suit1) card4 = Card(Number.JACK, suit1) two_pair = [card, card1, card2, card3, card4] two_pair_result = HandResult(two_pair) self.assertTrue(two_pair_result.hand_type == HandType.TWO_PAIR, "Expected Two Pair")
def test_is_legit_card(self): #ranks that don't exist self.assertFalse(Cards.is_legit_card(Card(1, 'DIAMONDS'))) self.assertTrue(Cards.is_legit_card(Card(2, 'DIAMONDS'))) #suits that don't exist #legit self.assertTrue(Cards.is_legit_card(Card(2, 'DIAMONDS'))) for rank in Cards.RANKS: for suit in Cards.SUITS: self.assertTrue(Cards.is_legit_card(Card(rank, suit)))
def test_straight_check_ace_begin(self): suit = Suit.DIAMONDS suit1 = Suit.CLUBS card = Card(Number.FOUR, suit) card1 = Card(Number.TWO, suit1) card2 = Card(Number.THREE, suit) card3 = Card(Number.ACE, suit1) card4 = Card(Number.FIVE, suit) straight = [card, card1, card2, card3, card4] straight_result = HandResult(straight) self.assertTrue(straight_result.hand_type == HandType.STRAIGHT, "Expected Straight")
def test_straight_check_ace_end(self): suit = Suit.DIAMONDS suit1 = Suit.CLUBS card = Card(Number.JACK, suit) card1 = Card(Number.TEN, suit1) card2 = Card(Number.QUEEN, suit) card3 = Card(Number.ACE, suit1) card4 = Card(Number.KING, suit) straight = [card, card1, card2, card3, card4] straight_result = HandResult(straight) self.assertTrue(straight_result.hand_type == HandType.STRAIGHT, "Expected Straight")
def test_straight_flush(self): suit = Suit.DIAMONDS card = Card(Number.JACK, suit) card1 = Card(Number.TEN, suit) card2 = Card(Number.QUEEN, suit) card3 = Card(Number.ACE, suit) card4 = Card(Number.KING, suit) straight_flush = [card, card1, card2, card3, card4] straight_flush_result = HandResult(straight_flush) self.assertTrue( straight_flush_result.hand_type == HandType.STRAIGHT_FLUSH, "Expected Straight Flush")
def test_three_of_a_kind(self): suit = Suit.DIAMONDS suit1 = Suit.CLUBS three_of_a_kind = [ Card(Number.ACE, suit), Card(Number.ACE, suit1), Card(Number.ACE, Suit.SPADES), Card(Number.THREE, suit), Card(Number.TWO, suit1) ] three_of_a_kind_result = HandResult(three_of_a_kind) self.assertTrue(three_of_a_kind_result.hand_type == HandType.TRIPS, "Expected Trips")
def createDecks(self): colors = ["red", "green", "blue", "yellow"] wildCount = 0 wildAmount = 4 while wildCount < wildAmount: self.cards.append(Wild()) self.cards.append(DrawFour()) wildCount += 1 for color in colors: count = 0 while count <= 9: self.cards.append(Card(color, count)) if count == 9: self.cards.append(DrawTwo(color)) self.cards.append(Reverse(color)) self.cards.append(Skip(color)) count += 1 random.shuffle(self.cards) cardCount = 0 while cardCount < self.playerCardCount: for player in self.players: card = self.cards[cardCount] player.addCard(card) self.cards.remove(card) cardCount += 1
def random_cards(self, ranks, suits, count): """for generating random cards of specified ranks or suites; for example you might want an list of random Spades for testing""" result = [] for i in range(count): result.append( Card(np.random.choice(ranks), np.random.choice(suits))) return result
def build(self) -> None: """Generate cards to initialize the deck return: stack of Card object in card.py """ for suit in ["Spades", "Hearts", "Clubs", "Diamonds"]: for value in range(1, 14): self.cards.append(Card(suit, value))
def test_init(self): suit = 'Spades' rank = 'Ace' c = Card(suit, rank) self.assertEqual(c.suit, suit) self.assertEqual(c.rank, rank) self.assertEqual(unicode(c), 'Ace of Spades')
def __init__(self, player_count: int = 3): self.players = self.create_players(player_count) self.player_order = [player.name for player in self.players] self.deck = Deck() self.set_rank() self.draw_cards() self.start_card = Card("Hearts", 3)
def test_is_legit_bad_suit_5_card(self): self.assertFalse( Cards.is_legit_hand([ Card(2, 'DIAMONDs'), Card(3, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(5, 'DIAMONDS') ])) self.assertFalse( Cards.is_legit_hand([ Card(10, 'DIAMONDS'), Card('JACK', 'HEATS'), Card('ACE', 'DIAMONDS'), Card('KING', 'SPADES'), Card('QUEEN', 'DIAMONDS') ]))
def add_card_to_hand( self, card: Card, index: Optional[int] = None, state: HandCardState = HandCardState.VisibleOnlyForPlayer, ) -> None: assert card not in self.hand assert card not in self.hand_states card.on_hand_enter() if index is not None: self.hand.insert(index, card) else: self.hand.append(card) self.hand_states[card] = state assert card in self.hand assert card in self.hand_states
def test_is_royal_flush(self): self.assertFalse( Cards.is_royal_flush([ Card(10, 'HEARTS'), Card('JACK', 'DIAMONDS'), Card('ACE', 'DIAMONDS'), Card('KING', 'DIAMONDS'), Card('QUEEN', 'DIAMONDS') ])) self.assertTrue( Cards.is_royal_flush([ Card(10, 'DIAMONDS'), Card('JACK', 'DIAMONDS'), Card('ACE', 'DIAMONDS'), Card('KING', 'DIAMONDS'), Card('QUEEN', 'DIAMONDS') ]))
def test_contains_two_of_a_kind(self): self.assertFalse( Cards.contains_two_of_a_kind([ Card(10, 'HEARTS'), Card('JACK', 'DIAMONDS'), Card('ACE', 'DIAMONDS'), Card('KING', 'DIAMONDS'), Card('QUEEN', 'HEARTS') ])) self.assertTrue( Cards.contains_two_of_a_kind([ Card(4, 'DIAMONDS'), Card(4, 'CLUBS'), Card(5, 'HEARTS'), Card(5, 'CLUBS'), Card(5, 'SPADES') ]))
def test_is_full_house(self): self.assertFalse( Cards.is_full_house([ Card(4, 'DIAMONDS'), Card(4, 'CLUBS'), Card(5, 'HEARTS'), Card(5, 'CLUBS'), Card(6, 'SPADES') ])) self.assertTrue( Cards.is_full_house([ Card(4, 'DIAMONDS'), Card(4, 'CLUBS'), Card(5, 'HEARTS'), Card(5, 'CLUBS'), Card(5, 'SPADES') ]))
def test_contains_two_pair(self): self.assertFalse( Cards.contains_two_pairs([ Card(4, 'DIAMONDS'), Card(4, 'CLUBS'), Card(5, 'HEARTS'), Card(5, 'CLUBS'), Card(5, 'SPADES') ])) self.assertTrue( Cards.contains_two_pairs([ Card(4, 'DIAMONDS'), Card(4, 'CLUBS'), Card(5, 'HEARTS'), Card(5, 'CLUBS'), Card(8, 'SPADES') ]))
def load_cards(path): csv = CSV.load(path) cards = [] for text_xml, sentence_index, chunk_index in csv: text = Text.from_xml(encode_utf8(text_xml)) card = Card(text, int(sentence_index), int(chunk_index)) cards.append(card) return cards
def test_card_creation(self): a = Card("Spades", 10) self.assertEqual(a.value(), 10) self.assertEqual(a.suit(), "Spades")