Esempio n. 1
0
    def test_deplacer_les_dés_1_et_6(self):
        partie = Partie(2, 2)
        partie.sens = 1
        partie.joueur_courant = partie.joueurs[0]
        partie.determiner_joueur_suivant()

        # Cas 1: 1 dé de valeur 1 et 1 dé de valeur 6
        partie.joueurs[0].dés = [Dé(1), Dé(2), Dé(3), Dé(4), Dé(5), Dé(6)]
        partie.joueurs[1].dés = [Dé(2), Dé(2), Dé(4)]
        partie.deplacer_les_dés_1_et_6(1, 1)

        self.assertEqual(str([Dé(2), Dé(3), Dé(4), Dé(5)]),
                         str(partie.joueurs[0].dés))
        self.assertEqual(4, len(partie.joueurs[1]))

        # Cas 2: 5 dé de valeur 1 et 0 dé de valeur 6
        partie.joueurs[0].dés = [Dé(1), Dé(1), Dé(1), Dé(1), Dé(1)]
        partie.joueurs[1].dés = [Dé(2), Dé(2), Dé(4)]
        partie.deplacer_les_dés_1_et_6(5, 0)

        self.assertEqual(str([]), str(partie.joueurs[0].dés))
        self.assertEqual(3, len(partie.joueurs[1]))

        # Cas 3: 0 dé de valeur 1 et 5 dé de valeur 6
        partie.joueurs[0].dés = [Dé(6), Dé(6), Dé(6), Dé(6), Dé(6)]
        partie.joueurs[1].dés = [Dé(2), Dé(2), Dé(4)]
        partie.deplacer_les_dés_1_et_6(0, 5)

        self.assertEqual(str([]), str(partie.joueurs[0].dés))
        self.assertEqual(8, len(partie.joueurs[1]))
Esempio n. 2
0
    def test_verifier_si_fin_de_ronde(self):

        partie = Partie(6, 3)
        partie.joueur_courant = partie.joueurs[4]
        self.assertFalse(partie.verifier_si_fin_de_ronde())

        partie.joueurs[4].dés = []
        self.assertTrue(partie.verifier_si_fin_de_ronde())
Esempio n. 3
0
    def test_ajuster_points_du_gagnant(self):

        partie = Partie(3, 2)

        partie.joueur_courant = partie.joueurs[2]
        partie.joueur_courant.score = 40

        partie.ajuster_points_du_gagnant(15)

        self.assertEqual(55, partie.joueur_courant.score)
Esempio n. 4
0
    def test_passer_au_prochain_joueur(self):

        partie = Partie(5, 1)
        partie.joueur_courant = partie.joueurs[0]
        partie.sens = 1

        partie.passer_au_prochain_joueur()
        self.assertEqual(partie.joueur_courant.identifiant, 2)
        self.assertEqual(partie.joueur_suivant.identifiant, 3)

        partie.passer_au_prochain_joueur()
        self.assertEqual(partie.joueur_courant.identifiant, 3)
        self.assertEqual(partie.joueur_suivant.identifiant, 4)

        partie.passer_au_prochain_joueur()
        partie.passer_au_prochain_joueur()
        self.assertEqual(partie.joueur_courant.identifiant, 5)
        self.assertEqual(partie.joueur_suivant.identifiant, 1)

        partie.joueurs_actifs = [
            partie.joueurs[0], partie.joueurs[2], partie.joueurs[4]
        ]
        partie.joueur_suivant = partie.joueurs[0]

        partie.passer_au_prochain_joueur()
        self.assertEqual(partie.joueur_courant.identifiant, 1)
        self.assertEqual(partie.joueur_suivant.identifiant, 3)

        partie.passer_au_prochain_joueur()
        self.assertEqual(partie.joueur_courant.identifiant, 3)
        self.assertEqual(partie.joueur_suivant.identifiant, 5)

        partie.passer_au_prochain_joueur()
        self.assertEqual(partie.joueur_courant.identifiant, 5)
        self.assertEqual(partie.joueur_suivant.identifiant, 1)

        partie.sens = -1

        partie.joueur_suivant = partie.joueurs[2]

        self.assertEqual(partie.joueur_courant.identifiant, 5)
        self.assertEqual(partie.joueur_suivant.identifiant, 3)

        partie.passer_au_prochain_joueur()
        self.assertEqual(partie.joueur_courant.identifiant, 3)
        self.assertEqual(partie.joueur_suivant.identifiant, 1)

        partie.passer_au_prochain_joueur()
        self.assertEqual(partie.joueur_courant.identifiant, 1)
        self.assertEqual(partie.joueur_suivant.identifiant, 5)
Esempio n. 5
0
    def test_determiner_joueur_suivant(self):

        partie = Partie(7, 6)
        partie.joueur_courant = partie.joueurs[5]

        # Cas 1: Sens horaire, on passe au prochain avec un retour au premier joueur
        partie.sens = 1
        partie.determiner_joueur_suivant()
        self.assertEqual(partie.joueurs[6], partie.joueur_suivant)

        partie.joueur_courant = partie.joueurs[6]
        partie.determiner_joueur_suivant()
        self.assertEqual(partie.joueurs[0], partie.joueur_suivant)

        # Cas 2: Sens anti-horaire, on passe au joueur précédent
        partie.sens = -1
        partie.joueur_courant = partie.joueurs[1]
        partie.determiner_joueur_suivant()
        self.assertEqual(partie.joueurs[0], partie.joueur_suivant)

        partie.joueur_courant = partie.joueurs[0]
        partie.determiner_joueur_suivant()
        self.assertEqual(partie.joueurs[6], partie.joueur_suivant)

        # Cas 3: Sens horaire, avec seulement quelques joueurs actifs.
        partie.sens = 1
        partie.joueurs_actifs = [
            partie.joueurs[1], partie.joueurs[4], partie.joueurs[6]
        ]
        partie.joueur_courant = partie.joueurs[4]

        partie.determiner_joueur_suivant()
        self.assertEqual(partie.joueurs[6], partie.joueur_suivant)

        partie.joueur_courant = partie.joueurs[6]
        partie.determiner_joueur_suivant()
        self.assertEqual(partie.joueurs[1], partie.joueur_suivant)

        # Cas 4: Sens anti-horaire, avec seulement quelques joueurs actifs
        partie.sens = -1

        partie.determiner_joueur_suivant()
        self.assertEqual(partie.joueurs[4], partie.joueur_suivant)

        partie.joueur_courant = partie.joueurs[1]
        partie.determiner_joueur_suivant()
        self.assertEqual(partie.joueurs[6], partie.joueur_suivant)
Esempio n. 6
0
    def test_jouer_dés_en_fin_de_ronde(self):

        partie = Partie(3, 2)

        partie.joueurs[0].dés = [Dé(4), Dé(5), Dé(6)]
        partie.joueurs[1].dés = [Dé(1), Dé(2)]
        partie.joueurs[2].dés = []
        partie.joueur_courant = partie.joueurs[2]

        dés_joueur0 = [Dé(4), Dé(5), Dé(6)]
        dés_joueur1 = [Dé(1), Dé(2)]

        partie.jouer_dés_en_fin_de_ronde()

        # Les dés des deux joueurs à qui il reste des dés doivent changer (petite possibilité de dés identiques)
        self.assertNotEqual(str(dés_joueur0), str(partie.joueurs[0].dés))
        self.assertNotEqual(str(dés_joueur1), str(partie.joueurs[1].dés))
        self.assertEqual([], partie.joueurs[2].dés)
Esempio n. 7
0
    def test_verifier_des_joueur_courant_pour_1_et_6(self):

        partie = Partie(2, 2)
        partie.joueurs[0].dés = [Dé(1), Dé(2), Dé(3), Dé(4), Dé(5), Dé(6)]
        partie.joueur_courant = partie.joueurs[0]
        self.assertEqual((1, 1),
                         partie.verifier_dés_joueur_courant_pour_1_et_6())

        partie.joueurs[0].dés = [Dé(2), Dé(2), Dé(3), Dé(4), Dé(5), Dé(5)]
        self.assertEqual((0, 0),
                         partie.verifier_dés_joueur_courant_pour_1_et_6())

        partie.joueurs[0].dés = [Dé(2), Dé(2), Dé(3), Dé(4), Dé(5), Dé(6)]
        self.assertEqual((0, 1),
                         partie.verifier_dés_joueur_courant_pour_1_et_6())

        partie.joueurs[0].dés = [Dé(1), Dé(1), Dé(1), Dé(1), Dé(1), Dé(1)]
        self.assertEqual((6, 0),
                         partie.verifier_dés_joueur_courant_pour_1_et_6())
Esempio n. 8
0
    def test_ajuster_points_des_perdants_en_fin_de_ronde(self):

        partie = Partie(4, 2)
        partie.joueur_courant = partie.joueurs[0]
        partie.joueurs[0].dés = []
        partie.joueurs[1].dés = [Dé(5), Dé(3)]
        partie.joueurs[2].dés = [Dé(2)]
        partie.joueurs[3].dés = [Dé(4), Dé(1), Dé(6)]

        partie.joueurs[1].score = 10
        partie.joueurs[2].score = 35
        partie.joueurs[3].score = 8

        points_au_gagnant = partie.ajuster_points_des_perdants_en_fin_de_ronde(
        )

        self.assertEqual(18, points_au_gagnant)
        self.assertEqual(2, partie.joueurs[1].score)
        self.assertEqual(33, partie.joueurs[2].score)
        self.assertEqual(0, partie.joueurs[3].score)