def test_deal_next_hand_retain_pila(self):
"""Player retains their pila when a new hand is dealt.
"""
alice = Player("Alice")
bob = Player("Bob")
alice_cards = [Card(7, "oro"), Card(8, "oro")]
player_cards = {}
player_cards[alice] = {"hand": [], "pila": Pila().add(alice_cards)}
player_cards[bob] = {"hand": [], "pila": Pila()}
attributes = {
"current_player": bob,
"dealer": alice,
"deck": Deck(Card),
"last_pickup": alice,
"mesa": [],
"players": [alice, bob],
"player_cards": player_cards
}
ronda = Ronda(**attributes)
alice_pila = ronda._player_cards[alice]["pila"]
alice_pila_cards = alice_pila.get_cards()
self.assertEqual(2, len(alice_pila_cards["oro"]))
self.assertEqual(0, len(alice_pila_cards["copa"]))
self.assertEqual(0, len(alice_pila_cards["espada"]))
self.assertEqual(0, len(alice_pila_cards["basto"]))
def test_is_finished(self):
alice = Player("Alice")
bob = Player("bob")
deck = Deck(Card).deal(40)[0]
player_cards = {
alice: {
"hand": [],
"pila": Pila()
},
bob: {
"hand": [],
"pila": Pila()
},
}
ronda = Ronda(
**{
"current_player": bob,
"dealer": alice,
"deck": deck,
"last_pickup": bob,
"mesa": [],
"players": [alice, bob],
"player_cards": player_cards
})
self.assertTrue(ronda.is_finished)
def test_instantiate(self):
alice = Player("Alice")
bob = Player("bob")
deck = Deck(Card)
player_cards = {
alice: {
"hand": [],
"pila": Pila()
},
bob: {
"hand": [],
"pila": Pila()
},
}
ronda = Ronda(
**{
"current_player": bob,
"dealer": alice,
"deck": deck,
"last_pickup": bob,
"mesa": [],
"players": [alice, bob],
"player_cards": player_cards
})
self.assertTrue(isinstance(ronda, Ronda))
def test_deal_next_hand_retain_escobas(self):
"""Players keep escobas when starting a new round."""
alice = Player("Alice")
bob = Player("Bob")
alice_cards = [Card(7, "oro"), Card(8, "oro")]
player_cards = {}
player_cards[alice] = {
"hand": [],
"pila": Pila().add(alice_cards, True)
}
player_cards[bob] = {"hand": [], "pila": Pila(escobas=4)}
attributes = {
"current_player": bob,
"dealer": alice,
"deck": Deck(Card),
"last_pickup": alice,
"mesa": [],
"players": [alice, bob],
"player_cards": player_cards
}
ronda = Ronda(**attributes)
alice_pila = ronda._player_cards[alice]["pila"]
alice_escobas = alice_pila.get_escobas()
self.assertEqual(1, alice_escobas)
bob_pila = ronda._player_cards[bob]["pila"]
bob_escobas = bob_pila.get_escobas()
self.assertEqual(4, bob_escobas)
def test_pick_up_hand(self):
"""Collects a hand of three cards from the deck (ie. at the start of each round)"""
bob = Player('Bob')
a = Card(3, 'oro')
b = Card(4, 'oro')
c = Card(5, 'oro')
bob.pick_up_hand([a, b, c])
self.assertEqual([a, b, c], bob.current_hand())
def test_start_with_escoba(self):
random.seed(27)
alice = Player("Alice")
bob = Player("Bob")
ronda = Ronda.start([alice, bob], alice)
self.assertFalse(ronda.current_mesa)
alice_pila = ronda._player_cards[alice]["pila"]
self.assertEqual(4, alice_pila.total_cards())
def test_hand_is_done(self):
alice = Player("alice")
bob = Player("Bob")
ronda = Ronda.start([alice, bob], alice)
self.assertFalse(ronda._hand_is_done)
ronda._player_cards[bob]["hand"] = []
self.assertFalse(ronda._hand_is_done)
ronda._player_cards[alice]["hand"] = []
self.assertTrue(ronda._hand_is_done)
def test_play_turn(self):
random.seed(0)
alice = Player("Alice")
bob = Player("Bob")
ronda = Ronda.start([alice, bob], alice)
# bob holds: [(6, "basto"), (8, "basto"), (4, "copa")]
# alice holds: [(1, "oro"), (7, "copa"), (4, "oro")]
# on table: [(10, "espada"), (9, "espada"), (1, "basto"), (6, "oro")]
# bob drops a card
ronda2 = ronda.play_turn(Card(8, "basto"))
self.assertTrue(Card(8, "basto") in ronda._player_cards[bob]["hand"])
self.assertTrue(
Card(8, "basto") not in ronda2._player_cards[bob]["hand"])
def test_place_card_on_mesa(self):
"""Puts down a card on the mesa"""
alice = Player('Alice')
card1 = Card(5, 'oro')
card2 = Card(10, 'basto')
card3 = Card(8, 'espada')
alice.pick_up_hand([card1, card2, card3])
mesa = []
alice.place_card_on_mesa(mesa, (5, 'oro'))
self.assertEqual(card1, mesa[0])
self.assertEqual([card2, card3], alice.current_hand())
alice.place_card_on_mesa(mesa, (8, 'espada'))
self.assertEqual([card1, card3], mesa)
self.assertEqual([card2], alice.current_hand())
def _start_game(self):
"""Wraps the callback function provided by the parent GameApp widget.
Provides the parent with a list of players which it can use to
initiate a new game.
"""
if not self.name_entry.validate():
return
user = Player(self.name_entry.get())
user.set_image(self.avatar_path)
path = join(getcwd(), "quince/assets/avatars")
npc1 = NPC("Roberto", f"{path}/avatar06.png")
npc2 = NPC("Gus", f"{path}/avatar08.png")
npc3 = NPC("Diana", f"{path}/avatar07.png")
game_frame_factory = GameFrameFactory(user, npc1, npc2, npc3)
self.start_game(game_frame_factory)
def test_start(self):
random.seed(0)
alice = Player("Alice")
bob = Player("Bob")
ronda = Ronda.start([alice, bob], alice)
self.assertTrue(isinstance(ronda, Ronda))
# Alice deals, Bob plays first
self.assertEqual(alice, ronda._dealer)
self.assertEqual(bob, ronda.current_player)
# Each player has three cards
for val in ronda._player_cards.values():
self.assertEqual(3, len(val["hand"]))
# The table has four cards
self.assertEqual(4, len(ronda.current_mesa))
def test_holds_card(self):
"""True if the player has the card in their current hand"""
alice = Player('Alice')
a = Card(3, 'oro')
b = Card(4, 'oro')
c = Card(5, 'espada')
alice.pick_up_hand([a, b, c])
self.assertTrue(alice.holds_card((3, 'oro')))
self.assertTrue(alice.holds_card((5, 'espada')))
self.assertFalse(alice.holds_card((10, 'oro')))
self.assertFalse(alice.holds_card((4, 'copa')))
def test_pick_up_registers_escoba(self):
"""Players earn escobas when picking up."""
alice = Player("Alice")
bob = Player("Bob")
player_cards = {}
player_cards[alice] = {"hand": [], "pila": Pila()}
player_cards[bob] = {"hand": [], "pila": Pila()}
rey = Card(10, "oro")
attributes = {
"current_player": bob,
"dealer": alice,
"deck": Deck(Card),
"last_pickup": alice,
"mesa": [rey],
"players": [alice, bob],
"player_cards": player_cards
}
ronda = Ronda(**attributes)
newronda = ronda.play_turn(Card(5, "oro"), [rey])
escobas = newronda._player_cards[bob]["pila"].escobas
self.assertEqual(1, escobas)
def test_name(self):
"""Getter for the player's name"""
alice = Player("Alice")
self.assertEqual("Alice", alice.name)
def test_repr(self):
"""String representation"""
p = Player("Billy")
s = repr(p)
self.assertTrue("Billy" in s)
def test_id(self):
"""Initialize different players with different ids"""
a = Player("Alice")
b = Player("Alice")
self.assertTrue(a.id + 1 == b.id)
def test_pick_up_from_mesa(self):
"""Plays one card from their current hand and picks up
cards from the mesa, adding up to 15, and places them
in their pila. If last card is taken from the mesa,
an escoba is counted.
Modifies the player's currenthand, pila, and the mesa.
"""
alice = Player('Alice')
bob = Player('Bob')
card_alice1 = Card(5, 'oro')
card_alice2 = Card(7, 'basto')
card_alice3 = Card(8, 'espada')
card_bob1 = Card(5, 'espada')
card_bob2 = Card(7, 'copa')
card_bob3 = Card(8, 'oro')
card_mesa1 = Card(4, 'copa')
card_mesa2 = Card(4, 'basto')
card_mesa3 = Card(10, 'oro')
alice.pick_up_hand([card_alice1, card_alice2, card_alice3])
bob.pick_up_hand([card_bob1, card_bob2, card_bob3])
mesa = [card_mesa1, card_mesa2, card_mesa3]
# Alice uses her 7 to pick up two 4s from the table
alice.pick_up_from_mesa(mesa, (7, 'basto'), [(4, 'basto'), (4,'copa')])
self.assertEqual([card_mesa3], mesa)
self.assertEqual([card_alice1, card_alice3], alice.current_hand())
# Next, bob uses his 5 to pick up the 10 from the table and get an escoba
bob.pick_up_from_mesa(mesa, (5, 'espada'), [(10, 'oro')])
self.assertEqual([], mesa)
self.assertEqual(1, bob.pila().get_escobas())
self.assertEqual([card_bob2, card_bob3], bob.current_hand())
def test_name(self):
"""Getter for the player's name"""
alice = Player('Alice')
self.assertEqual('Alice', alice.name())
def test_count_scores(self):
alice = Player("Alice")
bob = Player("Bob")
charlie = Player("Charlie")
alice_cards = [
Card(1, "espada"),
Card(10, "espada"),
Card(4, "oro"),
Card(1, "copa"),
Card(9, "basto"),
Card(2, "copa"),
Card(1, "basto"),
Card(3, "basto"),
Card(8, "copa"),
Card(8, "basto")
]
bob_cards = [
Card(6, "copa"),
Card(9, "espada"),
Card(3, "oro"),
Card(5, "espada"),
Card(7, "basto"),
Card(7, "espada"),
Card(6, "oro"),
Card(3, "espada"),
Card(8, "espada"),
Card(9, "oro"),
Card(8, "oro"),
Card(2, "oro")
]
charlie_cards = [
Card(10, "basto"),
Card(5, "basto"),
Card(4, "basto"),
Card(9, "copa"),
Card(7, "copa"),
Card(5, "oro"),
Card(1, "oro"),
Card(2, "basto"),
Card(4, "copa"),
Card(10, "copa"),
Card(5, "copa"),
Card(4, "espada"),
Card(3, "copa"),
Card(6, "espada"),
Card(2, "espada"),
Card(7, "oro"),
Card(6, "basto"),
Card(10, "oro")
]
ronda = Ronda.start([alice, bob, charlie], alice)
ronda._player_cards[alice]["pila"] = Pila().add(alice_cards)
ronda._player_cards[bob]["pila"] = Pila().add(bob_cards, True)
ronda._player_cards[charlie]["pila"] = Pila().add(charlie_cards)
scores = ronda.calculate_scores()
(most_cards, _) = scores["most_cards"]
self.assertTrue(charlie in most_cards)
self.assertTrue(alice not in most_cards)
self.assertTrue(bob not in most_cards)
(most_oros, _) = scores["most_oros"]
self.assertTrue(bob in most_oros)
self.assertTrue(alice not in most_oros)
self.assertTrue(charlie not in most_oros)
siete_de_velo = scores["7_de_velo"]
self.assertTrue(charlie is siete_de_velo)
setenta = [x.player for x in scores["setenta"]]
self.assertTrue(charlie in setenta)
self.assertTrue(bob in setenta)
self.assertTrue(alice not in setenta)
escobas = scores["escobas"]
self.assertTrue((bob, 1) in escobas)
self.assertEqual(1, len(escobas))
def test_total_score(self):
"""Getter for the player's score"""
alice = Player('Alice')
self.assertEqual(0, alice.total_score())
def test_str(self):
"""String representation"""
p = Player("Annie")
s = str(p)
self.assertTrue("Annie" in s)