def setUp(self):
self.cards = CardCollection([
Copper(),
Silver(),
Gold(),
Gold(),
Duchy(),
Estate(),
Estate(),
Copper(),
Duchy()
])
def test_victory_point_value(self):
deck = CardCollection([Gardens()] + [Copper()
for i in xrange(8)]) # 9 cards
self.assertEqual(deck[0].total_victory_point_value(deck), 0)
deck = CardCollection([Gardens()] + [Copper()
for i in xrange(9)]) # 10 cards
self.assertEqual(deck[0].total_victory_point_value(deck), 1)
deck = CardCollection([Gardens()] + [Copper()
for i in xrange(10)]) # 11 cards
self.assertEqual(deck[0].total_victory_point_value(deck), 1)
deck = CardCollection([Gardens()] + [Copper()
for i in xrange(18)]) # 19 cards
self.assertEqual(deck[0].total_victory_point_value(deck), 1)
deck = CardCollection([Gardens()] + [Copper()
for i in xrange(34)]) # 35 cards
self.assertEqual(deck[0].total_victory_point_value(deck), 3)
class TestCardCollection(unittest.TestCase):
def setUp(self):
self.cards = CardCollection([
Copper(),
Silver(),
Gold(),
Gold(),
Duchy(),
Estate(),
Estate(),
Copper(),
Duchy()
])
def test_total_treasure_value(self):
self.assertEqual(self.cards.total_treasure_value(), 10)
def test_add_cards(self):
self.assertEqual(len(self.cards), 9)
self.cards.add_cards(Province())
self.assertEqual(len(self.cards), 10)
self.assertEqual(Province(), self.cards[9])
self.cards.add_cards(Duchy(), Duchy())
self.assertEqual(len(self.cards), 12)
def test_draw_card(self):
self.assertEqual(self.cards.draw_card(), Duchy())
self.assertEqual(self.cards.draw_card(), Copper())
self.assertEqual(self.cards.draw_card(), Estate())
def test_pop_card(self):
self.assertEqual(self.cards.pop_card(7), Copper())
self.assertEqual(self.cards.pop_card(2), Gold())
self.assertEqual(self.cards.pop_card(2), Gold())
def test_in(self):
self.assertTrue(Copper() in self.cards)
self.assertFalse(Copper() in CardCollection(
[Estate(), Estate(), Gold()]))
def test_pop_function(self):
duchies = pop_matching_cards(lambda c: c == Duchy(), self.cards)
self.assertEqual(len(duchies), 2)
self.assertTrue(all([c == Duchy() for c in duchies]))
self.assertEqual(len(self.cards), 7)
self.assertFalse(any([c == Duchy() for c in self.cards]))
class TestCardCollection(unittest.TestCase):
def setUp(self):
self.cards = CardCollection([Copper(), Silver(), Gold(), Gold(), Duchy(), Estate(), Estate(), Copper(), Duchy()])
def test_total_treasure_value(self):
self.assertEqual(self.cards.total_treasure_value(), 10)
def test_add_cards(self):
self.assertEqual(len(self.cards), 9)
self.cards.add_cards(Province())
self.assertEqual(len(self.cards), 10)
self.assertEqual(Province(), self.cards[9])
self.cards.add_cards(Duchy(), Duchy())
self.assertEqual(len(self.cards), 12)
def test_draw_card(self):
self.assertEqual(self.cards.draw_card(), Duchy())
self.assertEqual(self.cards.draw_card(), Copper())
self.assertEqual(self.cards.draw_card(), Estate())
def test_pop_card(self):
self.assertEqual(self.cards.pop_card(7), Copper())
self.assertEqual(self.cards.pop_card(2), Gold())
self.assertEqual(self.cards.pop_card(2), Gold())
def test_in(self):
self.assertTrue(Copper() in self.cards)
self.assertFalse(Copper() in CardCollection([Estate(), Estate(), Gold()]))
def test_pop_function(self):
duchies = pop_matching_cards(lambda c: c == Duchy(), self.cards)
self.assertEqual(len(duchies), 2)
self.assertTrue(all([c == Duchy() for c in duchies]))
self.assertEqual(len(self.cards), 7)
self.assertFalse(any([c == Duchy() for c in self.cards]))
def __init__(self, game, deck):
self.game = game
self.deck = deck
self.discard = CardCollection()
def select_to_return_to_deck(self, cards, num_cards, is_attack, is_own_cards):
selected = CardCollection()
for i in xrange(num_cards):
selected.add_cards(cards.draw_card())
return selected
class BaseBot(object):
def __init__(self, game, deck):
self.game = game
self.deck = deck
self.discard = CardCollection()
def victory_point_count(self):
full_deck = self.turn.hand + self.deck + self.discard
return sum(card.total_victory_point_value(full_deck) for card in full_deck)
def log(self, level, message):
self.game.log(level, message)
def draw_cards(self, count=1):
"""
This is the `safe` way to draw up to `count` cards. If the deck is
truly out of cards and there are no discards to reshuffle, this will
just return less cards than asked for.
"""
if not self.deck:
self.log(logging.DEBUG, "Player {0} Reshuffling".format(self.game.get_turn()))
self.discard.shuffle()
self.deck, self.discard = self.discard, self.deck
cards = []
for i in xrange(count):
try:
cards.append(self.deck.draw_card())
except IndexError:
break
return cards
def discard_cards(self, *cards):
assert all(cards)
self.discard.add_cards(*cards)
def set_turn(self, turn):
self.turn = turn
def do_turn(self):
pass
def cleanup_turn(self):
self.discard_cards(*[c for c in self.turn.hand])
self.discard_cards(*[c for c in self.turn.discard])
def select_for_discard(self, cards, num_cards, is_attack, is_own_cards):
selected = CardCollection()
for i in xrange(num_cards):
selected.add_cards(cards.draw_card())
return selected
def select_to_add_to_deck(self, cards, num_cards):
"""
cards in this method is a list of card classes, not a collection of cards.
"""
selected = []
for i in xrange(num_cards):
selected.append(cards.pop())
return selected
def select_to_return_to_deck(self, cards, num_cards, is_attack, is_own_cards):
selected = CardCollection()
for i in xrange(num_cards):
selected.add_cards(cards.draw_card())
return selected
def setUp(self):
self.cards = CardCollection([Copper(), Silver(), Gold(), Gold(), Duchy(), Estate(), Estate(), Copper(), Duchy()])
def __init__(self, game, deck):
self.game = game
self.deck = deck
self.discard = CardCollection()
def select_to_return_to_deck(self, cards, num_cards, is_attack,
is_own_cards):
selected = CardCollection()
for i in xrange(num_cards):
selected.add_cards(cards.draw_card())
return selected
class BaseBot(object):
def __init__(self, game, deck):
self.game = game
self.deck = deck
self.discard = CardCollection()
def victory_point_count(self):
full_deck = self.turn.hand + self.deck + self.discard
return sum(
card.total_victory_point_value(full_deck) for card in full_deck)
def log(self, level, message):
self.game.log(level, message)
def draw_cards(self, count=1):
"""
This is the `safe` way to draw up to `count` cards. If the deck is
truly out of cards and there are no discards to reshuffle, this will
just return less cards than asked for.
"""
if not self.deck:
self.log(logging.DEBUG,
'Player {0} Reshuffling'.format(self.game.get_turn()))
self.discard.shuffle()
self.deck, self.discard = self.discard, self.deck
cards = []
for i in xrange(count):
try:
cards.append(self.deck.draw_card())
except IndexError:
break
return cards
def discard_cards(self, *cards):
assert all(cards)
self.discard.add_cards(*cards)
def set_turn(self, turn):
self.turn = turn
def do_turn(self):
pass
def cleanup_turn(self):
self.discard_cards(*[c for c in self.turn.hand])
self.discard_cards(*[c for c in self.turn.discard])
def select_for_discard(self, cards, num_cards, is_attack, is_own_cards):
selected = CardCollection()
for i in xrange(num_cards):
selected.add_cards(cards.draw_card())
return selected
def select_to_add_to_deck(self, cards, num_cards):
"""
cards in this method is a list of card classes, not a collection of cards.
"""
selected = []
for i in xrange(num_cards):
selected.append(cards.pop())
return selected
def select_to_return_to_deck(self, cards, num_cards, is_attack,
is_own_cards):
selected = CardCollection()
for i in xrange(num_cards):
selected.add_cards(cards.draw_card())
return selected
def test_in(self):
self.assertTrue(Copper() in self.cards)
self.assertFalse(Copper() in CardCollection(
[Estate(), Estate(), Gold()]))
