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