Esempio n. 1
0
    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))
Esempio n. 2
0
 def loadPhrase(self, screen, screenSize):
     Cartes.aleaPhrase()
     pygame.draw.rect(
         screen, (0, 0, 0),
         (screenSize[0] / 2 - 120, screenSize[1] / 2 - 160, 240, 320), 0,
         15)
     screen.blit(self.loadText(24, self.phrase[0]),
                 (screenSize[0] / 2 - 160, screenSize[1] / 2))
Esempio n. 3
0
 def loadMots(self, screen, screenSize, deck):
     Cartes.aleaMots()
     if self.selectionGagnant:
         pygame.draw.rect(
             screen, (255, 255, 255),
             (screenSize[0] / 2 - 390, screenSize[1] / 2 + 240, 240, 320),
             0, 10)
         pygame.draw.rect(
             screen, (255, 255, 255),
             (screenSize[0] / 2 - 120, screenSize[1] / 2 + 240, 240, 320),
             0, 10)
         pygame.draw.rect(
             screen, (255, 255, 255),
             (screenSize[0] / 2 + 150, screenSize[1] / 2 + 240, 240, 320),
             0, 10)
         screen.blit(self.loadTextV2(24, self.choixPlayer1),
                     (screenSize[0] / 2 - 390, screenSize[1] / 2 + 240))
         screen.blit(self.loadTextV2(24, "Egalité"),
                     (screenSize[0] / 2 - 120, screenSize[1] / 2 + 240))
         screen.blit(self.loadTextV2(24, self.choixPlayer2),
                     (screenSize[0] / 2 + 150, screenSize[1] / 2 + 240))
     else:
         i = 0
         dispoMots = [
             (screenSize[0] * 1 / 36, screenSize[1] - screenSize[1] / 8),
             (screenSize[0] * 8 / 36, screenSize[1] - screenSize[1] / 8),
             (screenSize[0] * 5 / 12, screenSize[1] - screenSize[1] / 8),
             (screenSize[0] * 22 / 36, screenSize[1] - screenSize[1] / 8),
             (screenSize[0] * 29 / 36, screenSize[1] - screenSize[1] / 8)
         ]
         pygame.draw.rect(screen, (255, 255, 255),
                          (screenSize[0] * 1 / 36, screenSize[1] -
                           screenSize[1] / 8, screenSize[0] / 6, 320), 0,
                          10)
         pygame.draw.rect(screen, (255, 255, 255),
                          (screenSize[0] * 8 / 36, screenSize[1] -
                           screenSize[1] / 8, screenSize[0] / 6, 320), 0,
                          10)
         pygame.draw.rect(screen, (255, 255, 255),
                          (screenSize[0] * 5 / 12, screenSize[1] -
                           screenSize[1] / 8, screenSize[0] / 6, 320), 0,
                          10)
         pygame.draw.rect(screen, (255, 255, 255),
                          (screenSize[0] * 22 / 36, screenSize[1] -
                           screenSize[1] / 8, screenSize[0] / 6, 320), 0,
                          10)
         pygame.draw.rect(screen, (255, 255, 255),
                          (screenSize[0] * 29 / 36, screenSize[1] -
                           screenSize[1] / 8, screenSize[0] / 6, 320), 0,
                          10)
         for mots in deck:
             screen.blit(self.loadTextV2(24, mots), dispoMots[i])
             i += 1
Esempio n. 4
0
    def crearCartes():  # crear totes les cartes de poker

        cartes = []

        for x in range(1, 13):
            cartes.append(Cartes(
                "Picas",
                x))  # es crea un objecte Cartes amb un string i un numero
        for x in range(1, 13):
            cartes.append(Cartes("Corazones", x))
        for x in range(1, 13):
            cartes.append(Cartes("Diamantes", x))
        for x in range(1, 13):
            cartes.append(Cartes("Treboles", x))

        return cartes  # retorna una llista amb totes les cartes
Esempio n. 5
0
    def __init__(self,
                 plateau=p.Plateau(),
                 pioche=[Cartes.Carte() for i in range(9)],
                 nbJoueurs=1):
        """
        Initialise le jeu.
        1 - Recupère le plateau de jeu
        2 - Recupère les cartes de la pioche
        3 - Cree les joueurs avec la methode definie dans Joueur.py
        4 - Verifie que toutes les variables sont bien instanciees
        Paramètres
        ----------
        plateau: le plateau de jeu pour la partie
        pioche: une liste de cartes
        """

        self.plateau = plateau
        self.pioche = pioche
        self.step = 0
        self.__finSequence = False
        self.__hasPicked = False  #est-ce que l'humain a pioché correctement?

        #        nbJoueurs = int(input("Nombre de joueurs?"))
        self.nbJoueurs = nbJoueurs

        self.listeJoueurs = [j.creerJoueur(i) for i in range(nbJoueurs)]

        for joueur in self.listeJoueurs:
            joueur.murs = self.plateau.listeMurs
Esempio n. 6
0
    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))
Esempio n. 7
0
    plateau.ajouterMur(mur)
    mur = Murs.MurVertical((plateau.x - 1, y), (plateau.x, y))
    plateau.ajouterMur(mur)

for x in range(0, plateau.x, 1):
    mur = Murs.MurHorizontal((x, -1), (x, 0))
    plateau.ajouterMur(mur)
    mur = Murs.MurHorizontal((x, plateau.y - 1), (x, plateau.y))
    plateau.ajouterMur(mur)

nombreJoueurs = 2
plateau.nombreJoueurs = nombreJoueurs

# Pour ce tableau, le robot doit commencer à la position O,1 avec une orientation de 0

listeCartes = [
    Cartes.Translation(1),
    Cartes.Translation(2),
    Cartes.Translation(3),
    Cartes.Translation(1),
    Cartes.Translation(2),
    Cartes.Translation(1),
    Cartes.Translation(-1),
    Cartes.Translation(-1),
    Cartes.Rotation(1),
    Cartes.Rotation(3),
    Cartes.Rotation(2),
    Cartes.Rotation(1),
    Cartes.Rotation(3),
    Cartes.Rotation(2)
]
Esempio n. 8
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
Esempio n. 9
0
    """
    renvoie la distance entre A et B
    """
    xa, ya = A
    xb, yb = B
    return scalaire((xa - xb, ya - yb), (xa - xb, ya - yb))


#Pour faire quelques tests:
if __name__ == "__main__":
    import Cartes
    import plateau3
    p = plateau3.plateau
    p.prepare()
    state = (9, 3, 0, 0)
    carte = Cartes.Translation(-1)
    print('carte', carte)
    print('départ', state, 'arrivée', estimatedStateCarte(state, carte, p))
    #    print(p.m0)
    #    print(estimatedStateCarte(state,carte, p))

    #    listeCartes = [Cartes.Translation(1), Cartes.Translation(2),Cartes.Translation(3),
    #               Cartes.Translation(1), Cartes.Translation(2),Cartes.Translation(1),
    #               Cartes.Translation(1), Cartes.Translation(2),Cartes.Translation(1),
    #               Cartes.Rotation(1), Cartes.Rotation(3),Cartes.Rotation(2)]
    #
    #    listeCartes = [Cartes.Translation(2),Cartes.Translation(3),
    #               Cartes.Rotation(3), Cartes.Rotation(3),Cartes.Rotation(2)]
    #
    listeCartes = [
        Cartes.Rotation(2),
Esempio n. 10
0
    caseCopy2=case.copy(None,platy-case.position[1], -1)
    plateau.mettreCase(caseCopy2)
    caseCopy3=case.copy(platx-case.position[0],platy-case.position[1])
    plateau.mettreCase(caseCopy3)
    
#robot1_start = (5,2)   # A ajouter dans le code

#mise en place des murs autour du plateau
for y in range(0,plateau.y,1):
    mur = Murs.MurVertical((-1,y),(0,y))
    plateau.ajouterMur(mur)
    mur = Murs.MurVertical((plateau.x-1,y),(plateau.x,y))
    plateau.ajouterMur(mur)

for x in range(0,plateau.x,1):
    mur = Murs.MurHorizontal((x,-1),(x,0))
    plateau.ajouterMur(mur)
    mur = Murs.MurHorizontal((x,plateau.y-1),(x,plateau.y))
    plateau.ajouterMur(mur)




# Pour ce tableau, le robot doit commencer à la position O,1 avec une orientation de 0


listeCartes = [Cartes.Translation(1), Cartes.Translation(2),Cartes.Translation(3),
               Cartes.Translation(1), Cartes.Translation(2),Cartes.Translation(1),
               Cartes.Translation(-1), Cartes.Translation(-1),
               Cartes.Rotation(1), Cartes.Rotation(3),Cartes.Rotation(2),
               Cartes.Rotation(1), Cartes.Rotation(3),Cartes.Rotation(2)]
Esempio n. 11
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