Restructuration terminee - de nombreux bugs a regler

lib/AEtoile.py

@@ -32,7 +32,7 @@ def chemin(plateau, origine, cible):
     #on continue jusqu'a tomber sur la case cible, ou jusqu'a un echec
     while position.coord != cible and not echec:
         it += 1
-        print "##", it, position.coord
+##        print "##", it, position.coord
         
         #on etudie tous les voisins de la case en cours
         for coord in plateau.cases[position.coord].voisins:
@@ -61,11 +61,11 @@ def chemin(plateau, origine, cible):
                                 nTest.parent = noeud.parent
                                 nTest.cout = noeud.cout
                                 trouve = True
-                                print " | teste", coord, "maj", noeud.coutG**2, noeud.coutH, noeud.cout
+##                                print " | teste", coord, "maj", noeud.coutG**2, noeud.coutH, noeud.cout
                             
                     if not trouve:
                         filOuvert.append(noeud)
-                        print " | teste", coord, "ajout", noeud.coutG**2, noeud.coutH, noeud.cout
+##                        print " | teste", coord, "ajout", noeud.coutG**2, noeud.coutH, noeud.cout
 
         #on parcourt les noeuds de la liste ouverte
         #et on cherche le meilleur noeud (le cout le plus faible)
@@ -79,7 +79,7 @@ def chemin(plateau, origine, cible):
             else:
                 if noeud.cout < meilleur.cout:
                     meilleur = noeud
-        print " >> retenu", meilleur.coord, meilleur.cout
+##        print " >> retenu", meilleur.coord, meilleur.cout
                 
         if meilleur:
             filFerme.append(meilleur)
@@ -93,7 +93,7 @@ def chemin(plateau, origine, cible):
         while position.coord != origine:
             chemin.insert(0, position.coord)
             position = position.parent
-            print "retour", position.coord
+##            print "retour", position.coord
             
     return chemin                    
                     

lib/Actions.py

@@ -1,38 +1,36 @@
 #from __future__ import unicode_literals
 # -*- coding: utf-8 -*-
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
 import regles
 import AEtoile
 
-class Action():
+class Action(object):
     """action effectuee par un combattant sur le plateau de jeu"""
     def __init__(self):
         self._num = None         #no du pion actif
         self._coordCible = None  #coord de la case ciblee par le curseur
         self._cible = None       #cible (case ou pion)
 
-
-    def activer(self, plateau):
+    def activer(self, plateau, numPion):
         self.plateau = plateau
+        self._num = numPion
         self.creerItemsGraphiques()
 
     def majCoordCible(self, coord):
         """met a jour les coordonnees de la cible,
             cad la case actuellement survolee par la souris"""
-        if self.plateau.estCoordonneeValide(coord):
+        if self.plateau.coordonneesValides(coord):
             self._coordCible = coord
             self.maj()
 
-##    def majCible(self, item):
-##        """met a jour la cible,
-##            (item actuellement actuellement survole par la souris)"""
-##        self._cible = item
-##        self.maj()
-
     def desactiver(self):
+        self.afficherCibles(False)
         self.detruireItemsGraphiques()
 
     def valider(self):
         #envoyer signal
+        self.envoiSignal()
         self.desactiver()
 
     def estValide(self):
@@ -64,26 +62,29 @@ class Action():
     def afficherCibles(self, actif):
         pass
 
+    #envoi du signal en cas de validation
+    def envoiSignal(self):
+        pass
 
 class Deplacement(Action):
     ### a completer avec des icones de deplacement,
     #la prise en compte de la nage et de l'escalade
     #et le calcul du cout de deplacement
     def __init__(self):
-        super(Deplacement, self).__init__(self)
+        super(Deplacement, self).__init__()
         self._chemin = []  #liste des coord des cases a traverser
         self._cout = 0     #cout en points de dep
 
-    def activer(self, plateau):
-        super(Deplacement, self).activer(self, plateau)
+    def valider(self):
+        if self.estValide():
+            super(Deplacement, self).valider()
 
-    def desactiver(self):
-        self.afficherCibles(False)
-        super(Deplacement, self).desactiver(self)
+    def estValide(self):
+        return len(self._chemin)>0
 
     def majCoordCible(self, coord):
         if coord != self.coordActeur():
-            super(Deplacement, self).majCoordCible(self, coord)
+            super(Deplacement, self).majCoordCible(coord)
 
     def maj(self):
         self.afficherCibles(False)
@@ -100,12 +101,17 @@ class Deplacement(Action):
     def afficherCibles(self, actif):
         for coord in self._chemin:
             self.plateau.cases[coord].majEstDansChampDeplacement(actif)
-            
+
+    def envoiSignal(self):
+        coutDep = 0
+        for coord in self._chemin:
+            cout += self.plateau.cases[coord].coutDep()
+        print "{}  s'est deplacé et a utilisé {} points de mouvement".format(self.acteur().txtId(), cout)
 
 class Attaque(Action):
     """attaque pre-parametree affectee a un pion, un personnage ou une creature"""
     def __init__(self):
-        super(Attaque, self).__init__(self)
+        super(Attaque, self).__init__()
         self.nom = "Attaque"
         self.portee = 1   #portee max en cases
         self.attributs = regles.listeAttributsAttaques()
@@ -116,20 +122,21 @@ class Attaque(Action):
 class Cac(Attaque):
     """attaque au corps a corps"""
     def __init__(self):
-        super(Cac, self).__init__(self)
+        super(Cac, self).__init__()
         self.nom = "Attaque au corps-à-corps"
         self._pionCible = None
 
-    def activer(self, plateau):
-        super(Deplacement, self).activer(self, plateau)
-
     def desactiver(self):
         self.afficherCibles(False)
-        super(Deplacement, self).desactiver(self)
+        super(Deplacement, self).desactiver()
+
+    def valider(self):
+        if self.estValide() and self._pionCible:
+            super(Cac, self).valider()
       
     def maj(self):
         self.afficherCibles(False)
-        pionCible = self_plateau.cases[self._coordCible].pionOccupant()
+        pionCible = self.plateau.cases[self._coordCible].pionOccupant()
         if pionCible != None and pionCible != self._plateau.pionSelectionne():
             self._pionCible = pionCible
         else:
@@ -143,34 +150,32 @@ class Cac(Attaque):
         if self._pionCible:
             self._pionCible.estCibleAttaque(actif, self.estValide())
 
+    def envoiSignal(self):
+        print "{} a attaqué {} au corps-à-corps".format(self.acteur().txtId(), self._pionCible.txtId())
 
 class Distance(Attaque):
     """attaque a distance"""
     def __init__(self):
-        super(Distance, self).__init__(self)
+        super(Distance, self).__init__()
         self.nom = "Attaque à distance"
         self._itemLigne = None
         self._pionCible = None
 
-    def activer(self, plateau):
-        #creation de la ligne de mire
-        super(Distance, self).activer(self, plateau)
-
     def majCoordCible(self, coord):
         if self._pionCible:
             self._pionCible.estCibleAttaque(False, self.estValide())
         if self._coordCible in self.plateau.cases:    
             self.plateau.cases[self._coordCible].majEstCibleCurseur(False)
-        super(Distance, self).majCoord(self, coord)        
-        
-    def desactiver(self):
-        super(Distance, self).desactiver(self)
+        super(Distance, self).majCoordCible(coord)        
+
+    def valider(self):
+        if self.estValide() and self._pionCible:
+            super(Distance, self).valider()
 
-        
     def maj(self):
         """met a jour la ligne de mire representant l'attaque a distance"""
         self.afficherCibles(False)
-        pionCible = self_plateau.cases[self._coordCible].pionOccupant()
+        pionCible = self.plateau.cases[self._coordCible].pionOccupant()
 
         self.majItemsGraphiques()
         if pionCible != None and pionCible != self._plateau.pionSelectionne():
@@ -188,7 +193,7 @@ class Distance(Attaque):
             self._pionCible.estCibleAttaque(actif, self.estValide())
         else:
             #si pas de pion vise, on affiche la case cible comme visee
-            self.plateau.cases[self._coordCible].majEstCibleCurseur(True, self.estValide())            
+            self.plateau.cases[self._coordCible].majEstCibleCurseur(actif, self.estValide())            
 
     def creerItemsGraphiques(self):
         self._itemLigne = QGraphicsLineItem()
@@ -206,19 +211,30 @@ class Distance(Attaque):
     def detruireItemsGraphiques(self):
         if self._itemLigne != None:
             self._itemLigne.prepareGeometryChange()
-            self.removeItem(self._itemLigne)
+            self.plateau.removeItem(self._itemLigne)
             self._itemLigne = None
 
+    def envoiSignal(self):
+        print "{} a attaqué {} a distance".format(self.acteur().txtId(), self._pionCible.txtId())
+
 
 class Zone(Attaque):
     """attaque de zone de base"""
     def __init__(self):
-        super(Zone, self).__init__(self)    
+        super(Zone, self).__init__()    
         self.nom = "Attaque de zone"
         self._itemLigne = None
         self._itemCible = None
         self._casesCibles = []
 
+    def valider(self):
+        if self.estValide() and len(self._casesCibles) > 0:
+            super(Zone, self).valider()
+
+    def desactiver(self):
+        self.afficherCibles(False)
+        self.detruireItemsGraphiques()
+
     def maj(self):
         """maj la forme de l'attaque de zone et les items cibles"""
         self.afficherCibles(False)
@@ -257,20 +273,25 @@ class Zone(Attaque):
     def detruireItemsGraphiques(self):
         if self._itemCible != None:
             self._itemCible.prepareGeometryChange()
-            self.removeItem(self._itemCible)
+            self.plateau.removeItem(self._itemCible)
             self._itemCible = None
 
         if self._itemLigne != None:
             self._itemLigne.prepareGeometryChange()
-            self.removeItem(self._itemLigne)
+            self.plateau.removeItem(self._itemLigne)
             self._itemLigne = None
 
-
+    def envoiSignal(self):
+        touches = ""
+        for pion in self.plateau.pionsSurListeCase(self._casesCibles):
+            touches += "{}, ".format(pion.txtId())
+        touches = touches[:-2]
+        print "{} a lancé une attaque de zone. Les pions suivants sont touches: \n {}".format(self.acteur().txtId(), touches)
 
 class Ligne(Attaque):
     """attaque de zone de forme lineaire"""
     def __init__(self):
-        super(Ligne, self).__init__(self)
+        super(Ligne, self).__init__()
         self.nom = "Attaque de zone: ligne"
 
     def majItemsGraphiques(self):
@@ -281,7 +302,7 @@ class Ligne(Attaque):
 class Disque(Attaque):
     """attaque de zone de forme circulaire"""
     def __init__(self):
-        super(Disque, self).__init__(self)
+        super(Disque, self).__init__()
         self.nom = "Attaque de zone: disque"
         self.rayon = 1
 
@@ -289,7 +310,7 @@ class Disque(Attaque):
         self._casesCibles = self.plateau.zone(self._coordCible, self.rayon, 0)
 
     def afficherCibles(self, actif):
-        super(Disque, self).afficherCibles(self, actif)
+        super(Disque, self).afficherCibles(actif)
         #si on affiche une attaque invalide
         if actif and not self.estValide():
             self.plateau.cases[self._coordCible].majEstCibleCurseur(True, False)
@@ -321,7 +342,7 @@ class Disque(Attaque):
 class Cone(Attaque):
     """attaque de zone de forme conique"""
     def __init__(self):
-        super(Cone, self).__init__(self)
+        super(Cone, self).__init__()
         self.nom = "Attaque de zone: cône"
 
     def creerItemsGraphiques(self):

lib/Case.py

@@ -250,6 +250,11 @@ class Case(QGraphicsPolygonItem):
                 retour = False
         return retour
 
+    def coutDep(self):
+        #a implementer, en fonction des
+        #capacites de deplacement du pion actuellement selectionne
+        return 1
+
     def estObstacleVision(self, hauteurObs):
         """renvoie vrai si la case et l'eventuel decor qui l'occupe bloquent le champ de
            vision d'un observateur situe a la hauteur precisee"""

lib/Modes.py

@@ -8,6 +8,7 @@ de maniere a produire un resultat unique (cases peintes, pion deplace...)"""
 from PyQt4.QtCore import *
 from PyQt4.QtGui import *
 from EntreeSortie import EntreeSortie
+import Actions
 import regles
 
 class ModeBase(object):
@@ -408,118 +409,59 @@ class StandardPi(ModeBasePi):
     def clic_combattant(self, num):
         self.plateau.activerMode(PionSelectionne, num)
 
+    def nouvelleAction(self, action):
+        pass
 
+    
 class PionSelectionne(ModeBasePi):
     """mode active a la selection d'un pion combattant"""
     def __init__(self, plateau):
         super(PionSelectionne, self).__init__(plateau)
         self._focus = True
         self._num = None
+        self._action = None
 
     def pion(self):
         """retourne la ref du pion actuellement selectionne"""
-        return self.plateau.combattants[self._num]
+        retour = None
+        if self._num in self.plateau.combattants:
+            retour = self.plateau.combattants[self._num]
+        return retour
 
     def activer(self, num):
         self._num = num
         #intensifie l'ombre du pion
         self.pion().afficheOmbreSelection(True)
-        
-        ### maj la selection dans la liste d'ordre de jeu
-        for i in range(0, self.plateau.fenetre.ui.inf_listeOrdreJeu.rowCount()):
-            if str(self.plateau.fenetre.ui.inf_listeOrdreJeu.item(i, 0).text().toUtf8()) == str(self._num):
-                self.plateau.fenetre.ui.inf_listeOrdreJeu.setCurrentCell(i,0)
-
-        ### maj des infos dans le panneau pi
-        self.plateau.fenetre.ui.pi_nom.majTexte(self.pion().txtId())
-        self.plateau.fenetre.ui.pi_img.chargerImage("img\\"+self.pion().img.nomFichier)
-
-        ### maj de la liste des attributs
-        self.plateau.fenetre.ui.pi_listeAttributs.setColumnWidth(0, 50)
-        self.plateau.disconnect(self.plateau.fenetre.ui.pi_listeAttributs, SIGNAL("cellChanged(int,int)"), self.plateau.listeAttributCelluleModifiee)
-        
-        #on vide la liste
-        while self.plateau.fenetre.ui.pi_listeAttributs.rowCount() > 0:
-            self.plateau.fenetre.ui.pi_listeAttributs.removeRow(0)
-
-        #creation des lignes de base    
-        lignesBase = ["Nom","Etat","Alt."]   #attention: modifier aussi dans listeAttributCelluleModifiee
-        for i in range(0, 10):    #10 premieres colonnes reservees pour les infos de base
-            self.plateau.fenetre.ui.pi_listeAttributs.insertRow(i)
-            item = QTableWidgetItem()
-            if i < len(lignesBase):
-                item.setText(QString.fromUtf8(lignesBase[i]))
-            item.setFlags(Qt.NoItemFlags)    
-            self.plateau.fenetre.ui.pi_listeAttributs.setItem(i, 0, item)
-            self.plateau.fenetre.ui.pi_listeAttributs.setRowHidden(i, (i >= len(lignesBase)))
-
-        #maj des donnees de base    
-        self.plateau.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Nom"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pion().nom))))
-        self.plateau.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Etat"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pion().etat))))
-        self.plateau.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Alt."), 1, QTableWidgetItem(QString.fromUtf8(str(self.pion().z))))
-        
-        #attributs issus des regles utilisees    
-        ordre = regles.ordreAttributs()
-        for elt in ordre:
-            ligne = 10 + ordre.index(elt)
-            self.plateau.fenetre.ui.pi_listeAttributs.insertRow(ligne)
-            item = QTableWidgetItem(QString.fromUtf8(elt))
-            item.setFlags(Qt.NoItemFlags)
-            self.plateau.fenetre.ui.pi_listeAttributs.setItem(ligne, 0, item)
-            self.plateau.fenetre.ui.pi_listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.pion().listeAttributs[elt]))))
-            
-        self.plateau.connect(self.plateau.fenetre.ui.pi_listeAttributs, SIGNAL("cellChanged(int,int)"), self.plateau.listeAttributCelluleModifiee)
-
-
-        ###affiche les notes du combattant
-        self.plateau.fenetre.ui.pi_notes.majTexte(self.pion().notes)
-
-
-        ###maj la liste des attaques du pion
-        #on vide la liste
-        while self.plateau.fenetre.ui.pi_listeAttaques.rowCount() > 0:
-            self.plateau.fenetre.ui.pi_listeAttaques.removeRow(0)
-
-        i = 0
-        for attaque in self.pion().attaques:
-            self.plateau.fenetre.ui.pi_listeAttaques.insertRow(i)
-            self.plateau.fenetre.ui.pi_listeAttaques.setItem(i, 0, QTableWidgetItem(QString.fromUtf8(str(self.pion().attaques.index(attaque)))))
-            icone = None
-            if attaque.typ == "cac":
-                icone = QIcon("img\\curseurEpee.png")
-            if attaque.typ == "dist":
-                icone = QIcon("img\\arc.png")
-            if attaque.typ == "zone":
-                icone = QIcon("img\\baguette.png")
-            if icone != None:
-                self.plateau.fenetre.ui.pi_listeAttaques.setItem(i, 1, QTableWidgetItem(icone, QString.fromUtf8("")))
-            self.plateau.fenetre.ui.pi_listeAttaques.setItem(i, 2, QTableWidgetItem(QString.fromUtf8(attaque.nom)))
-        self.plateau.majInfosAttaqueEC()  
-
+        self.plateau.majPanneauPi()
         super(PionSelectionne, self).activer()
 
-
     def desactiver(self):
+        if self._action:
+            self._action.desactiver()
+            self._action = None
         self.pion().afficheOmbreSelection(False)
-
-        #maj des infos dans le panneau pi
-        self.plateau.fenetre.ui.pi_img.clear()  
-        self.plateau.fenetre.ui.pi_nom.majTexte("Pas de pion\nselectionné")
-
-        #vide la liste des attributs
-        self.plateau.disconnect(self.plateau.fenetre.ui.pi_listeAttributs, SIGNAL("cellChanged(int,int)"), self.plateau.listeAttributCelluleModifiee)
-        while self.plateau.fenetre.ui.pi_listeAttributs.rowCount() > 0:
-            self.plateau.fenetre.ui.pi_listeAttributs.removeRow(0)        
-
-        #vide la liste des attaques du pion
-        while self.plateau.fenetre.ui.pi_listeAttaques.rowCount() > 0:
-            self.plateau.fenetre.ui.pi_listeAttaques.removeRow(0)
-        self.plateau.majInfosAttaqueEC()
-
+        self._num = None
+        self.plateau.majPanneauPi()
         super(PionSelectionne, self).desactiver()
 
+    def nouvelleAction(self, action):
+        self._action = action()
+        self._action.activer(self.plateau, self._num)
 
+    def survol_case(self, coord):
+        if self._action:
+            self._action.majCoordCible(coord)
 
+    def clic_case(self, coord):
+        if self._action:
+            self._action.valider()        
+           
+    def clicDroit(self):
+        if self._action:
+            self._action.desactiver()
+            self._action = None
+        else:
+            super(PionSelectionne, self).clicDroit(self)
 
 
 

lib/Plateau.py

@@ -453,6 +453,96 @@ class Plateau(QGraphicsScene):
         
     ###############
 
+    ############### maj des infos du panneau Pi a la selection/deselection d'un pion
+        #voir a balancer tout ca dans une classe a part
+
+    def majPanneauPi(self):
+        if self.pionSelectionne():
+            ### maj la selection dans la liste d'ordre de jeu
+            for i in range(0, self.fenetre.ui.inf_listeOrdreJeu.rowCount()):
+                if str(self.fenetre.ui.inf_listeOrdreJeu.item(i, 0).text().toUtf8()) == str(self.pionSelectionne().numero):
+                    self.fenetre.ui.inf_listeOrdreJeu.setCurrentCell(i,0)
+
+            ### maj des infos dans le panneau pi
+            self.fenetre.ui.pi_nom.majTexte(self.pionSelectionne().txtId())
+            self.fenetre.ui.pi_img.chargerImage("img\\"+self.pionSelectionne().img.nomFichier)
+
+            ### maj de la liste des attributs
+            self.fenetre.ui.pi_listeAttributs.setColumnWidth(0, 50)
+            self.disconnect(self.fenetre.ui.pi_listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee)
+            
+            #on vide la liste
+            while self.fenetre.ui.pi_listeAttributs.rowCount() > 0:
+                self.fenetre.ui.pi_listeAttributs.removeRow(0)
+
+            #creation des lignes de base    
+            lignesBase = ["Nom","Etat","Alt."]   #attention: modifier aussi dans listeAttributCelluleModifiee
+            for i in range(0, 10):    #10 premieres colonnes reservees pour les infos de base
+                self.fenetre.ui.pi_listeAttributs.insertRow(i)
+                item = QTableWidgetItem()
+                if i < len(lignesBase):
+                    item.setText(QString.fromUtf8(lignesBase[i]))
+                item.setFlags(Qt.NoItemFlags)    
+                self.fenetre.ui.pi_listeAttributs.setItem(i, 0, item)
+                self.fenetre.ui.pi_listeAttributs.setRowHidden(i, (i >= len(lignesBase)))
+
+            #maj des donnees de base    
+            self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Nom"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().nom))))
+            self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Etat"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().etat))))
+            self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Alt."), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().z))))
+            
+            #attributs issus des regles utilisees    
+            ordre = regles.ordreAttributs()
+            for elt in ordre:
+                ligne = 10 + ordre.index(elt)
+                self.fenetre.ui.pi_listeAttributs.insertRow(ligne)
+                item = QTableWidgetItem(QString.fromUtf8(elt))
+                item.setFlags(Qt.NoItemFlags)
+                self.fenetre.ui.pi_listeAttributs.setItem(ligne, 0, item)
+                self.fenetre.ui.pi_listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().listeAttributs[elt]))))
+                
+            self.connect(self.fenetre.ui.pi_listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee)
+            
+            ###affiche les notes du combattant
+            self.fenetre.ui.pi_notes.majTexte(self.pionSelectionne().notes)
+
+            ###maj la liste des attaques du pion
+            #on vide la liste
+            while self.fenetre.ui.pi_listeAttaques.rowCount() > 0:
+                self.fenetre.ui.pi_listeAttaques.removeRow(0)
+                
+            i = 0
+            for attaque in self.pionSelectionne().attaques:
+                self.fenetre.ui.pi_listeAttaques.insertRow(i)
+                self.fenetre.ui.pi_listeAttaques.setItem(i, 0, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().attaques.index(attaque)))))
+                icone = None
+                if attaque.typ == "cac":
+                    icone = QIcon("img\\curseurEpee.png")
+                if attaque.typ == "dist":
+                    icone = QIcon("img\\arc.png")
+                if attaque.typ == "zone":
+                    icone = QIcon("img\\baguette.png")
+                if icone != None:
+                    self.fenetre.ui.pi_listeAttaques.setItem(i, 1, QTableWidgetItem(icone, QString.fromUtf8("")))
+                self.fenetre.ui.pi_listeAttaques.setItem(i, 2, QTableWidgetItem(QString.fromUtf8(attaque.nom)))  
+
+        else:
+            #maj des infos dans le panneau pi
+            self.fenetre.ui.pi_img.clear()  
+            self.fenetre.ui.pi_nom.majTexte("Pas de pion\nselectionné")
+
+            #vide la liste des attributs
+            self.disconnect(self.fenetre.ui.pi_listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee)
+            while self.fenetre.ui.pi_listeAttributs.rowCount() > 0:
+                self.fenetre.ui.pi_listeAttributs.removeRow(0)        
+
+            #vide la liste des attaques du pion
+            while self.fenetre.ui.pi_listeAttaques.rowCount() > 0:
+                self.fenetre.ui.pi_listeAttaques.removeRow(0)
+                
+        self.majInfosAttaqueEC()
+
+
     ########### affichage des curseurs personnalises ########
     def curseurGomme(self):
         self.fenetre.ui.cbt_vue.setDragMode(0)
@@ -607,19 +697,23 @@ class Plateau(QGraphicsScene):
 
     def majModeCombatDeplacement(self):
         """active le mode de combat 'deplacement' (mode standard)"""
-        self.majModeCombat("combatDeplacement")
+        self.modeActif.nouvelleAction(Actions.Deplacement)
+##        self.majModeCombat("combatDeplacement")
 
     def majModeCombatAttaqueCaC(self):
         """active le mode de combat 'corps-a-corps'"""
-        self.majModeCombat("combatAttaqueCaC")
+        self.modeActif.nouvelleAction(Actions.Cac)
+##        self.majModeCombat("combatAttaqueCaC")
 
     def majModeCombatAttaqueDist(self):
         """active le mode de combat 'attaque a distance'"""
-        self.majModeCombat("combatAttaqueDist")
+        self.modeActif.nouvelleAction(Actions.Distance)
+##        self.majModeCombat("combatAttaqueDist")
 
     def majModeCombatZone(self):
         if not len(self.modeParam["typeAttaqueZone"]) > 0: self.modeParam["typeAttaqueZone"] = "ligne"
-        self.majModeCombat("combatAttaqueZone")        
+        self.modeActif.nouvelleAction(Actions.Ligne)
+##        self.majModeCombat("combatAttaqueZone")        
 
     def majModeCombatZoneForme(self):
         pass
@@ -1573,10 +1667,9 @@ class Plateau(QGraphicsScene):
     ######## interaction avec les cases, decors et pions  #############
     def pionSelectionne(self):
         """renvoie le pion actuellement selectionne"""
-        if self.modeParam["numPionSelectionne"] in self.combattants:
-            retour = self.combattants[self.modeParam["numPionSelectionne"]]
-        else:
-            retour = None
+        retour = None
+        if self.modeActif.__class__.__name__ == "PionSelectionne":
+            retour = self.modeActif.pion()
         return retour    
 
     def pionDecorSelectionne(self):

lib/ui/ecran_principal.py

@@ -2,7 +2,7 @@
 
 # Form implementation generated from reading ui file 'mainwindow.ui'
 #
-# Created: Fri May 29 17:43:56 2015
+# Created: Mon Jun 01 16:33:22 2015
 #      by: PyQt4 UI code generator 4.10.4
 #
 # WARNING! All changes made in this file will be lost!
@@ -1022,7 +1022,7 @@ class Ui_principal(object):
         self.pi_afficherNotes.setObjectName(_fromUtf8("pi_afficherNotes"))
         self.verticalLayout_8 = QtGui.QVBoxLayout(self.pi_afficherNotes)
         self.verticalLayout_8.setObjectName(_fromUtf8("verticalLayout_8"))
-        self.pi_notes = QtGui.QTextEdit(self.pi_afficherNotes)
+        self.pi_notes = DmTextEdit(self.pi_afficherNotes)
         self.pi_notes.setDocumentTitle(_fromUtf8(""))
         self.pi_notes.setObjectName(_fromUtf8("pi_notes"))
         self.verticalLayout_8.addWidget(self.pi_notes)
@@ -1349,7 +1349,7 @@ class Ui_principal(object):
         self.retranslateUi(principal)
         self.dm_panneauCentre.setCurrentIndex(0)
         self.cp_ongletsListes.setCurrentIndex(1)
-        self.pi_ongletsListes.setCurrentIndex(0)
+        self.pi_ongletsListes.setCurrentIndex(3)
         self.tabStatutAppli.setCurrentIndex(2)
         QtCore.QMetaObject.connectSlotsByName(principal)
 
@@ -1551,7 +1551,7 @@ class Ui_principal(object):
         self.actionParam_tres.setText(_translate("principal", "Paramètres", None))
         self.actionLexique.setText(_translate("principal", "Lexique", None))
 
-from dm import DmTableBiblio, DmGraphicsView, DmLabel
+from dm import DmTableBiblio, DmTextEdit, DmGraphicsView, DmLabel
 
 if __name__ == "__main__":
     import sys