Exemple #1
0
class Controleur(object):
    def __init__(self,listeJoueurs,debug=False):
        self._debug = debug
        random.seed()
        self._nombreJoueurs = len(listeJoueurs)

        if self._debug:
            self._numeroSequenceDes = 0
            self._mappe = Mappe(['foret','champ','colline','champ','colline','montagne','pre','foret','montagne','desert','foret','colline','pre','champ','montagne','pre','pre','foret','champ'])
            self._paquetCartes = Cartes(True)
        else:
            random.shuffle(listeJoueurs)
            self._mappe = Mappe()
            self._paquetCartes = Cartes()

        self._joueurs = []
        self._longueurCheminPlusLong = 1
        self._joueurAyantCheminPlusLong = None
        self._armeePlusPuissante = 0
        self._joueurAyantArmeePlusPuissante = None

        for i in range(self._nombreJoueurs):
            self._joueurs.append(fabrique.creerJoueur(listeJoueurs[i],i))


    def jouer(self):
        # Premier tour: chaque joueur place une colonie et une route
        for i in range(self._nombreJoueurs):
            #print 'Premier tour,', self._joueurs[i].nom()
            try:
                (positionColonie, extremiteRoute) = self._joueurs[i].premierTour(self._mappe)
                self._mappe._ajouterOccupationInitiale(positionColonie,Occupation.COLONIE,i)
                self._joueurs[i].ajusterCapaciteEchange(self._mappe.obtenirIntersection(positionColonie))
                self._mappe._ajouterRoute(positionColonie, extremiteRoute, i)
                #print 'Occupation placée avec succès'
            except RuntimeError as e:
                print 'ERREUR:', e

        # Deuxième tour: en ordre inverse, chaque joueur place une seconde colonie et une seconde route
        for i in range(self._nombreJoueurs-1,-1,-1):
            #print 'Deuxième  tour,', self._joueurs[i].nom()
            try:
                (positionColonie, extremiteRoute) = self._joueurs[i].deuxiemeTour(self._mappe)
                self._mappe._ajouterOccupationInitiale(positionColonie,Occupation.COLONIE,i)
                self._joueurs[i].ajusterCapaciteEchange(self._mappe.obtenirIntersection(positionColonie))
                self._mappe._ajouterRoute(positionColonie, extremiteRoute, i)
                #print 'Occupation placée avec succès'
                
                # Distribuer les ressources initiales
                self._mappe._distribuerRessourcesInitiales(self._joueurs[i],positionColonie)

            except RuntimeError as e:
                print 'ERREUR:', e



        #print 'État après le placement initial:'
        #self._mappe.afficher()

        #self._afficherEtatJoueurs()

        # À partir de maintenant on commence les tours réguliers
        joueurCourant = 0
        numeroTour = 0
        while not self._joueurGagnant() and numeroTour < 1000:
            numeroTour += 1
            valeur = self._lancerDes()

            #print 'Tour', numeroTour
            #print 'Valeur des dés',valeur

            # Si la valeur des dés est 7, chaque joueur possédant plus de 7 cartes doit en discarter la 
            # moitié et le joueur courant doit déplacer les voleurs
            if (valeur == 7):
                for joueur in self._joueurs:
                    if joueur.nombreRessources() > 7:
                        #print joueur.nom(),"se fait voler"
                        quantiteVolee = joueur.nombreRessources() // 2
                        joueur.volerRessources(quantiteVolee)

                if self._debug:
                    (positionVoleurs,joueurVole) = self._joueurs[joueurCourant].jouerVoleurs(self._mappe,self._infoJoueurs())
                else:
                    (positionVoleurs,joueurVole) = self._joueurs[joueurCourant].jouerVoleurs(self._mappe,self._infoJoueurs())

                if 1 <= positionVoleurs and positionVoleurs <= 19 and joueurVole in range(self._nombreJoueurs):
                    self._mappe._deplacerVoleurs(positionVoleurs)
                    #print self._joueurs[joueurCourant].nom(), 'vole', self._joueurs[joueurVole].nom()
                    ressourceVolee = self._joueurs[joueurVole].pigerRessourceAleatoirement()
                    if ressourceVolee == None:
                        print "ERREUR : Ce joueur ne possède aucune ressource"
                    else:
                        self._joueurs[joueurCourant].ajouterRessources(ressourceVolee,1)

            # Sinon, chaque joueur reçoit les ressources auxquelles il a droit
            else:
                ressources = self._mappe._distribuerRessources(valeur)
                for (j,r) in ressources:
                    self._joueurs[j].ajouterRessources(r,ressources[(j,r)])

            # On rend jouables les cartes chevalier recues dans le tour précédent
            self._joueurs[joueurCourant].activerChevaliers()

            #print 'Etat des joueurs après distribution des ressources:'
            for i in range(self._nombreJoueurs):
                self._joueurs[i].afficher()
            #print 
            #print self._joueurs[joueurCourant].nom(), '[', joueurCourant, '] joue'

            # On exécute toutes les actions choisies par le joueur courant
            nombreActions = 0
            if self._debug:
                action = self._joueurs[joueurCourant].choisirAction(self._mappe,self._infoJoueurs(),self._paquetCartes.vide(),self._numeroSequenceDes)
            else:
                action = self._joueurs[joueurCourant].choisirAction(self._mappe,self._infoJoueurs(),self._paquetCartes.vide())

            while action != Action.TERMINER and nombreActions < 50:
                self._executer(action,joueurCourant)
                if self._debug:
                    action = self._joueurs[joueurCourant].choisirAction(self._mappe,self._infoJoueurs(),self._paquetCartes.vide(),self._numeroSequenceDes)
                else:
                    action = self._joueurs[joueurCourant].choisirAction(self._mappe,self._infoJoueurs(),self._paquetCartes.vide())
                nombreActions += 1

            # On passe au joueur suivant
            #print "État à la fin du tour"
            #self._mappe.afficher()
            #self._afficherEtatJoueurs()
            joueurCourant = (joueurCourant+1) % self._nombreJoueurs


    # Retourne une liste contenant un triplet (pv, car, ch) pour chaque joueur
    #  où pv = nombre de points de victoire (excluant les cartes de points de victoire cachées)
    #     car = nombre de cartes ressources que le joueur a en sa possession
    #     ch = nombre de cartes chevalier jouées
    def _infoJoueurs(self):
        infoJoueurs = []
        for i in range(self._nombreJoueurs):
            infoJoueurs.append((self._joueurs[i].nombrePointsVictoireVisibles(), 
                                self._joueurs[i].nombreCartesRessources(), 
                                self._joueurs[i].nombreChevaliers()))
        return infoJoueurs

    def _afficherEtatJoueurs(self):
        for i in range(self._nombreJoueurs):
            self._joueurs[i].afficher()


    def _joueurGagnant(self):
        for j in range(self._nombreJoueurs):
            if self._joueurs[j].nombrePointsVictoire() >= 10:
                #print self._joueurs[j].nom(),"a gagné la partie"
                for k in range(self._nombreJoueurs):
                    self._joueurs[k].finDePartie(self._mappe,self._joueurs[j].id())
                return True
        return False


    def _executer(self,(action,donnees),joueurCourant):
        if action == Action.ACHETER_CARTE:
            #print "ACHETER CARTE"
            if (self._joueurs[joueurCourant].quantiteRessources(Ressource.LAINE) >= 1 and
                self._joueurs[joueurCourant].quantiteRessources(Ressource.MINERAL) >= 1 and
                self._joueurs[joueurCourant].quantiteRessources(Ressource.BLE) >= 1):
                if self._paquetCartes.vide():
                    i=0
                    #print "ERREUR: Paquet de cartes vide"
                else:
                    self._joueurs[joueurCourant].retirerRessources(Ressource.LAINE,1)
                    self._joueurs[joueurCourant].retirerRessources(Ressource.MINERAL,1)
                    self._joueurs[joueurCourant].retirerRessources(Ressource.BLE,1)            
                    self._joueurs[joueurCourant].ajouterCarte(self._paquetCartes.pigerCarte())
            else:
                print "ERREUR: Pas assez de ressources pour acheter une carte"

        elif action == Action.AJOUTER_COLONIE:
            #print "AJOUTER COLONIE"
            if (self._joueurs[joueurCourant].quantiteRessources(Ressource.BOIS) >= 1 and
                self._joueurs[joueurCourant].quantiteRessources(Ressource.ARGILE) >= 1 and
                self._joueurs[joueurCourant].quantiteRessources(Ressource.BLE) >= 1 and
                self._joueurs[joueurCourant].quantiteRessources(Ressource.LAINE) >= 1):
                try:
                    self._mappe._ajouterOccupation(donnees[0],Occupation.COLONIE,joueurCourant)
                    self._joueurs[joueurCourant].ajusterCapaciteEchange(self._mappe.obtenirIntersection(donnees[0]))
                    self._joueurs[joueurCourant].retirerRessources(Ressource.BOIS,1)
                    self._joueurs[joueurCourant].retirerRessources(Ressource.ARGILE,1)
                    self._joueurs[joueurCourant].retirerRessources(Ressource.BLE,1)     
                    self._joueurs[joueurCourant].retirerRessources(Ressource.LAINE,1)     
                    self._joueurs[joueurCourant].augmenterPointsVictoire(1)
                except RuntimeError as e:
                        print 'ERREUR:',e
            else:
                print "ERREUR: Pas assez de ressources pour construire une colonie"


        elif action == Action.AJOUTER_VILLE:
            #print "AJOUTER VILLE"
            if (self._joueurs[joueurCourant].quantiteRessources(Ressource.BLE) >= 2 and
                self._joueurs[joueurCourant].quantiteRessources(Ressource.MINERAL) >= 3):
                   try:
                       self._mappe._ajouterOccupation(donnees[0],Occupation.VILLE,joueurCourant)
                       self._joueurs[joueurCourant].retirerRessources(Ressource.BLE,2)     
                       self._joueurs[joueurCourant].retirerRessources(Ressource.MINERAL,3)     
                       self._joueurs[joueurCourant].augmenterPointsVictoire(1)
                   except RuntimeError as e:
                       print 'ERREUR:',e
            else:
                print "ERREUR: Pas assez de ressources pour construire une ville"


        elif action == Action.AJOUTER_ROUTE:  
            #print "AJOUTER ROUTE"                        
            if (self._joueurs[joueurCourant].quantiteRessources(Ressource.BOIS) >= 1 and
                self._joueurs[joueurCourant].quantiteRessources(Ressource.ARGILE) >= 1):
                   try:
                       self._mappe._ajouterRoute(donnees[0],donnees[1],joueurCourant)
                       self._joueurs[joueurCourant].retirerRessources(Ressource.BOIS,1)
                       self._joueurs[joueurCourant].retirerRessources(Ressource.ARGILE,1)
                       self._attribuerPointsRoutePlusLongue(joueurCourant)
                   except RuntimeError as e:
                       print 'ERREUR:',e
            else:
                print "ERREUR: Pas assez de ressources pour construire une route"

 
        elif action == Action.JOUER_CARTE_CHEVALIER:
            #print "JOUER CARTE CHEVALIER"
            try:
                self._joueurs[joueurCourant].jouerCarteChevalier()
                self._attribuerPointsArmeePlusPuissante(joueurCourant)
                self._mappe._deplacerVoleurs(donnees[0])
                joueurVole = donnees[1]
                if joueurVole in  [v.obtenirOccupant() for v in self._mappe.obtenirTerritoire(donnees[0]).obtenirVoisins()]:
                    ressourceVolee = self._joueurs[joueurVole].pigerRessourceAleatoirement()
                    self._joueurs[joueurCourant].ajouterRessources(ressourceVolee,1)
            except Exception as e:
                print 'ERREUR:', e

        elif action == Action.ECHANGER_RESSOURCES:
            #print "ECHANGER"
            self._echanger(joueurCourant,donnees[0],donnees[1],donnees[2])

        else:
            pass # Action invalide
Exemple #2
0
class Controleur(object):
    def __init__(self, listeJoueurs, debug=False):
        self._debug = debug
        random.seed()
        self._nombreJoueurs = len(listeJoueurs)

        if self._debug:
            self._numeroSequenceDes = 0
            self._mappe = Mappe([
                'foret', 'champ', 'colline', 'champ', 'colline', 'montagne',
                'pre', 'foret', 'montagne', 'desert', 'foret', 'colline',
                'pre', 'champ', 'montagne', 'pre', 'pre', 'foret', 'champ'
            ])
            self._paquetCartes = Cartes(True)
        else:
            random.shuffle(listeJoueurs)
            self._mappe = Mappe()
            self._paquetCartes = Cartes()

        self._joueurs = []
        self._longueurCheminPlusLong = 1
        self._joueurAyantCheminPlusLong = None
        self._armeePlusPuissante = 0
        self._joueurAyantArmeePlusPuissante = None

        for i in range(self._nombreJoueurs):
            self._joueurs.append(fabrique.creerJoueur(listeJoueurs[i], i))

    def jouer(self):
        # Premier tour: chaque joueur place une colonie et une route
        for i in range(self._nombreJoueurs):
            #print 'Premier tour,', self._joueurs[i].nom()
            try:
                (positionColonie,
                 extremiteRoute) = self._joueurs[i].premierTour(self._mappe)
                self._mappe._ajouterOccupationInitiale(positionColonie,
                                                       Occupation.COLONIE, i)
                self._joueurs[i].ajusterCapaciteEchange(
                    self._mappe.obtenirIntersection(positionColonie))
                self._mappe._ajouterRoute(positionColonie, extremiteRoute, i)
                #print 'Occupation placée avec succès'
            except RuntimeError as e:
                print 'ERREUR:', e

        # Deuxième tour: en ordre inverse, chaque joueur place une seconde colonie et une seconde route
        for i in range(self._nombreJoueurs - 1, -1, -1):
            #print 'Deuxième  tour,', self._joueurs[i].nom()
            try:
                (positionColonie,
                 extremiteRoute) = self._joueurs[i].deuxiemeTour(self._mappe)
                self._mappe._ajouterOccupationInitiale(positionColonie,
                                                       Occupation.COLONIE, i)
                self._joueurs[i].ajusterCapaciteEchange(
                    self._mappe.obtenirIntersection(positionColonie))
                self._mappe._ajouterRoute(positionColonie, extremiteRoute, i)
                #print 'Occupation placée avec succès'

                # Distribuer les ressources initiales
                self._mappe._distribuerRessourcesInitiales(
                    self._joueurs[i], positionColonie)

            except RuntimeError as e:
                print 'ERREUR:', e

        #print 'État après le placement initial:'
        #self._mappe.afficher()

        #self._afficherEtatJoueurs()

        # À partir de maintenant on commence les tours réguliers
        joueurCourant = 0
        numeroTour = 0
        while not self._joueurGagnant() and numeroTour < 1000:
            numeroTour += 1
            valeur = self._lancerDes()

            #print 'Tour', numeroTour
            #print 'Valeur des dés',valeur

            # Si la valeur des dés est 7, chaque joueur possédant plus de 7 cartes doit en discarter la
            # moitié et le joueur courant doit déplacer les voleurs
            if (valeur == 7):
                for joueur in self._joueurs:
                    if joueur.nombreRessources() > 7:
                        #print joueur.nom(),"se fait voler"
                        quantiteVolee = joueur.nombreRessources() // 2
                        joueur.volerRessources(quantiteVolee)

                if self._debug:
                    (positionVoleurs,
                     joueurVole) = self._joueurs[joueurCourant].jouerVoleurs(
                         self._mappe, self._infoJoueurs())
                else:
                    (positionVoleurs,
                     joueurVole) = self._joueurs[joueurCourant].jouerVoleurs(
                         self._mappe, self._infoJoueurs())

                if 1 <= positionVoleurs and positionVoleurs <= 19 and joueurVole in range(
                        self._nombreJoueurs):
                    self._mappe._deplacerVoleurs(positionVoleurs)
                    #print self._joueurs[joueurCourant].nom(), 'vole', self._joueurs[joueurVole].nom()
                    ressourceVolee = self._joueurs[
                        joueurVole].pigerRessourceAleatoirement()
                    if ressourceVolee == None:
                        print "ERREUR : Ce joueur ne possède aucune ressource"
                    else:
                        self._joueurs[joueurCourant].ajouterRessources(
                            ressourceVolee, 1)

            # Sinon, chaque joueur reçoit les ressources auxquelles il a droit
            else:
                ressources = self._mappe._distribuerRessources(valeur)
                for (j, r) in ressources:
                    self._joueurs[j].ajouterRessources(r, ressources[(j, r)])

            # On rend jouables les cartes chevalier recues dans le tour précédent
            self._joueurs[joueurCourant].activerChevaliers()

            #print 'Etat des joueurs après distribution des ressources:'
            for i in range(self._nombreJoueurs):
                self._joueurs[i].afficher()
            #print
            #print self._joueurs[joueurCourant].nom(), '[', joueurCourant, '] joue'

            # On exécute toutes les actions choisies par le joueur courant
            nombreActions = 0
            if self._debug:
                action = self._joueurs[joueurCourant].choisirAction(
                    self._mappe, self._infoJoueurs(),
                    self._paquetCartes.vide(), self._numeroSequenceDes)
            else:
                action = self._joueurs[joueurCourant].choisirAction(
                    self._mappe, self._infoJoueurs(),
                    self._paquetCartes.vide())

            while action != Action.TERMINER and nombreActions < 50:
                self._executer(action, joueurCourant)
                if self._debug:
                    action = self._joueurs[joueurCourant].choisirAction(
                        self._mappe, self._infoJoueurs(),
                        self._paquetCartes.vide(), self._numeroSequenceDes)
                else:
                    action = self._joueurs[joueurCourant].choisirAction(
                        self._mappe, self._infoJoueurs(),
                        self._paquetCartes.vide())
                nombreActions += 1

            # On passe au joueur suivant
            #print "État à la fin du tour"
            #self._mappe.afficher()
            #self._afficherEtatJoueurs()
            joueurCourant = (joueurCourant + 1) % self._nombreJoueurs

    # Retourne une liste contenant un triplet (pv, car, ch) pour chaque joueur
    #  où pv = nombre de points de victoire (excluant les cartes de points de victoire cachées)
    #     car = nombre de cartes ressources que le joueur a en sa possession
    #     ch = nombre de cartes chevalier jouées
    def _infoJoueurs(self):
        infoJoueurs = []
        for i in range(self._nombreJoueurs):
            infoJoueurs.append(
                (self._joueurs[i].nombrePointsVictoireVisibles(),
                 self._joueurs[i].nombreCartesRessources(),
                 self._joueurs[i].nombreChevaliers()))
        return infoJoueurs

    def _afficherEtatJoueurs(self):
        for i in range(self._nombreJoueurs):
            self._joueurs[i].afficher()

    def _joueurGagnant(self):
        for j in range(self._nombreJoueurs):
            if self._joueurs[j].nombrePointsVictoire() >= 10:
                #print self._joueurs[j].nom(),"a gagné la partie"
                for k in range(self._nombreJoueurs):
                    self._joueurs[k].finDePartie(self._mappe,
                                                 self._joueurs[j].id())
                return True
        return False

    def _executer(self, (action, donnees), joueurCourant):
        if action == Action.ACHETER_CARTE:
            #print "ACHETER CARTE"
            if (self._joueurs[joueurCourant].quantiteRessources(
                    Ressource.LAINE) >= 1
                    and self._joueurs[joueurCourant].quantiteRessources(
                        Ressource.MINERAL) >= 1
                    and self._joueurs[joueurCourant].quantiteRessources(
                        Ressource.BLE) >= 1):
                if self._paquetCartes.vide():
                    i = 0
                    #print "ERREUR: Paquet de cartes vide"
                else:
                    self._joueurs[joueurCourant].retirerRessources(
                        Ressource.LAINE, 1)
                    self._joueurs[joueurCourant].retirerRessources(
                        Ressource.MINERAL, 1)
                    self._joueurs[joueurCourant].retirerRessources(
                        Ressource.BLE, 1)
                    self._joueurs[joueurCourant].ajouterCarte(
                        self._paquetCartes.pigerCarte())
            else:
                print "ERREUR: Pas assez de ressources pour acheter une carte"

        elif action == Action.AJOUTER_COLONIE:
            #print "AJOUTER COLONIE"
            if (self._joueurs[joueurCourant].quantiteRessources(Ressource.BOIS)
                    >= 1 and self._joueurs[joueurCourant].quantiteRessources(
                        Ressource.ARGILE) >= 1
                    and self._joueurs[joueurCourant].quantiteRessources(
                        Ressource.BLE) >= 1
                    and self._joueurs[joueurCourant].quantiteRessources(
                        Ressource.LAINE) >= 1):
                try:
                    self._mappe._ajouterOccupation(donnees[0],
                                                   Occupation.COLONIE,
                                                   joueurCourant)
                    self._joueurs[joueurCourant].ajusterCapaciteEchange(
                        self._mappe.obtenirIntersection(donnees[0]))
                    self._joueurs[joueurCourant].retirerRessources(
                        Ressource.BOIS, 1)
                    self._joueurs[joueurCourant].retirerRessources(
                        Ressource.ARGILE, 1)
                    self._joueurs[joueurCourant].retirerRessources(
                        Ressource.BLE, 1)
                    self._joueurs[joueurCourant].retirerRessources(
                        Ressource.LAINE, 1)
                    self._joueurs[joueurCourant].augmenterPointsVictoire(1)
                except RuntimeError as e:
                    print 'ERREUR:', e
            else:
                print "ERREUR: Pas assez de ressources pour construire une colonie"

        elif action == Action.AJOUTER_VILLE:
            #print "AJOUTER VILLE"
            if (self._joueurs[joueurCourant].quantiteRessources(Ressource.BLE)
                    >= 2 and self._joueurs[joueurCourant].quantiteRessources(
                        Ressource.MINERAL) >= 3):
                try:
                    self._mappe._ajouterOccupation(donnees[0],
                                                   Occupation.VILLE,
                                                   joueurCourant)
                    self._joueurs[joueurCourant].retirerRessources(
                        Ressource.BLE, 2)
                    self._joueurs[joueurCourant].retirerRessources(
                        Ressource.MINERAL, 3)
                    self._joueurs[joueurCourant].augmenterPointsVictoire(1)
                except RuntimeError as e:
                    print 'ERREUR:', e
            else:
                print "ERREUR: Pas assez de ressources pour construire une ville"

        elif action == Action.AJOUTER_ROUTE:
            #print "AJOUTER ROUTE"
            if (self._joueurs[joueurCourant].quantiteRessources(Ressource.BOIS)
                    >= 1 and self._joueurs[joueurCourant].quantiteRessources(
                        Ressource.ARGILE) >= 1):
                try:
                    self._mappe._ajouterRoute(donnees[0], donnees[1],
                                              joueurCourant)
                    self._joueurs[joueurCourant].retirerRessources(
                        Ressource.BOIS, 1)
                    self._joueurs[joueurCourant].retirerRessources(
                        Ressource.ARGILE, 1)
                    self._attribuerPointsRoutePlusLongue(joueurCourant)
                except RuntimeError as e:
                    print 'ERREUR:', e
            else:
                print "ERREUR: Pas assez de ressources pour construire une route"

        elif action == Action.JOUER_CARTE_CHEVALIER:
            #print "JOUER CARTE CHEVALIER"
            try:
                self._joueurs[joueurCourant].jouerCarteChevalier()
                self._attribuerPointsArmeePlusPuissante(joueurCourant)
                self._mappe._deplacerVoleurs(donnees[0])
                joueurVole = donnees[1]
                if joueurVole in [
                        v.obtenirOccupant()
                        for v in self._mappe.obtenirTerritoire(
                            donnees[0]).obtenirVoisins()
                ]:
                    ressourceVolee = self._joueurs[
                        joueurVole].pigerRessourceAleatoirement()
                    self._joueurs[joueurCourant].ajouterRessources(
                        ressourceVolee, 1)
            except Exception as e:
                print 'ERREUR:', e

        elif action == Action.ECHANGER_RESSOURCES:
            #print "ECHANGER"
            self._echanger(joueurCourant, donnees[0], donnees[1], donnees[2])

        else:
            pass  # Action invalide
Exemple #3
0
class TestPrincipal(unittest.TestCase):

    def setUp(self):
        self.mappe = Mappe()


    def tearDown(self):
        pass
        #self.mappe.afficher()
        
    def testAjouterOccupationInitiale1(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.assertTrue(self.mappe.obtenirIntersection(23).occupe())
        self.assertFalse(self.mappe.joueurPossedeRoute(23,24,1))
        print "Test - Occupation initiale 1"

        
    def testAjouterOccupationInitiale2(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.mappe._ajouterRoute(23,24,1)
        self.assertTrue(self.mappe.obtenirIntersection(23).occupe())
        self.assertTrue(self.mappe.joueurPossedeRoute(23,24,1))
        print "Test - Occupation initiale 2"

    def testAjouterOccupationInitiale3(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.mappe._ajouterRoute(23,24,1)
        self.assertRaisesRegexp(RuntimeError,'Une intersection voisine est déjà occupée',self.mappe._ajouterOccupationInitiale,22,Occupation.COLONIE,2)
        print "Test - Occupation initiale 3"


    def testAjoutColonie(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.assertRaisesRegexp(RuntimeError,'Emplacement déjà occupé',self.mappe._ajouterOccupationInitiale,23,Occupation.COLONIE,1)
        print "Test- Ajout colonie"

    def testAjoutVille1(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.mappe._ajouterRoute(23,24,1)
        self.mappe._ajouterRoute(14,24,1)
        self.assertRaisesRegexp(RuntimeError,'On ne peut construire une ville que sur l\'emplacement d\'une colonie',self.mappe._ajouterOccupationInitiale,14,Occupation.VILLE,1)
        print "Test - Ajout ville 1"


    def testAjoutVille2(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.assertRaisesRegexp(RuntimeError,'On ne peut construire une ville sur un emplacement occupé par un autre joueur',self.mappe._ajouterOccupationInitiale,23,Occupation.VILLE,2)
        print "Test - Ajout ville 2"

    def testAjoutVille3(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.mappe._ajouterOccupationInitiale(23,Occupation.VILLE,1)
        self.assertEqual(self.mappe.obtenirIntersection(23).afficherOccupation(),'V1') 
        print "Test - Ajout ville 3"

    def testAjoutVille4(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.mappe._ajouterOccupationInitiale(23,Occupation.VILLE,1)
        self.assertRaisesRegexp(RuntimeError,'Il y a déjà une ville à l\'emplacement spécifié',self.mappe._ajouterOccupationInitiale,23,Occupation.VILLE,2)
        print "Test - Ajout ville 4"

    def testAjoutRoute1(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.mappe._ajouterRoute(23,24,1)
        self.mappe._ajouterRoute(25,24,1)
        self.assertTrue(self.mappe.joueurPossedeRoute(24,25,1))
        print "Test - Ajouter route 1"
        
    def testAjoutRoute2(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.mappe._ajouterRoute(23,24,1)
        self.assertRaisesRegexp(RuntimeError,'Le joueur 1 ne peut pas construire une route à cet endroit',self.mappe._ajouterRoute,18,19,1)
        print "Test - Ajouter route 2"

    def testAjoutRoute3(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.mappe._ajouterRoute(23,24,1)
        self.assertRaisesRegexp(RuntimeError,'Le joueur 2 ne peut pas construire une route à cet endroit',self.mappe._ajouterRoute,24,25,2)
        print "Test - Ajouter route 3"

    def testPeutConstruireOccupation1(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.mappe._ajouterRoute(23,24,1)
        self.assertRaisesRegexp(RuntimeError,'Une intersection voisine est déjà occupée',self.mappe._ajouterOccupation,24,Occupation.COLONIE,1)
        print "Test - Peut contruire occupation 1"

    def testPeutConstruireOccupation2(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.mappe._ajouterRoute(23,24,1)
        self.assertRaisesRegexp(RuntimeError,'Une intersection voisine est déjà occupée',self.mappe._ajouterOccupation,25,Occupation.COLONIE,1)
        print "Test - Peut contruire occupation 2"

    def testPeutConstruireOccupation3(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.mappe._ajouterRoute(23,24,1)
        self.assertRaisesRegexp(RuntimeError,'Une intersection voisine est déjà occupée',self.mappe._ajouterOccupation,25,Occupation.COLONIE,2)
        print "Test - Peut contruire occupation 3"

    def testPeutConstruireOccupation4(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.mappe._ajouterRoute(23,24,1)
        self.mappe._ajouterRoute(24,25,1)
        self.mappe._ajouterOccupation(25,Occupation.COLONIE,1)
        self.assertTrue(self.mappe.obtenirIntersection(25).occupe())
        print "Test - Peut construire occupation 4"

    def testPeutConstruireOccupation5(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.mappe._ajouterOccupationInitiale(33,Occupation.COLONIE,1)
        self.mappe._ajouterOccupationInitiale(35,Occupation.COLONIE,1)
        self.assertRaisesRegexp(RuntimeError,'Une intersection voisine est déjà occupée',self.mappe._ajouterOccupation,34,Occupation.COLONIE,2)
        print "Test - Peut construire occupation 5"


    def testCheminPlusLong1(self):
        self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
        self.mappe._ajouterOccupationInitiale(12,Occupation.COLONIE,2)
        self.mappe._ajouterOccupationInitiale(43,Occupation.COLONIE,2)

        self.mappe._ajouterRoute(23,24,1)
        self.mappe._ajouterRoute(24,25,1)
        self.mappe._ajouterRoute(25,36,1)
        self.mappe._ajouterRoute(36,37,1)
        self.mappe._ajouterRoute(37,38,1)
        self.mappe._ajouterRoute(38,27,1)
        self.mappe._ajouterRoute(37,47,1)
        self.mappe._ajouterRoute(26,27,1)
        self.mappe._ajouterRoute(26,25,1)
        self.mappe._ajouterRoute(16,26,1)
        self.mappe._ajouterRoute(15,16,1)
        
        self.mappe._ajouterRoute(43,44,2)
        self.mappe._ajouterRoute(52,44,2)
        self.mappe._ajouterRoute(12,13,2)
        
        self.mappe._ajouterOccupation(38,Occupation.COLONIE,1)
        self.mappe._ajouterOccupation(43,Occupation.VILLE,2)

        self.assertEqual(self.mappe.cheminPlusLong(1), 9)
        self.assertEqual(self.mappe.cheminPlusLong(2), 2)

        print "Test - Chemin plus long 1"

    def testCheminPlusLong2(self):
        self.mappe._ajouterOccupationInitiale(12,Occupation.COLONIE,2)
        self.mappe._ajouterOccupationInitiale(43,Occupation.COLONIE,2)

        self.mappe._ajouterRoute(43,44,2)
        self.mappe._ajouterRoute(52,44,2)
        self.mappe._ajouterRoute(45,44,2)
        self.mappe._ajouterRoute(45,46,2)
        self.mappe._ajouterRoute(12,13,2)
        
        self.assertEqual(self.mappe.cheminPlusLong(2), 3)

        print "Test - Chemin plus long 2"

    def testCheminPlusLong3(self):
        self.mappe._ajouterOccupationInitiale(12,Occupation.COLONIE,2)
        self.mappe._ajouterOccupationInitiale(43,Occupation.COLONIE,2)

        self.mappe._ajouterRoute(43,44,2)
        self.mappe._ajouterRoute(52,44,2)
        self.mappe._ajouterRoute(45,44,2)
        self.mappe._ajouterRoute(45,46,2)
        self.mappe._ajouterRoute(12,13,2)
        self.mappe._ajouterRoute(12,22,2)
        self.mappe._ajouterRoute(21,22,2)
        
        self.assertEqual(self.mappe.cheminPlusLong(2), 3)

        print "Test - Chemin plus long 3"


    def testCheminPlusLong4(self):
        self.mappe._ajouterOccupationInitiale(12,Occupation.COLONIE,2)
        self.mappe._ajouterOccupationInitiale(43,Occupation.COLONIE,2)

        self.mappe._ajouterRoute(43,44,2)
        self.mappe._ajouterRoute(52,44,2)
        self.mappe._ajouterRoute(45,44,2)
        self.mappe._ajouterRoute(45,46,2)
        self.mappe._ajouterRoute(12,13,2)
        self.mappe._ajouterRoute(12,22,2)
        self.mappe._ajouterRoute(21,22,2)
        self.mappe._ajouterRoute(5,13,2)
        
        self.assertEqual(self.mappe.cheminPlusLong(2), 4)

        print "Test - Chemin plus long 4"


    def testVoleurs1(self):
        t = self.mappe.obtenirTerritoireContenantVoleurs()
        self.assertTrue(isinstance(t,Desert))
        print "Test - Voleurs 1"

    def testVoleurs3(self):
        typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
        self.mappe = Mappe(typesTerritoires)
        self.mappe._deplacerVoleurs(7)
        t = self.mappe.obtenirTerritoireContenantVoleurs()
        self.assertEqual(t.id(),7)
        print "Test - Voleurs 3"


    def testVoleurs4(self):
        typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
        self.mappe = Mappe(typesTerritoires)
        self.mappe._deplacerVoleurs(10)
        self.assertRaisesRegexp(RuntimeError,'On ne peut pas déplacer les voleurs dans le territoire où ils se trouvent déjà',self.mappe._deplacerVoleurs,10)
        print "Test - Voleurs 4"

    def testVoleurs5(self):
        typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
        self.mappe = Mappe(typesTerritoires)
        self.mappe._deplacerVoleurs(5)
        self.mappe._deplacerVoleurs(18)
        t = self.mappe.obtenirTerritoireContenantVoleurs()
        self.assertEqual(t.id(),18)
        print "Test - Voleurs 5"
        #self.mappe.afficher()

        
    def testDistribuerRessources1(self):
        typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
        self.mappe = Mappe(typesTerritoires)
        self.mappe._ajouterOccupationInitiale(12,Occupation.COLONIE,1)       
        ressources = self.mappe._distribuerRessources(2)
        self.assertEqual(ressources[(1,Ressource.BLE)],1)
        print "Test - Distribuer ressources 1"

    def testDistribuerRessources2(self):
        typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
        self.mappe = Mappe(typesTerritoires)
        self.mappe._ajouterOccupationInitiale(24,Occupation.COLONIE,1)
        self.mappe._deplacerVoleurs(7)
        ressources = self.mappe._distribuerRessources(3)
        self.assertEqual(len(ressources),0)
        print "Test - Distribuer ressources 2"


    def testDistribuerRessources3(self):
        typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
        self.mappe = Mappe(typesTerritoires)
        self.mappe._ajouterOccupationInitiale(24,Occupation.COLONIE,1)
        self.mappe._ajouterOccupationInitiale(24,Occupation.VILLE,1)
        ressources = self.mappe._distribuerRessources(3)
        self.assertEqual(ressources[(1,Ressource.BOIS)],2)
        print "Test - Distribuer ressources 3"

    def testDistribuerRessources4(self):
        typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
        self.mappe = Mappe(typesTerritoires)
        self.mappe._ajouterOccupationInitiale(24,Occupation.COLONIE,1)
        self.mappe._ajouterOccupationInitiale(24,Occupation.VILLE,1)
        self.mappe._ajouterOccupationInitiale(16,Occupation.COLONIE,1)
        ressources = self.mappe._distribuerRessources(3)
        self.assertEqual(ressources[(1,Ressource.BOIS)],3)
        print "Test - Distribuer ressources 4"

    def testDistribuerRessources5(self):
        typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
        self.mappe = Mappe(typesTerritoires)
        self.mappe._ajouterOccupationInitiale(24,Occupation.COLONIE,1)
        self.mappe._ajouterOccupationInitiale(24,Occupation.VILLE,1)
        self.mappe._ajouterOccupationInitiale(16,Occupation.COLONIE,2)
        ressources = self.mappe._distribuerRessources(3)
        self.assertEqual(ressources[(1,Ressource.BOIS)],2)
        self.assertEqual(ressources[(2,Ressource.BOIS)],1)
        print "Test - Distribuer ressources 5"


    def testDistribuerRessources6(self):
        typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
        self.mappe = Mappe(typesTerritoires)
        self.mappe._ajouterOccupationInitiale(19,Occupation.COLONIE,1)
        self.mappe._ajouterOccupationInitiale(19,Occupation.VILLE,1)
        self.mappe._ajouterOccupationInitiale(37,Occupation.COLONIE,2)
        ressources = self.mappe._distribuerRessources(8)
        self.assertEqual(ressources[(1,Ressource.BLE)],2)
        self.assertEqual(ressources[(2,Ressource.LAINE)],1)
        print "Test - Distribuer ressources 6"

    def testDistribuerRessources7(self):
        typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
        self.mappe = Mappe(typesTerritoires)
        self.mappe._ajouterOccupationInitiale(19,Occupation.COLONIE,1)
        self.mappe._ajouterOccupationInitiale(19,Occupation.VILLE,1)
        self.mappe._ajouterOccupationInitiale(26,Occupation.COLONIE,1)
        self.mappe._ajouterOccupationInitiale(37,Occupation.COLONIE,2)
        ressources = self.mappe._distribuerRessources(8)
        self.assertEqual(ressources[(1,Ressource.BLE)],2)
        self.assertEqual(ressources[(1,Ressource.LAINE)],1)
        self.assertEqual(ressources[(2,Ressource.LAINE)],1)
        print "Test - Distribuer ressources 7"
Exemple #4
0
class TestPrincipal(unittest.TestCase):
    def setUp(self):
        self.mappe = Mappe()

    def tearDown(self):
        pass
        #self.mappe.afficher()

    def testAjouterOccupationInitiale1(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.assertTrue(self.mappe.obtenirIntersection(23).occupe())
        self.assertFalse(self.mappe.joueurPossedeRoute(23, 24, 1))
        print "Test - Occupation initiale 1"

    def testAjouterOccupationInitiale2(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.mappe._ajouterRoute(23, 24, 1)
        self.assertTrue(self.mappe.obtenirIntersection(23).occupe())
        self.assertTrue(self.mappe.joueurPossedeRoute(23, 24, 1))
        print "Test - Occupation initiale 2"

    def testAjouterOccupationInitiale3(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.mappe._ajouterRoute(23, 24, 1)
        self.assertRaisesRegexp(
            RuntimeError, 'Une intersection voisine est déjà occupée',
            self.mappe._ajouterOccupationInitiale, 22, Occupation.COLONIE, 2)
        print "Test - Occupation initiale 3"

    def testAjoutColonie(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.assertRaisesRegexp(RuntimeError, 'Emplacement déjà occupé',
                                self.mappe._ajouterOccupationInitiale, 23,
                                Occupation.COLONIE, 1)
        print "Test- Ajout colonie"

    def testAjoutVille1(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.mappe._ajouterRoute(23, 24, 1)
        self.mappe._ajouterRoute(14, 24, 1)
        self.assertRaisesRegexp(
            RuntimeError,
            'On ne peut construire une ville que sur l\'emplacement d\'une colonie',
            self.mappe._ajouterOccupationInitiale, 14, Occupation.VILLE, 1)
        print "Test - Ajout ville 1"

    def testAjoutVille2(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.assertRaisesRegexp(
            RuntimeError,
            'On ne peut construire une ville sur un emplacement occupé par un autre joueur',
            self.mappe._ajouterOccupationInitiale, 23, Occupation.VILLE, 2)
        print "Test - Ajout ville 2"

    def testAjoutVille3(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.mappe._ajouterOccupationInitiale(23, Occupation.VILLE, 1)
        self.assertEqual(
            self.mappe.obtenirIntersection(23).afficherOccupation(), 'V1')
        print "Test - Ajout ville 3"

    def testAjoutVille4(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.mappe._ajouterOccupationInitiale(23, Occupation.VILLE, 1)
        self.assertRaisesRegexp(
            RuntimeError,
            'Il y a déjà une ville à l\'emplacement spécifié',
            self.mappe._ajouterOccupationInitiale, 23, Occupation.VILLE, 2)
        print "Test - Ajout ville 4"

    def testAjoutRoute1(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.mappe._ajouterRoute(23, 24, 1)
        self.mappe._ajouterRoute(25, 24, 1)
        self.assertTrue(self.mappe.joueurPossedeRoute(24, 25, 1))
        print "Test - Ajouter route 1"

    def testAjoutRoute2(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.mappe._ajouterRoute(23, 24, 1)
        self.assertRaisesRegexp(
            RuntimeError,
            'Le joueur 1 ne peut pas construire une route à cet endroit',
            self.mappe._ajouterRoute, 18, 19, 1)
        print "Test - Ajouter route 2"

    def testAjoutRoute3(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.mappe._ajouterRoute(23, 24, 1)
        self.assertRaisesRegexp(
            RuntimeError,
            'Le joueur 2 ne peut pas construire une route à cet endroit',
            self.mappe._ajouterRoute, 24, 25, 2)
        print "Test - Ajouter route 3"

    def testPeutConstruireOccupation1(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.mappe._ajouterRoute(23, 24, 1)
        self.assertRaisesRegexp(
            RuntimeError, 'Une intersection voisine est déjà occupée',
            self.mappe._ajouterOccupation, 24, Occupation.COLONIE, 1)
        print "Test - Peut contruire occupation 1"

    def testPeutConstruireOccupation2(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.mappe._ajouterRoute(23, 24, 1)
        self.assertRaisesRegexp(
            RuntimeError, 'Une intersection voisine est déjà occupée',
            self.mappe._ajouterOccupation, 25, Occupation.COLONIE, 1)
        print "Test - Peut contruire occupation 2"

    def testPeutConstruireOccupation3(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.mappe._ajouterRoute(23, 24, 1)
        self.assertRaisesRegexp(
            RuntimeError, 'Une intersection voisine est déjà occupée',
            self.mappe._ajouterOccupation, 25, Occupation.COLONIE, 2)
        print "Test - Peut contruire occupation 3"

    def testPeutConstruireOccupation4(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.mappe._ajouterRoute(23, 24, 1)
        self.mappe._ajouterRoute(24, 25, 1)
        self.mappe._ajouterOccupation(25, Occupation.COLONIE, 1)
        self.assertTrue(self.mappe.obtenirIntersection(25).occupe())
        print "Test - Peut construire occupation 4"

    def testPeutConstruireOccupation5(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.mappe._ajouterOccupationInitiale(33, Occupation.COLONIE, 1)
        self.mappe._ajouterOccupationInitiale(35, Occupation.COLONIE, 1)
        self.assertRaisesRegexp(
            RuntimeError, 'Une intersection voisine est déjà occupée',
            self.mappe._ajouterOccupation, 34, Occupation.COLONIE, 2)
        print "Test - Peut construire occupation 5"

    def testCheminPlusLong1(self):
        self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
        self.mappe._ajouterOccupationInitiale(12, Occupation.COLONIE, 2)
        self.mappe._ajouterOccupationInitiale(43, Occupation.COLONIE, 2)

        self.mappe._ajouterRoute(23, 24, 1)
        self.mappe._ajouterRoute(24, 25, 1)
        self.mappe._ajouterRoute(25, 36, 1)
        self.mappe._ajouterRoute(36, 37, 1)
        self.mappe._ajouterRoute(37, 38, 1)
        self.mappe._ajouterRoute(38, 27, 1)
        self.mappe._ajouterRoute(37, 47, 1)
        self.mappe._ajouterRoute(26, 27, 1)
        self.mappe._ajouterRoute(26, 25, 1)
        self.mappe._ajouterRoute(16, 26, 1)
        self.mappe._ajouterRoute(15, 16, 1)

        self.mappe._ajouterRoute(43, 44, 2)
        self.mappe._ajouterRoute(52, 44, 2)
        self.mappe._ajouterRoute(12, 13, 2)

        self.mappe._ajouterOccupation(38, Occupation.COLONIE, 1)
        self.mappe._ajouterOccupation(43, Occupation.VILLE, 2)

        self.assertEqual(self.mappe.cheminPlusLong(1), 9)
        self.assertEqual(self.mappe.cheminPlusLong(2), 2)

        print "Test - Chemin plus long 1"

    def testCheminPlusLong2(self):
        self.mappe._ajouterOccupationInitiale(12, Occupation.COLONIE, 2)
        self.mappe._ajouterOccupationInitiale(43, Occupation.COLONIE, 2)

        self.mappe._ajouterRoute(43, 44, 2)
        self.mappe._ajouterRoute(52, 44, 2)
        self.mappe._ajouterRoute(45, 44, 2)
        self.mappe._ajouterRoute(45, 46, 2)
        self.mappe._ajouterRoute(12, 13, 2)

        self.assertEqual(self.mappe.cheminPlusLong(2), 3)

        print "Test - Chemin plus long 2"

    def testCheminPlusLong3(self):
        self.mappe._ajouterOccupationInitiale(12, Occupation.COLONIE, 2)
        self.mappe._ajouterOccupationInitiale(43, Occupation.COLONIE, 2)

        self.mappe._ajouterRoute(43, 44, 2)
        self.mappe._ajouterRoute(52, 44, 2)
        self.mappe._ajouterRoute(45, 44, 2)
        self.mappe._ajouterRoute(45, 46, 2)
        self.mappe._ajouterRoute(12, 13, 2)
        self.mappe._ajouterRoute(12, 22, 2)
        self.mappe._ajouterRoute(21, 22, 2)

        self.assertEqual(self.mappe.cheminPlusLong(2), 3)

        print "Test - Chemin plus long 3"

    def testCheminPlusLong4(self):
        self.mappe._ajouterOccupationInitiale(12, Occupation.COLONIE, 2)
        self.mappe._ajouterOccupationInitiale(43, Occupation.COLONIE, 2)

        self.mappe._ajouterRoute(43, 44, 2)
        self.mappe._ajouterRoute(52, 44, 2)
        self.mappe._ajouterRoute(45, 44, 2)
        self.mappe._ajouterRoute(45, 46, 2)
        self.mappe._ajouterRoute(12, 13, 2)
        self.mappe._ajouterRoute(12, 22, 2)
        self.mappe._ajouterRoute(21, 22, 2)
        self.mappe._ajouterRoute(5, 13, 2)

        self.assertEqual(self.mappe.cheminPlusLong(2), 4)

        print "Test - Chemin plus long 4"

    def testVoleurs1(self):
        t = self.mappe.obtenirTerritoireContenantVoleurs()
        self.assertTrue(isinstance(t, Desert))
        print "Test - Voleurs 1"

    def testVoleurs3(self):
        typesTerritoires = [
            'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
            'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
            'montagne', 'colline', 'colline', 'colline', 'desert'
        ]
        self.mappe = Mappe(typesTerritoires)
        self.mappe._deplacerVoleurs(7)
        t = self.mappe.obtenirTerritoireContenantVoleurs()
        self.assertEqual(t.id(), 7)
        print "Test - Voleurs 3"

    def testVoleurs4(self):
        typesTerritoires = [
            'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
            'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
            'montagne', 'colline', 'colline', 'colline', 'desert'
        ]
        self.mappe = Mappe(typesTerritoires)
        self.mappe._deplacerVoleurs(10)
        self.assertRaisesRegexp(
            RuntimeError,
            'On ne peut pas déplacer les voleurs dans le territoire où ils se trouvent déjà',
            self.mappe._deplacerVoleurs, 10)
        print "Test - Voleurs 4"

    def testVoleurs5(self):
        typesTerritoires = [
            'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
            'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
            'montagne', 'colline', 'colline', 'colline', 'desert'
        ]
        self.mappe = Mappe(typesTerritoires)
        self.mappe._deplacerVoleurs(5)
        self.mappe._deplacerVoleurs(18)
        t = self.mappe.obtenirTerritoireContenantVoleurs()
        self.assertEqual(t.id(), 18)
        print "Test - Voleurs 5"
        #self.mappe.afficher()

    def testDistribuerRessources1(self):
        typesTerritoires = [
            'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
            'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
            'montagne', 'colline', 'colline', 'colline', 'desert'
        ]
        self.mappe = Mappe(typesTerritoires)
        self.mappe._ajouterOccupationInitiale(12, Occupation.COLONIE, 1)
        ressources = self.mappe._distribuerRessources(2)
        self.assertEqual(ressources[(1, Ressource.BLE)], 1)
        print "Test - Distribuer ressources 1"

    def testDistribuerRessources2(self):
        typesTerritoires = [
            'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
            'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
            'montagne', 'colline', 'colline', 'colline', 'desert'
        ]
        self.mappe = Mappe(typesTerritoires)
        self.mappe._ajouterOccupationInitiale(24, Occupation.COLONIE, 1)
        self.mappe._deplacerVoleurs(7)
        ressources = self.mappe._distribuerRessources(3)
        self.assertEqual(len(ressources), 0)
        print "Test - Distribuer ressources 2"

    def testDistribuerRessources3(self):
        typesTerritoires = [
            'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
            'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
            'montagne', 'colline', 'colline', 'colline', 'desert'
        ]
        self.mappe = Mappe(typesTerritoires)
        self.mappe._ajouterOccupationInitiale(24, Occupation.COLONIE, 1)
        self.mappe._ajouterOccupationInitiale(24, Occupation.VILLE, 1)
        ressources = self.mappe._distribuerRessources(3)
        self.assertEqual(ressources[(1, Ressource.BOIS)], 2)
        print "Test - Distribuer ressources 3"

    def testDistribuerRessources4(self):
        typesTerritoires = [
            'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
            'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
            'montagne', 'colline', 'colline', 'colline', 'desert'
        ]
        self.mappe = Mappe(typesTerritoires)
        self.mappe._ajouterOccupationInitiale(24, Occupation.COLONIE, 1)
        self.mappe._ajouterOccupationInitiale(24, Occupation.VILLE, 1)
        self.mappe._ajouterOccupationInitiale(16, Occupation.COLONIE, 1)
        ressources = self.mappe._distribuerRessources(3)
        self.assertEqual(ressources[(1, Ressource.BOIS)], 3)
        print "Test - Distribuer ressources 4"

    def testDistribuerRessources5(self):
        typesTerritoires = [
            'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
            'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
            'montagne', 'colline', 'colline', 'colline', 'desert'
        ]
        self.mappe = Mappe(typesTerritoires)
        self.mappe._ajouterOccupationInitiale(24, Occupation.COLONIE, 1)
        self.mappe._ajouterOccupationInitiale(24, Occupation.VILLE, 1)
        self.mappe._ajouterOccupationInitiale(16, Occupation.COLONIE, 2)
        ressources = self.mappe._distribuerRessources(3)
        self.assertEqual(ressources[(1, Ressource.BOIS)], 2)
        self.assertEqual(ressources[(2, Ressource.BOIS)], 1)
        print "Test - Distribuer ressources 5"

    def testDistribuerRessources6(self):
        typesTerritoires = [
            'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
            'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
            'montagne', 'colline', 'colline', 'colline', 'desert'
        ]
        self.mappe = Mappe(typesTerritoires)
        self.mappe._ajouterOccupationInitiale(19, Occupation.COLONIE, 1)
        self.mappe._ajouterOccupationInitiale(19, Occupation.VILLE, 1)
        self.mappe._ajouterOccupationInitiale(37, Occupation.COLONIE, 2)
        ressources = self.mappe._distribuerRessources(8)
        self.assertEqual(ressources[(1, Ressource.BLE)], 2)
        self.assertEqual(ressources[(2, Ressource.LAINE)], 1)
        print "Test - Distribuer ressources 6"

    def testDistribuerRessources7(self):
        typesTerritoires = [
            'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
            'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
            'montagne', 'colline', 'colline', 'colline', 'desert'
        ]
        self.mappe = Mappe(typesTerritoires)
        self.mappe._ajouterOccupationInitiale(19, Occupation.COLONIE, 1)
        self.mappe._ajouterOccupationInitiale(19, Occupation.VILLE, 1)
        self.mappe._ajouterOccupationInitiale(26, Occupation.COLONIE, 1)
        self.mappe._ajouterOccupationInitiale(37, Occupation.COLONIE, 2)
        ressources = self.mappe._distribuerRessources(8)
        self.assertEqual(ressources[(1, Ressource.BLE)], 2)
        self.assertEqual(ressources[(1, Ressource.LAINE)], 1)
        self.assertEqual(ressources[(2, Ressource.LAINE)], 1)
        print "Test - Distribuer ressources 7"