Exemple #1
0
    def test_run_game(self):
        dealer = Dealer.new([Player(1), Player(2)])
        dealer.hand = []
        expected_dealer1 = copy.deepcopy(dealer)

        dealer.runGame()

        self.assertEquals(dealer, expected_dealer1)

        dealer.hand = [TraitCard(AMBUSH, -1), TraitCard(AMBUSH), TraitCard(AMBUSH, 1), TraitCard(BURROWING),
                       TraitCard(BURROWING, 3), TraitCard(CARNIVORE, -1), TraitCard(CLIMBING), TraitCard(CLIMBING, 2),
                       TraitCard(CLIMBING, 3), TraitCard(WARNING_CALL)]

        expected_player1_species = [Species(0, 0, 2, [TraitCard(AMBUSH, 1)])]
        expected_player2_species = [Species(0, 0, 1, [TraitCard(CLIMBING)])]
        expected_player1 = PlayerState(1, 2, expected_player1_species,
                                       [], Player(1))
        expected_player2 = PlayerState(2, 1, expected_player2_species,
                                       [TraitCard(CLIMBING, 3), TraitCard(WARNING_CALL)], Player(2))
        self.assertEquals(dealer.wateringHole, 0)
        dealer.runGame()
        self.assertEquals(dealer.playerStates[0].trait_cards, [TraitCard(CLIMBING, 3), TraitCard(WARNING_CALL)])
        self.assertEquals(dealer.playerStates[1].trait_cards, [])

        self.assertEquals(dealer.hand, [])
        self.assertEquals(dealer.playerStates[1].species[0].trait_cards, expected_player1_species[0].trait_cards)
        self.assertEquals(dealer.playerStates[0].species[0], expected_player2_species[0])
        self.assertEquals(dealer.wateringHole, 0)
        self.assertEquals(dealer.playerStates[1].foodbag, 2)
        self.assertEquals(dealer.playerStates[0].foodbag, 1)

        self.assertEquals(dealer.playerStates[1].species, expected_player1.species)
        self.assertEquals(dealer.playerStates[0].species, expected_player2.species)
        self.assertEquals(dealer.playerStates[1].trait_cards, expected_player1.trait_cards)
        self.assertEquals(dealer.playerStates[0].trait_cards, expected_player2.trait_cards)

        self.assertEquals(dealer.playerStates[1], expected_player1)

        self.assertEquals(dealer.playerStates, [expected_player2, expected_player1])

        exp_dealer2 = Dealer([expected_player2, expected_player1], 0, [])
        self.assertEquals(dealer, exp_dealer2)

        dealer3 = Dealer.new([Player(1), Player(1), Player(1), Player(1), Player(1), Player(1), Player(1), Player(1)])
        dealer3.runGame()
        dealer4 = Dealer.new([Player(1), Player(1), Player(1), Player(1)])
        dealer4.runGame()
Exemple #2
0
    def test_new(self):
        players = [Player(i) for i in range(1, 5)]

        dealer = Dealer.new(players)

        self.assertEquals(len(dealer.hand), 122)
        self.assertEquals(dealer.wateringHole, 0)
        self.assertEquals(len(dealer.playerStates), 4)
Exemple #3
0
 def test_cycle_players(self):
     dealer = Dealer.new([Player(1), Player(2), Player(3), Player(4), Player(5), Player(6), Player(7), Player(8)])
     dealer.cycle_players()
     self.assertEquals(dealer.playerStates[0].id, 2)
     self.assertEquals(dealer.playerStates[1].id, 3)
     self.assertEquals(dealer.playerStates[2].id, 4)
     self.assertEquals(dealer.playerStates[3].id, 5)
     self.assertEquals(dealer.playerStates[4].id, 6)
     self.assertEquals(dealer.playerStates[5].id, 7)
     self.assertEquals(dealer.playerStates[6].id, 8)
     self.assertEquals(dealer.playerStates[7].id, 1)
Exemple #4
0
 def test_turn(self):
     dealer = Dealer.new([Player(1), Player(2), Player(3)])
     result_dealer = copy.deepcopy(dealer)
     result_dealer.hand = result_dealer.hand[24:]
     result_dealer.playerStates[0] = PlayerState(1, 0, [], [TraitCard(BURROWING, 2), TraitCard(BURROWING, 3),
                                                            TraitCard(CARNIVORE, -8), TraitCard(CARNIVORE, -7)])
     result_dealer.playerStates[1] = PlayerState(2, 0, [], [TraitCard(CARNIVORE, -6), TraitCard(CARNIVORE, -5),
                                                            TraitCard(CARNIVORE, -4), TraitCard(CARNIVORE, -3)])
     result_dealer.playerStates[2] = PlayerState(3, 0, [], [TraitCard(CARNIVORE, -2), TraitCard(CARNIVORE, -1),
                                                            TraitCard(CARNIVORE, 0), TraitCard(CARNIVORE, 1)])
     dealer.turn()
     self.assertEquals(dealer, result_dealer)
Exemple #5
0
    def test_is_game_over(self):
        traits = [TraitCard(CARNIVORE), TraitCard(AMBUSH), TraitCard(WARNING_CALL), TraitCard(LONG_NECK),
                  TraitCard(CARNIVORE), TraitCard(AMBUSH), TraitCard(WARNING_CALL), TraitCard(LONG_NECK)]
        enough_traits = [TraitCard(CARNIVORE), TraitCard(AMBUSH), TraitCard(WARNING_CALL), TraitCard(LONG_NECK),
                         TraitCard(CARNIVORE), TraitCard(AMBUSH), TraitCard(WARNING_CALL), TraitCard(LONG_NECK),
                         TraitCard(CARNIVORE), TraitCard(AMBUSH), TraitCard(FERTILE), TraitCard(FERTILE, 3)]

        dealer = Dealer.new([Player(1), Player(2), Player(3)])

        dealer.hand = traits
        self.assertTrue(dealer.is_game_over())

        dealer.hand = enough_traits
        self.assertFalse(dealer.is_game_over())