Esempio n. 1
0
    def test9(self):
        spiel = Spiel_class.Spiel(Kartenliste)
        player1 = Player(1)
        player2 = Player(2)

        k1 = Card('W', 'W', 'S', 'S')
        pos1 = spiel.calculate_possible_actions(k1, player1)

        self.assertEqual(len(pos1), 24)
        spiel.make_action(player1, k1, 0, 1, 3)

        k2 = Card('S', 'O', 'S', 'W')
        pos2 = spiel.calculate_possible_actions(k2, player2)

        self.assertEqual(len(pos2), 40)
        wiese = [w for w in k2.wiesen if w.ecken == [5, 6]][0]

        spiel.make_action(player1, k2, 1, 1, 1, wiese)

        k3 = Card('O', 'O', 'S', 'O', 'O', True)
        pos3 = spiel.calculate_possible_actions(k3, player1)

        self.assertEqual(len(pos3), 18)
Esempio n. 2
0
    def test3(self):

        spiel = Spiel_class.Spiel(Kartenliste)
        player1 = Player(1)
        player2 = Player(2)

        k1 = Card('O', 'O', 'S', 'O', 'O', True)
        spiel.make_action(player2, k1, 1, 0, 0, k1.orte[0])

        k2 = Card('O', 'W', 'W', 'O', 'O')
        spiel.make_action(player1, k2, 1, 1, 2, k2.wiesen[0])

        k3 = Card('W', 'W', 'W', 'W', 'K')
        pos = spiel.calculate_possible_actions(k3, player2)

        #display_spielbrett_dict(spiel.cards_set)

        goal = [(-1, 0, 0, k3.wiesen[0]), (-1, 0, 0, None), (-1, 0, 0, 'k'),
                (1, 2, 0, None), (1, 2, 0, 'k')]

        self.assertEqual(len(pos), len(goal))
        for tup in pos:
            self.assertTrue(tup in goal)
Esempio n. 3
0
    def test7(self):
        spiel = Spiel_class.Spiel(Kartenliste)
        player1 = Player(1)
        player2 = Player(2)

        k1 = Card('S', 'W', 'S', 'W')
        pos1 = spiel.calculate_possible_actions(k1, player1)

        self.assertEqual(len(pos1), 12)
        spiel.make_action(player1, k1, 0, 1, 0, k1.strassen[0])

        k2 = Card('O', 'W', 'W', 'O', 'O')
        pos2 = spiel.calculate_possible_actions(k2, player2)

        self.assertEqual(len(pos2), 24)
        spiel.make_action(player2, k2, 1, 0, 0, k2.orte[0])

        #display_spielbrett_dict(spiel.cards_set)

        k3 = Card('W', 'W', 'S', 'S')
        pos3 = spiel.calculate_possible_actions(k3, player1)

        self.assertEqual(len(pos3), 44)
        spiel.make_action(player1, k3, 0, 2, 3)

        k4 = Card('O', 'S', 'S', 'W')
        pos4 = spiel.calculate_possible_actions(k4, player2)

        self.assertEqual(len(pos4), 46)
        spiel.make_action(player2, k4, 1, 2, 2)

        k4 = Card('W', 'O', 'W', 'O')
        pos5 = spiel.calculate_possible_actions(k4, player1)

        #display_spielbrett_dict(spiel.cards_set)

        self.assertEqual(len(pos5), 31)
Esempio n. 4
0
    def test8(self):
        """fast der gleiche wie test7, nur mit meeple mehr in vorletzem Zug"""
        spiel = Spiel_class.Spiel(Kartenliste)
        player1 = Player(1)
        player2 = Player(2)

        k1 = Card('S', 'W', 'S', 'W')
        pos1 = spiel.calculate_possible_actions(k1, player1)

        self.assertEqual(len(pos1), 12)
        spiel.make_action(player1, k1, 0, 1, 0, k1.strassen[0])

        k2 = Card('O', 'W', 'W', 'O', 'O')
        pos2 = spiel.calculate_possible_actions(k2, player2)

        self.assertEqual(len(pos2), 24)
        spiel.make_action(player2, k2, 1, 0, 0, k2.orte[0])

        #display_spielbrett_dict(spiel.cards_set)

        k3 = Card('W', 'W', 'S', 'S')
        pos3 = spiel.calculate_possible_actions(k3, player1)

        self.assertEqual(len(pos3), 44)
        spiel.make_action(player1, k3, 0, 2, 3)

        k4 = Card('O', 'S', 'S', 'W')
        pos4 = spiel.calculate_possible_actions(k4, player2)

        self.assertEqual(len(pos4), 46)
        spiel.make_action(player2, k4, 1, 2, 2, k4.orte[0])

        k5 = Card('W', 'O', 'W', 'O')
        pos5 = spiel.calculate_possible_actions(k5, player1)

        self.assertEqual(len(pos5), 30)
Esempio n. 5
0
    def test3(self):
        spiel = Spiel_class.Spiel(Kartenliste)
        player1 = Player_Class.Player(1)
        player2 = Player_Class.Player(2)

        k1 = Card('O', 'W', 'W', 'W')
        spiel.make_action(player1, k1, 1, 0, 3, k1.orte[0])

        self.assertEqual(len(spiel.cards_set), 2)
        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 1)
        self.assertEqual(len(spiel.alle_wiesen), 3)
        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 7)
        self.assertEqual(player2.meeples, 7)
        self.assertEqual(player1.punkte, 4)
        self.assertEqual(player2.punkte, 0)

        k2 = Card('W', 'W', 'S', 'S')
        spiel.make_action(player2, k2, 0, 1, 0, k2.strassen[0])

        self.assertEqual(len(spiel.cards_set), 3)

        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 1)
        self.assertEqual(len(spiel.alle_wiesen), 3)
        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 7)
        self.assertEqual(player2.meeples, 6)
        self.assertEqual(player1.punkte, 4)
        self.assertEqual(player2.punkte, 0)

        k3 = Card('O', 'S', 'S', 'O', 'O', True)
        spiel.make_action(player1, k3, 0, -1, 3, k3.orte[0])

        self.assertEqual(len(spiel.cards_set), 4)

        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 2)
        self.assertEqual(len(spiel.alle_wiesen), 3)
        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 6)
        self.assertEqual(player2.meeples, 6)
        self.assertEqual(player1.punkte, 4)
        self.assertEqual(player2.punkte, 0)

        k4 = Card('O', 'O', 'S', 'O', 'O', True)
        spiel.make_action(player2, k4, -1, 1, 3, k4.orte[0])

        self.assertEqual(len(spiel.cards_set), 5)

        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 3)
        self.assertEqual(len(spiel.alle_wiesen), 3)
        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 6)
        self.assertEqual(player2.meeples, 5)
        self.assertEqual(player1.punkte, 4)
        self.assertEqual(player2.punkte, 0)

        k5 = Card('W', 'O', 'O', 'W')
        ort1 = None
        for o in k5.orte:
            if o.kanten == [1]:
                ort1 = o
        spiel.make_action(player1, k5, -1, -1, 0, ort1)

        self.assertEqual(len(spiel.cards_set), 6)

        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 4)
        self.assertEqual(len(spiel.alle_wiesen), 4)
        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 5)
        self.assertEqual(player2.meeples, 5)
        self.assertEqual(player1.punkte, 4)
        self.assertEqual(player2.punkte, 0)

        k6 = Card('S', 'W', 'S', 'W')
        spiel.make_action(player2, k6, 1, -1, 3)

        self.assertEqual(len(spiel.cards_set), 7)

        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 4)
        self.assertEqual(len(spiel.alle_wiesen), 3)
        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 5)
        self.assertEqual(player2.meeples, 5)
        self.assertEqual(player1.punkte, 4)
        self.assertEqual(player2.punkte, 0)

        #display_spielbrett_dict(spiel.cards_set)

        k7 = Card('W', 'S', 'S', 'S', 'G')
        strasse1 = None
        for s in k7.strassen:
            if s.kanten == [3]:
                strasse1 = s
        spiel.make_action(player1, k7, 2, 0, 3, strasse1)

        self.assertEqual(len(spiel.cards_set), 8)

        self.assertEqual(len(spiel.alle_strassen), 4)
        self.assertEqual(len(spiel.alle_orte), 4)
        self.assertEqual(len(spiel.alle_wiesen), 5)
        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 4)
        self.assertEqual(player2.meeples, 5)
        self.assertEqual(player1.punkte, 4)
        self.assertEqual(player2.punkte, 0)

        k8 = Card('O', 'S', 'S', 'W')
        spiel.make_action(player2, k8, -1, 2, 2)

        self.assertEqual(len(spiel.cards_set), 9)

        self.assertEqual(len(spiel.alle_strassen), 5)
        self.assertEqual(len(spiel.alle_orte), 4)
        self.assertEqual(len(spiel.alle_wiesen), 7)
        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 4)
        self.assertEqual(player2.meeples, 5)
        self.assertEqual(player1.punkte, 4)
        self.assertEqual(player2.punkte, 0)

        k9 = Card('W', 'S', 'S', 'S', 'G')
        strasse2 = None
        for s in k9.strassen:
            if s.kanten == [1]:
                strasse2 = s
        spiel.make_action(player1, k9, -2, 2, 0, strasse2)

        self.assertEqual(len(spiel.cards_set), 10)

        self.assertEqual(len(spiel.alle_strassen), 7)
        self.assertEqual(len(spiel.alle_orte), 4)
        self.assertEqual(len(spiel.alle_wiesen), 8)
        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 3)
        self.assertEqual(player2.meeples, 5)
        self.assertEqual(player1.punkte, 4)
        self.assertEqual(player2.punkte, 0)

        k10 = Card('W', 'W', 'W', 'W', 'K')
        spiel.make_action(player2, k10, 1, 1, 2, 'k')

        self.assertEqual(len(spiel.cards_set), 11)

        self.assertEqual(len(spiel.alle_strassen), 7)
        self.assertEqual(len(spiel.alle_orte), 4)
        self.assertEqual(len(spiel.alle_wiesen), 8)
        self.assertEqual(len(spiel.alle_kloester), 1)

        self.assertEqual(player1.meeples, 3)
        self.assertEqual(player2.meeples, 4)
        self.assertEqual(player1.punkte, 4)
        self.assertEqual(player2.punkte, 0)

        k11 = Card('W', 'O', 'W', 'O', 'O', True)
        spiel.make_action(player1, k11, -2, 3, 0)

        self.assertEqual(len(spiel.cards_set), 12)

        self.assertEqual(len(spiel.alle_strassen), 7)
        self.assertEqual(len(spiel.alle_orte), 5)
        self.assertEqual(len(spiel.alle_wiesen), 9)
        self.assertEqual(len(spiel.alle_kloester), 1)

        self.assertEqual(player1.meeples, 3)
        self.assertEqual(player2.meeples, 4)
        self.assertEqual(player1.punkte, 4)
        self.assertEqual(player2.punkte, 0)

        k12 = Card('O', 'W', 'W', 'O', 'O')
        spiel.make_action(player2, k12, -1, 0, 0)

        self.assertEqual(len(spiel.cards_set), 13)

        self.assertEqual(len(spiel.alle_strassen), 7)
        self.assertEqual(len(spiel.alle_orte), 5)
        self.assertEqual(len(spiel.alle_wiesen), 8)
        self.assertEqual(len(spiel.alle_kloester), 1)

        self.assertEqual(player1.meeples, 3)
        self.assertEqual(player2.meeples, 4)
        self.assertEqual(player1.punkte, 4)
        self.assertEqual(player2.punkte, 0)

        k13 = Card('W', 'W', 'S', 'S')
        spiel.make_action(player1, k13, 2, -1, 1)

        #display_spielbrett_dict(spiel.cards_set)

        self.assertEqual(len(spiel.cards_set), 14)

        self.assertEqual(len(spiel.alle_strassen), 6)
        self.assertEqual(len(spiel.alle_orte), 5)
        self.assertEqual(len(spiel.alle_wiesen), 7)
        self.assertEqual(len(spiel.alle_kloester), 1)

        self.assertEqual(player1.meeples, 4)
        self.assertEqual(player2.meeples, 5)
        self.assertEqual(player1.punkte, 11)
        self.assertEqual(player2.punkte, 7)

        k14 = Card('S', 'W', 'S', 'W')
        spiel.make_action(player2, k14, 3, 0, 1, k14.strassen[0])

        self.assertEqual(len(spiel.cards_set), 15)

        self.assertEqual(len(spiel.alle_strassen), 6)
        self.assertEqual(len(spiel.alle_orte), 5)
        self.assertEqual(len(spiel.alle_wiesen), 7)
        self.assertEqual(len(spiel.alle_kloester), 1)

        self.assertEqual(player1.meeples, 4)
        self.assertEqual(player2.meeples, 4)
        self.assertEqual(player1.punkte, 11)
        self.assertEqual(player2.punkte, 7)
Esempio n. 6
0
    def test2(self):
        spiel = Spiel_class.Spiel(Kartenliste)
        player1 = Player_Class.Player(1)
        player2 = Player_Class.Player(2)

        k1 = Card('W', 'W', 'S', 'S')
        spiel.make_action(player1, k1, 0, 1, 3)

        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 1)
        self.assertEqual(len(spiel.alle_wiesen), 2)

        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 7)
        self.assertEqual(player2.meeples, 7)
        self.assertEqual(player1.punkte, 0)
        self.assertEqual(player2.punkte, 0)

        k2 = Card('O', 'S', 'S', 'O', 'O', True)
        spiel.make_action(player2, k2, 1, 1, 2, k2.orte[0])

        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 2)
        self.assertEqual(len(spiel.alle_wiesen), 2)

        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 7)
        self.assertEqual(player2.meeples, 6)
        self.assertEqual(player1.punkte, 0)
        self.assertEqual(player2.punkte, 0)

        k3 = Card('W', 'W', 'S', 'S')
        spiel.make_action(player1, k3, 0, -1, 2, k3.strassen[0])

        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 2)
        self.assertEqual(len(spiel.alle_wiesen), 2)

        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 6)
        self.assertEqual(player2.meeples, 6)
        self.assertEqual(player1.punkte, 0)
        self.assertEqual(player2.punkte, 0)

        k4 = Card('S', 'O', 'W', 'S')
        spiel.make_action(player2, k4, 1, -1, 3, k4. orte[0])

        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 3)
        self.assertEqual(len(spiel.alle_wiesen), 2)

        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 6)
        self.assertEqual(player2.meeples, 5)
        self.assertEqual(player1.punkte, 0)
        self.assertEqual(player2.punkte, 0)

        k5 = Card('O', 'O', 'S', 'O', 'O', True)
        wies = None
        for w in k5.wiesen:
            if w.ecken == [6]:
                wies = w
        spiel.make_action(player1, k5, 1, 2, 0, wies)

        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 4)
        self.assertEqual(len(spiel.alle_wiesen), 2)

        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 5)
        self.assertEqual(player2.meeples, 5)
        self.assertEqual(player1.punkte, 0)
        self.assertEqual(player2.punkte, 0)

        k6 = Card('O', 'O', 'W', 'O', 'O', True)
        spiel.make_action(player2, k6, 1, 0, 3)

        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 2)
        self.assertEqual(len(spiel.alle_wiesen), 3)

        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 5)
        self.assertEqual(player2.meeples, 5)
        self.assertEqual(player1.punkte, 0)
        self.assertEqual(player2.punkte, 0)

        k7 = Card('W', 'S', 'S', 'S')
        spiel.make_action(player1, k7, 1, -2, 1)

        self.assertEqual(len(spiel.alle_strassen), 3)
        self.assertEqual(len(spiel.alle_orte), 2)
        self.assertEqual(len(spiel.alle_wiesen), 4)

        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 6)
        self.assertEqual(player2.meeples, 5)
        self.assertEqual(player1.punkte, 7)
        self.assertEqual(player2.punkte, 0)

        k8 = Card('S', 'O', 'S', 'W')
        spiel.make_action(player2, k8, 2, 1, 2, k8.strassen[0])

        self.assertEqual(len(spiel.alle_strassen), 4)
        self.assertEqual(len(spiel.alle_orte), 2)
        self.assertEqual(len(spiel.alle_wiesen), 6)

        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 6)
        self.assertEqual(player2.meeples, 6)
        self.assertEqual(player1.punkte, 7)
        self.assertEqual(player2.punkte, 14)

        spiel.final_evaluate()
        self.assertEqual(player1.punkte, 10)
        self.assertEqual(player2.punkte, 15)
Esempio n. 7
0
    def test1(self):
        spiel = Spiel_class.Spiel(Kartenliste)
        player1 = Player_Class.Player(1)
        player2 = Player_Class.Player(2)

        k1 = Card('W', 'W', 'S', 'S')
        spiel.make_action(player1, k1, 0, 1, 0, k1.strassen[0])

        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 1)
        self.assertEqual(len(spiel.alle_wiesen), 2)

        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 6)
        self.assertEqual(player2.meeples, 7)
        self.assertEqual(player1.punkte, 0)
        self.assertEqual(player2.punkte, 0)

        k2 = Card('O', 'W', 'W', 'O', 'O', True)
        spiel.make_action(player2, k2, 1, 0, 3, k2.orte[0])

        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 1)
        self.assertEqual(len(spiel.alle_wiesen), 3)

        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 6)
        self.assertEqual(player2.meeples, 6)
        self.assertEqual(player1.punkte, 0)
        self.assertEqual(player2.punkte, 0)

        k3 = Card('O', 'W', 'W', 'W')
        spiel.make_action(player1, k3, 2, 0, 1, k3.orte[0])

        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 2)
        self.assertEqual(len(spiel.alle_wiesen), 3)

        self.assertEqual(len(spiel.alle_kloester), 0)

        self.assertEqual(player1.meeples, 5)
        self.assertEqual(player2.meeples, 6)
        self.assertEqual(player1.punkte, 0)
        self.assertEqual(player2.punkte, 0)

        k4 = Card('W', 'W', 'W', 'W', 'K')
        spiel.make_action(player2, k4, 1, 1, 2, 'k')

        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 2)
        self.assertEqual(len(spiel.alle_wiesen), 2)

        self.assertEqual(len(spiel.alle_kloester), 1)

        self.assertEqual(player1.meeples, 5)
        self.assertEqual(player2.meeples, 5)
        self.assertEqual(player1.punkte, 0)
        self.assertEqual(player2.punkte, 0)

        k5 = Card('O', 'W', 'W', 'O', 'O')
        spiel.make_action(player1, k5, 3, 0, 3)

        self.assertEqual(len(spiel.alle_strassen), 1)
        self.assertEqual(len(spiel.alle_orte), 2)
        self.assertEqual(len(spiel.alle_wiesen), 3)

        self.assertEqual(len(spiel.alle_kloester), 1)

        self.assertEqual(player1.meeples, 5)
        self.assertEqual(player2.meeples, 5)
        self.assertEqual(player1.punkte, 0)

        k6 = Card('S', 'W', 'S', 'W')
        spiel.make_action(player2, k6, 0, 2, 1)

        self.assertEqual(len(spiel.alle_strassen), 2)
        self.assertEqual(len(spiel.alle_orte), 2)
        self.assertEqual(len(spiel.alle_wiesen), 4)

        self.assertEqual(len(spiel.alle_kloester), 1)

        self.assertEqual(player1.meeples, 5)
        self.assertEqual(player2.meeples, 5)
        self.assertEqual(player1.punkte, 0)

        k7 = Card('W', 'W', 'S', 'S')
        spiel.make_action(player1, k7, 0, -1, 1)

        self.assertEqual(len(spiel.alle_strassen), 2)
        self.assertEqual(len(spiel.alle_orte), 2)
        self.assertEqual(len(spiel.alle_wiesen), 4)

        self.assertEqual(len(spiel.alle_kloester), 1)

        self.assertEqual(player1.meeples, 5)
        self.assertEqual(player2.meeples, 5)
        self.assertEqual(player1.punkte, 0)

        #display_spielbrett_dict(spiel.cards_set)

        k8 = Card('O', 'W', 'W', 'W')
        spiel.make_action(player2, k8, 1, -1, 0)

        self.assertEqual(len(spiel.alle_strassen), 2)
        self.assertEqual(len(spiel.alle_orte), 2)
        self.assertEqual(len(spiel.alle_wiesen), 4)

        self.assertEqual(len(spiel.alle_kloester), 1)

        self.assertEqual(player1.meeples, 5)
        self.assertEqual(player2.meeples, 6)
        self.assertEqual(player1.punkte, 0)
        self.assertEqual(player2.punkte, 8)

        # display_spielbrett_dict(spiel.cards_set)
        spiel.final_evaluate()

        self.assertEqual(player1.punkte, 5)
        self.assertEqual(player2.punkte, 14)
Esempio n. 8
0
    def test6(self):
        p1 = Player(1)
        p2 = Player(2)

        spiel = Spiel_class.Spiel([], p1, p2)

        k0 = Card('S', 'O', 'W', 'S')
        spiel.make_action(p1, k0, 1, 0, 2, k0.orte[0])

        k1 = Card('W', 'W', 'S', 'S')

        w = [w for w in k1.wiesen if w.ecken == [4, 5, 6]][0]
        spiel.make_action(p2, k1, 1, 1, 1, w)

        self.assertEqual(p2.meeples, 6)

        ka = Card('S', 'O', 'S', 'S', 'G')
        s = [s for s in ka.strassen if s.kanten == [0]][0]
        spiel.make_action(p1, ka, 1, 2, 2, s)

        self.assertEqual(p1.meeples, 6)
        self.assertEqual(p1.punkte, 4)
        self.assertEqual(p2.meeples, 6)
        self.assertEqual(p2.punkte, 0)

        kb = Card('O', 'S', 'S', 'W')
        spiel.make_action(p2, kb, 0, 2, 1, kb.orte[0])

        self.assertEqual(p1.meeples, 6)
        self.assertEqual(p1.punkte, 4)
        self.assertEqual(p2.meeples, 6)
        self.assertEqual(p2.punkte, 4)

        kc = Card('O', 'O', 'S', 'O', 'O', True)
        spiel.make_action(p1, kc, 1, 3, 0, kc.strassen[0])

        self.assertEqual(p1.meeples, 6)
        self.assertEqual(p1.punkte, 6)
        self.assertEqual(p2.meeples, 6)
        self.assertEqual(p2.punkte, 4)

        k3 = Card('W', 'W', 'S', 'W', 'K')
        spiel.make_action(p2, k3, 0, -1, 2, 'k')

        self.assertEqual(p1.meeples, 6)
        self.assertEqual(p1.punkte, 6)
        self.assertEqual(p2.meeples, 5)
        self.assertEqual(p2.punkte, 4)

        kd = Card('O', 'S', 'S', 'W')
        spiel.make_action(p1, kd, 2, 3, 3, kd.orte[0])

        self.assertEqual(p1.meeples, 5)
        self.assertEqual(p1.punkte, 6)
        self.assertEqual(p2.meeples, 5)
        self.assertEqual(p2.punkte, 4)

        k4 = Card('W', 'W', 'S', 'S')

        w = [w for w in k4.wiesen if w.ecken == [4, 5, 6]][0]
        spiel.make_action(p2, k4, 0, -2, 3, w)

        self.assertEqual(p1.meeples, 5)
        self.assertEqual(p1.punkte, 6)
        self.assertEqual(p2.meeples, 4)
        self.assertEqual(p2.punkte, 4)

        ke = Card('S', 'W', 'S', 'W')
        spiel.make_action(p1, ke, 2, 1, 0)

        self.assertEqual(p1.meeples, 5)
        self.assertEqual(p1.punkte, 6)
        self.assertEqual(p2.meeples, 4)
        self.assertEqual(p2.punkte, 4)

        k6 = Card('W', 'O', 'W', 'O', 'O', True)
        spiel.make_action(p2, k6, -1, -1, 1, k6.orte[0])

        self.assertEqual(p1.meeples, 5)
        self.assertEqual(p1.punkte, 6)
        self.assertEqual(p2.meeples, 3)
        self.assertEqual(p2.punkte, 4)

        #display_spielbrett_dict(spiel.cards_set)

        k5 = Card('S', 'O', 'S', 'S', 'G')
        s = [s for s in k5.strassen if s.kanten == [0]][0]
        spiel.make_action(p1, k5, 0, 1, 2, s)

        self.assertEqual(p1.meeples, 6)
        self.assertEqual(p1.punkte, 12)
        self.assertEqual(p2.meeples, 3)
        self.assertEqual(p2.punkte, 4)

        k6 = Card('O', 'O', 'W', 'O', 'O')
        spiel.make_action(p2, k6, -1, 1, 2, k6.orte[0])

        self.assertEqual(p1.meeples, 6)
        self.assertEqual(p1.punkte, 12)
        self.assertEqual(p2.meeples, 2)
        self.assertEqual(p2.punkte, 4)

        kf = Card('W', 'O', 'O', 'W')
        spiel.make_action(p1, kf, 0, 3, 3, kf.wiesen[0])

        self.assertEqual(p1.meeples, 5)
        self.assertEqual(p1.punkte, 12)
        self.assertEqual(p2.meeples, 2)
        self.assertEqual(p2.punkte, 4)

        k7 = Card('S', 'W', 'S', 'W')
        spiel.make_action(p2, k7, 1, -2, 1, k7.strassen[0])

        self.assertEqual(p1.meeples, 5)
        self.assertEqual(p1.punkte, 12)
        self.assertEqual(p2.meeples, 1)
        self.assertEqual(p2.punkte, 4)

        #display_spielbrett_dict(spiel.cards_set)

        k8 = Card('W', 'O', 'W', 'O', 'O', True)
        spiel.make_action(p1, k8, 0, 4, 1, k8.orte[0])

        self.assertEqual(p1.meeples, 4)
        self.assertEqual(p1.punkte, 12)
        self.assertEqual(p2.meeples, 1)
        self.assertEqual(p2.punkte, 4)

        k9 = Card('W', 'O', 'W', 'O')
        spiel.make_action(p2, k9, 1, 4, 1, k9.wiesen[0])

        self.assertEqual(p1.meeples, 5)
        self.assertEqual(p1.punkte, 22)
        self.assertEqual(p2.meeples, 0)
        self.assertEqual(p2.punkte, 4)

        k10 = Card('O', 'W', 'W', 'O', 'O')
        spiel.make_action(p1, k10, 0, 5, 2)

        self.assertEqual(p1.meeples, 5)
        self.assertEqual(p1.punkte, 22)
        self.assertEqual(p2.meeples, 0)
        self.assertEqual(p2.punkte, 4)

        k11 = Card('W', 'W', 'S', 'S')

        pos = spiel.calculate_possible_actions(k11, p2)

        pass
Esempio n. 9
0
    def test1(self):
        spiel = Spiel_class.Spiel(Kartenliste)
        player1 = Player(1)
        player2 = Player(2)

        k1 = Card('O', 'W', 'W', 'O', 'O')
        spiel.make_action(player2, k1, 1, 0, 0, k1.orte[0])

        x, y = player1.punkte, player2.punkte

        spiel.final_evaluate()

        self.assertEqual(player1.punkte, 0)
        self.assertEqual(player2.punkte, 2)

        player1.punkte, player2.punkte = x, y

        k2 = Card('O', 'W', 'W', 'W')
        spiel.make_action(player1, k2, 2, 0, 1, k2.orte[0])

        x, y = player1.punkte, player2.punkte

        spiel.final_evaluate()

        self.assertEqual(player1.punkte, 1)
        self.assertEqual(player2.punkte, 2)

        player1.punkte, player2.punkte = x, y

        k3 = Card('O', 'O', 'S', 'O', 'O', True)
        spiel.make_action(player2, k3, 1, 1, 2, k3.strassen[0])

        x, y = player1.punkte, player2.punkte

        spiel.final_evaluate()

        self.assertEqual(player1.punkte, 1)
        self.assertEqual(player2.punkte, 5)

        player1.punkte, player2.punkte = x, y

        k4 = Card('S', 'O', 'S', 'S', 'G')
        wiese = None
        for w in k4.wiesen:
            if w.ecken == [5, 6]:
                wiese = w
                break

        spiel.make_action(player1, k4, 3, 0, 2, wiese)

        x, y = player1.punkte, player2.punkte

        spiel.final_evaluate()

        self.assertEqual(player1.punkte, 7)
        self.assertEqual(player2.punkte, 5)

        player1.punkte, player2.punkte = x, y

        k5 = Card('O', 'W', 'W', 'O', 'O')
        spiel.make_action(player2, k5, 2, 1, 0, k5.wiesen[0])

        x, y = player1.punkte, player2.punkte

        spiel.final_evaluate()

        self.assertEqual(player1.punkte, 7)
        self.assertEqual(player2.punkte, 9)

        player1.punkte, player2.punkte = x, y

        #display_spielbrett_dict(spiel.cards_set)

        k6 = Card('W', 'W', 'S', 'S')
        spiel.make_action(player1, k6, 3, 1, 3, k6.strassen[0])

        x, y = player1.punkte, player2.punkte

        spiel.final_evaluate()

        self.assertEqual(player1.punkte, 9)
        self.assertEqual(player2.punkte, 9)

        player1.punkte, player2.punkte = x, y